@memizy/protocol 1.0.0-rc.5 → 1.0.0-rc.7

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog of @memizy/protocol
+
+The protocol has its own changelog at the end of [SPEC.md](https://github.com/memizy/memizy/blob/main/packages/protocol/SPEC.md#changelog) (protocol 1.0, 2026-10-14). This file lists the releases of the npm package.
+
+## 1.0.0-rc.7 (2026-10-16)
+
+* `InitPayload.seed`: a secret seed for the game's random numbers, only for the authority (SPEC 4.2, 8.4). Before, the SDK seeded `ctx.random` with the session id, which every device knows – a player could compute a shuffled deck.
+* Public items lose media that only hidden fields use (also in the public set's `meta.assets`); choice IDs are opaque to games, and a host may give per-session IDs (SPEC 4.4).
+* `prepareDisplaySet` shuffles each item with its own seed (the seed and the item ID): editing, adding or removing an item, or a part of a set, never changes the order of the other items (SPEC 4.4).
+* `recordAnswer` is an *authority* method (SPEC 5). The display order uses a secret, random seed (SPEC 4.4; not the session id).
+* SPEC: the Penpal 8 wire format (4); a host may give a game a part of a large set (4.2); answers to `open-ended` items do not change repetition, games record the first attempt (5.1); Zod: only `parse` / `safeParse` of the exported schemas are covered (9).
+* Public items keep only the fields the OQSE schema of their type lists (fail closed): unknown fields – also of choices, zones and other nested objects – and free-form `appSpecific` / `customData` are removed, so a field of a later OQSE version can never reveal an answer on players' devices (SPEC 4.4). Custom `x-` types keep their fields except `solution`.
+* Settings of a type from a later protocol version: a manifest may declare them (`UnknownSettingSchema`, needs `id`, `label`, `default`); `PluginRuntime.unknownSettings` lists them, `resolveSettings(definitions, input, unknownSettings)` gives them their default; `isKnownSetting`, `SETTING_TYPES`. `SettingValue` may be any JSON value.
+* `AnswerRecord.score` (partial credit 0–1).
+* SPEC: `InitPayload.set` holds the questions of this instance (4.2); the two axes of questions (10, decided); reserved: personal sets (`modes.multiplayer.sets`, feature `personal-sets`, `Player.set`), `pickItems`, `openSource`, `markItem` (10).
+
+## 1.0.0-rc.6 (2026-10-14)
+
+The contract of protocol 1.0 is final: within MAJOR 1 it changes only additively (SPEC 9).
+
+* SPEC status 1.0; the "RC4" labels are gone.
+* The address `"settings"` (`SETTINGS_ADDRESS`, the plugin's settings screen in the lobby) is defined in SPEC 3.1 and on the `Address` type.
+* `hello` is called once per instance: a second call rejects with `INVALID_ARGUMENT`. Only the first `end(result)` counts; later calls (also from a recreated authority) resolve and are ignored.
+* Guaranteed rates and sizes in SPEC 8.1 and `LIMITS`: `recordAnswer` 10 per second, burst 20 (`answersPerSecond`, `answerBurst`; the authority: per player), `getAsset` 10 per second, burst 20, and 2 MB per asset (`assetsPerSecond`, `assetBurst`, `assetBytes`), `reportError` 5 per second, burst 10, more dropped without an error (`errorReportsPerSecond`, `errorReportBurst`), and `serviceResultBytes` (256 KB, the service result limit that was already in the SPEC).
+* `RELAY_LIMITS.frameBytes` (in `@memizy/protocol/internal`) is 3 MB, so that a 2 MB asset fits a relay frame as base64.
+* Since 1.0.0-rc.5 (details in the SPEC changelog "1.0"): the term *host* (3.1) and `sessionEnded` before a player's instance is removed (`kicked`, `closed`, `host-left`); `exit`, `resize`, `setChanged` and `saveProgress` removed and reserved (SPEC 10); `InitPayload.services` and all `SessionClock` fields always present; the relay type `RoomPlayer`; state patches carry their format (`f`); reserved names `$…`, `data-mz-…`, `mz-…`; the `@memizy/protocol/internal` entry point (not public API); Zod 4 for the 1.x line; the error code `UNKNOWN_METHOD`; the sandbox allows popups that escape it (links in a new tab); `appSpecific.memizy.set`; OQSE 1.0 sets and OQSEM 1.0 manifests.
+
+## 1.0.0-rc.5
+
+Protocol RC4 as a package: handshake, views and authority, messages, learning progress, plugin data, services, pauses, permissions with a content policy, display order and public items, limits and errors.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 memizy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,16 +2,15 @@
 
 Types, Zod schemas and helpers of the **Memizy Plugin Protocol v1** – the contract between Memizy plugins (`@memizy/plugin-sdk`) and hosts (`@memizy/host-sdk`).
 
-* Specification: [SPEC.md](./SPEC.md) (Release Candidate 4)
-* Plugin authors do not use this package directly – see the [AI plugin guide](../../docs/ai-plugin-guide.md).
+* Specification: [SPEC.md](./SPEC.md) (1.0); changes of the package: [CHANGELOG.md](./CHANGELOG.md)
+* Plugin authors do not use this package directly – see the [AI plugin guide](https://github.com/memizy/memizy/blob/main/docs/ai-plugin-guide.md).
 
 ```ts
 import {
   readPluginManifestFromHtml, // validate a plugin's manifest data island without running it
   resolveSettings,            // apply defaults / validate setting values
   negotiateProtocolVersion,   // handshake version negotiation
-  parseHostCall,              // validate plugin → host calls
-  assertJsonWithin, LIMITS,   // size limits
+  LIMITS,                     // size and rate limits (SPEC 8.1)
   ProtocolError, toProtocolError,
   type HostApi, type PluginApi, type InitPayload,
 } from '@memizy/protocol';
@@ -19,3 +18,6 @@ import {
 const result = readPluginManifestFromHtml(html);
 if (result.success) console.log(result.runtime.views); // e.g. ['solo', 'board', 'controller']
 ```
+
+* **Public API** = what `@memizy/protocol` exports (semver within 1.x, SPEC 9). Helpers shared by the Memizy packages – call parsing (`parseHostCall`), size checks (`assertJsonWithin`), rate limiting, content policies of the iframe, relay limits – are in **`@memizy/protocol/internal`** and may change in any release.
+* The exported `*Schema` objects are Zod schemas: `parse` / `safeParse` are covered by semver, their Zod-specific API (`.extend`, `.shape`, the Zod major version) is not (SPEC 9). The functions (`safeParsePluginManifest`, `resolveSettings`, …) are the stable way to validate.

package/SPEC.md

@@ -1,8 +1,6 @@
 # Memizy Plugin Protocol v1
 
-> Status: **Release Candidate 4** (2026-10-07) · Final `1.0` after the acceptance test with AI-generated plugins (planned 2026-10-19/20).
->
-> RC rules: the design does not change unless the implementation or the acceptance test proves that something does not work. Every change until `1.0` is recorded in the changelog at the end.
+> Status: **1.0** (2026-10-14; protocol version `1.0`, packages `1.0.0`). The contract is frozen: within MAJOR `1` it changes only additively (section 9). Every change is recorded in the changelog at the end.
 
 This document defines the contract between a **Memizy plugin** (an HTML page running in a sandboxed iframe) and a **Memizy host** (the Memizy app, the Plugin Lab, or any other application embedding plugins through `@memizy/host-sdk`).
 
@@ -15,9 +13,9 @@ It covers:
 5. **message routing** for multiplayer,
 6. **limits, errors, security and compatibility rules**.
 
-It does **not** cover the high-level game API (`defineGame`) – that lives in `@memizy/plugin-sdk`, which every plugin bundles (see [the AI plugin guide](../../docs/ai-plugin-guide.md)). It also does not cover the host ↔ multiplayer-server wire protocol, which is internal to `@memizy/host-sdk`.
+It does **not** cover the high-level game API (`defineGame`) – that lives in `@memizy/plugin-sdk`, which every plugin bundles (see [the AI plugin guide](https://github.com/memizy/memizy/blob/main/docs/ai-plugin-guide.md)). It also does not cover the host ↔ multiplayer-server wire protocol, which is internal to `@memizy/host-sdk`.
 
-Data formats (sets, items, progress) are defined by [OQSE](../oqse/oqse.md).
+Data formats (sets, items, progress) are defined by [OQSE](https://github.com/memizy/memizy/blob/main/packages/oqse/oqse.md).
 
 ---
 
@@ -32,7 +30,7 @@ Data formats (sets, items, progress) are defined by [OQSE](../oqse/oqse.md).
 
 ## 2. Plugin Manifest
 
-The manifest is an [OQSEM](../oqse/oqse-manifest.md) document embedded in the plugin HTML as a data island. The host reads it **without executing the plugin** (registry, upload in the Lab).
+The manifest is an [OQSEM](https://github.com/memizy/memizy/blob/main/packages/oqse/oqse-manifest.md) document embedded in the plugin HTML as a data island. The host reads it **without executing the plugin** (registry, upload in the Lab).
 
 ```html
 <script type="application/oqse-manifest+json">
@@ -66,7 +64,7 @@ The manifest is an [OQSEM](../oqse/oqse-manifest.md) document embedded in the pl
 </script>
 ```
 
-The OQSEM part describes **content** (item types, assets, features) and is used for the [OQSE handshake](../oqse/oqse-manifest.md#the-handshake-matching-process) (`checkCompatibility`). The Memizy part (`appSpecific.memizy`) describes the **runtime**:
+The OQSEM part describes **content** (item types, assets, features) and is used for the [OQSE handshake](https://github.com/memizy/memizy/blob/main/packages/oqse/oqse-manifest.md#the-handshake-matching-process) (`checkCompatibility`). The Memizy part (`appSpecific.memizy`) describes the **runtime**:
 
 | Key | Type | Required | Description |
 | :--- | :--- | :--- | :--- |
@@ -80,9 +78,9 @@ The OQSEM part describes **content** (item types, assets, features) and is used
 | `settings` | SettingDefinition[] | No | Settings of the game (see below). Default `[]`. They define types, defaults and limits; the host validates every value against them. Used in both modes (section 3.3). |
 | `settingsScreen` | `{ size }` | No | Multiplayer lobby only. Present = the plugin renders its own settings screen (view `settings`) on the host's device; absent = the host generates a form from `settings`. `size: "compact"` – a panel next to the player list (the user may expand it to full screen); `size: "large"` – opened as a full-screen dialog from a "Game settings" button. |
 | `display.orientation` | `"any"` \| `"portrait"` \| `"landscape"` | No | Preferred orientation of player screens. Default `"any"`. |
-| `permissions.network` | string[] | No | RC4. Origins the plugin talks to with `fetch` / WebSocket, as `"https://host[:port]"` or `"wss://host[:port]"` (no path; max 20). Shown to users and enforced (section 8.4). |
-| `permissions.devices` | (`"camera"` \| `"microphone"` \| `"geolocation"` \| `"serial"` \| `"bluetooth"`)[] | No | RC4. Devices the plugin uses; the host grants only these (section 8.4). |
-| `services` | string[] | No | RC4. Memizy services the plugin calls (section 5.3), e.g. `"chess.puzzles"`: lowercase segments joined by dots. A host that does not offer one can still run the plugin; the call then fails with `SERVICE_UNAVAILABLE`. |
+| `permissions.network` | string[] | No | Origins the plugin talks to with `fetch` / WebSocket, as `"https://host[:port]"` or `"wss://host[:port]"` (no path; max 20). Shown to users and enforced (section 8.4). |
+| `permissions.devices` | (`"camera"` \| `"microphone"` \| `"geolocation"` \| `"serial"` \| `"bluetooth"`)[] | No | Devices the plugin uses; the host grants only these (section 8.4). |
+| `services` | string[] | No | Memizy services the plugin calls (section 5.3), e.g. `"chess.puzzles"`: lowercase segments joined by dots. A host that does not offer one can still run the plugin; the call then fails with `SERVICE_UNAVAILABLE`. |
 
 **SettingDefinition:** `{ id, type, label, default, description?, modes?, ...typeSpecific }`
 
@@ -97,6 +95,8 @@ The OQSEM part describes **content** (item types, assets, features) and is used
 
 `label`, `description` and option labels are either a string or a map of BCP 47 language → string (e.g. `{ "cs": "Čas", "en": "Time" }`).
 
+**Setting types from later versions:** a later 1.x version may add setting types. A host that does not know a type does not show the setting, ignores values sent for it (`updateSettings`) and passes its `default` (any JSON value) to the plugin. So a plugin may use a new setting type without requiring the newer protocol version, as long as it works with the default; the `type` is a lowercase name (`^[a-z][a-z0-9-]*$`), and the setting still needs `id`, `label` and `default`.
+
 Reserved for later minor versions: `teams`, editing permissions.
 
 ---
@@ -107,18 +107,19 @@ Reserved for later minor versions: `teams`, editing permissions.
 
 | Term | Meaning |
 | :--- | :--- |
+| **Host** | The application that embeds the plugin on a device and connects it to the session (the Memizy app, the Plugin Lab, on a player's device the player's app). A plugin only ever talks to its host; how a host connects the devices of a session is the host's business. |
 | **Session** | One run of a game, from start to end (e.g., one quiz in a lesson). |
 | **Mode** | `solo` (one person plays alone) or `multiplayer` (several devices together). |
 | **Host role** (`hostAs`) | In multiplayer, the role of the person who created the session: `presenter` (shows a shared board, e.g. a teacher at a projector, and does not play) or `player` (plays like everyone else, no board). A plugin may support both; the host chooses in the lobby. |
 | **Instance** | One running plugin iframe on one device. 30 phones + 1 projector = 31 instances. |
 | **View** | What one instance shows: `solo`, `board` (the presenter's shared screen), `controller` (one player's own screen – a phone, tablet or computer) or `settings` (the plugin's settings screen on the host's device in the multiplayer lobby). Views are derived from the manifest (section 3.2), not declared separately. |
 | **Player** | A person who plays and can score. The presenter is not a player. |
-| **Address** | The "envelope address" of an instance, used to route messages (section 6): the player ID for a player's instance (stable across reconnects), `"board"` for the presenter's board. The address `"server"` is **reserved** for a future server-side authority. Plugin authors never see addresses; the SDK exposes only player IDs. |
+| **Address** | The "envelope address" of an instance, used to route messages (section 6): the player ID for a player's instance (stable across reconnects), `"board"` for the presenter's board, `"settings"` (`SETTINGS_ADDRESS`) for the plugin's settings screen in the lobby. The address `"server"` is **reserved** for a future server-side authority. Plugin authors never see addresses; the SDK exposes only player IDs. |
 | **Authority** | The one place that owns the game state and applies actions: the board (`presenter`), the host's controller (host as `player`) or the only instance (`solo`). Other instances send actions to it and receive the new state. In a future version the authority may be the server (address `"server"`); this is why game logic must be deterministic. |
 | **State** | The whole state of the game: one JSON value owned by the authority; its content is defined by the plugin. |
 | **Action** | An intent of a player or a timer (e.g., "answered B"). Only actions change the state. |
 | **Snapshot** | A saved copy of the authority's state (including pending timers), used to resume the game when the authority instance is recreated (reload, crash). Late joiners and reconnecting players do not use it; they synchronize with the running authority. |
-| **Learning progress** | Per-item learning records of a player in [OQSEP](../oqse/oqse-progress.md) (buckets, review dates). Understood and scheduled by the host. |
+| **Learning progress** | Per-item learning records of a player in [OQSEP](https://github.com/memizy/memizy/blob/main/packages/oqse/oqse-progress.md) (buckets, review dates). Understood and scheduled by the host. |
 | **Plugin data** | Game progress of a player that only the plugin understands (unlocked levels, coins, best scores). Stored by the host, opaque to it (section 5.2). |
 
 | Situation | Instances (views) | Authority |
@@ -144,7 +145,7 @@ A plugin does not declare views. They follow from what it declares, so the two c
 
 **Multiplayer:**
 
-1. **Lobby** (host UI). The host chooses the plugin and the set; players join and may rename themselves. The settings are edited by the host: either in a form generated from `settings`, or – if the manifest declares `settingsScreen` – in the plugin itself running in view `settings` on the host's device (the plugin calls `updateSettings` and receives `playersChanged`). Start is enabled only while the settings are valid.
+1. **Lobby** (host UI). The host chooses the plugin and the set; players join. Player names are display names chosen by the host app – Memizy Play gives every player a random nickname and does not ask for real names (privacy of students); a host may let players change it. Names may change during the game (`playersChanged`). Plugins MUST NOT ask players for their real names or other personal data; a game that needs a name uses `Player.name`. The settings are edited by the host: either in a form generated from `settings`, or – if the manifest declares `settingsScreen` – in the plugin itself running in view `settings` on the host's device (the plugin calls `updateSettings` and receives `playersChanged`). Start is enabled only while the settings are valid.
 2. **Loading.** After Start, the host creates the game instances (board and/or controllers). Each instance connects, receives its `InitPayload` (without game state) and calls `ready()`.
 3. **Countdown.** When all connected instances are ready (or after a host-defined timeout, e.g. 15 s), the host shows a countdown and then calls `start()` on the authority. The authority creates the initial state and the game runs. The barrier exists so that timed games do not start before slower devices have loaded.
 4. **Running.** Late joiners (if `lateJoin`) and reconnecting players get a new instance, which synchronizes with the authority. A recreated authority receives the last `snapshot` and continues without `start()`. While the authority is unreachable, see section 6.1.
@@ -152,6 +153,8 @@ A plugin does not declare views. They follow from what it declares, so the two c
 
 **Solo:** one instance in view `solo`. There is **no plugin settings screen and no countdown**. Before creating the instance, the host MAY show a form generated from the settings that apply to solo (`modes`); otherwise it uses the defaults or values it presets (e.g. a course step "practise this set with 10 questions"). It calls `start()` right after `ready()`. Choices that belong to the game itself (a level, a character) are made inside the game, typically as its first phase.
 
+**Continuing a saved game** (a host feature; nothing changes for plugins). A host may save a game that has not ended – the authority's last snapshot, the settings, the display-order seed (4.4) and the players – and continue it later, in multiplayer also in a new room with other devices. The continued session keeps the same session ID and the same player IDs, so the game state stays valid: the authority is recreated from the snapshot (`InitPayload.snapshot`, no `start()`), the session starts paused (`SessionClock`, so the time between the lessons does not count), and each device takes the place of one earlier player (the host decides how; Memizy Play lets the player pick the earlier nickname and the teacher change it). A place without a device is a disconnected player (6). A game that ended with `end(result)` cannot be continued (its snapshot is discarded, 5). A continued game uses **the same set** (and the same display-order seed): the game state refers to its items. Continuing with another or an edited set is a set change that only games supporting it get (planned, section 10, `setChanged`).
+
 ---
 
 ## 4. Handshake
@@ -160,6 +163,19 @@ The connection uses [Penpal](https://github.com/Aaronius/penpal) over `postMessa
 
 **Transport.** Within MAJOR version 1 the connection is Penpal 8 over `postMessage`, with the method names of sections 5 and 7. Implementations may update Penpal (including security fixes) only to versions that speak the same wire protocol: an older host must still connect to a newer plugin and the other way round. Penpal 8 needs `Promise.withResolvers` and `Object.hasOwn`; on older browsers the host and the SDK add them before connecting.
 
+**Wire format** (Penpal 8, for implementations without the library). Every message is a plain object with `namespace: "penpal"` (and `channel`, which Memizy does not set):
+
+| Message | Fields | Meaning |
+| :--- | :--- | :--- |
+| `SYN` | `participantId` (a random string) | Both sides send it with `window.postMessage(message, "*")` until they have received the other's `SYN`. |
+| `ACK1` | – | Sent by the side whose `participantId` is greater (string comparison). |
+| `ACK2` | – | The answer to `ACK1`; it transfers a `MessagePort` (`postMessage(message, origin, [port])`). From now on both sides use only this port. |
+| `CALL` | `id` (string, unique per sender), `methodPath` (`["hello"]`, a one-element array with the method name of section 5 or 7), `args` (array) | A method call. |
+| `REPLY` | `callId` (= the `id` of the call), `value` | The result. On failure also `isError: true` and, for an `Error`, `isSerializedErrorInstance: true` with `value: { name, message, stack, penpalCode }` (`penpalCode` `METHOD_NOT_FOUND` = the method does not exist, section 8.2). |
+| `DESTROY` | – | The other side closed the connection. |
+
+Values are copied with the structured clone algorithm (JSON values, and `Blob` for `getAsset`). A rejected call's error message starts with the error code in brackets, `"[CODE] text"` (section 8.2). A receiver accepts window messages only from the expected window (the iframe's `contentWindow`, or the parent).
+
 1. The host creates the iframe and starts listening.
 2. The plugin (SDK) connects and calls `hello(handshake)` within **10 s**.
 3. The host validates the handshake and returns an `InitPayload` or rejects with a `ProtocolError`.
@@ -196,25 +212,26 @@ interface InitPayload {
   };
 
   players: Player[];                    // current roster (presenter is not a player)
-  set: {
+  set: {                                // the questions of THIS instance (see below)
     meta: OQSEMeta;
     items: OQSEAnyItem[];               // only types the plugin declared, in display order (4.4); public items for non-authority instances in multiplayer
   };
   settings: Record<string, unknown>;    // current values for every declared setting (defaults applied)
   config: { locale: string; theme: 'light' | 'dark' };
   clock: SessionClock;                  // session clock and pauses (below)
-  services?: string[];                  // RC4: services declared by the plugin AND offered by this host
+  services: string[];                   // services declared by the plugin AND offered by this host
   progress: Record<string, ProgressRecord>;  // learning progress of `self` (empty for board/settings)
   data: { plugin: unknown; set: unknown };   // plugin data of `self` (null when nothing saved; null for board/settings)
   snapshot: unknown | null;             // last saved snapshot, only for the authority (resume)
+  seed?: string;                        // only for the authority: the secret seed of the game's random numbers
 }
 
-type Address = string;                  // player ID, "board"; "server" is reserved
+type Address = string;                  // player ID, "board", "settings"; "server" is reserved
 
 interface SessionClock {
   offsetMs: number;                     // Date.now() + offsetMs = session time
-  pausedMs?: number;                    // RC4: total of finished pauses
-  pausedAt?: number | null;             // RC4: session time when the current pause began (null = running)
+  pausedMs: number;                     // total of finished pauses
+  pausedAt: number | null;              // session time when the current pause began (null = running)
 }
 // Game time = (pausedAt ?? session time) - pausedMs. The SDK uses game time for ctx.now,
 // timers and countdowns, so a pause stops them everywhere and nothing jumps afterwards.
@@ -227,23 +244,28 @@ interface Player {
 }
 ```
 
+**The seed of the game rules:** the host gives the authority a random `seed` (at least 128 bits of entropy, e.g. 32 hex digits) that no other instance gets. The SDK seeds `ctx.random` / `ctx.shuffle` with it, so players cannot compute a shuffled deck or the next draw from data they have (the session `id` is known to every instance). A resumed authority continues from the generator state in its snapshot; a host that records a game for replay keeps the seed with it.
+
+**The set of an instance:** `set` holds the questions this instance plays with. In 1.0 every instance of a session gets the same set (the authority and solo with answers, the others as public items, section 4.4). A host MAY give a game only a part of a large set (e.g., a lesson's items, or the items due for review); the game plays with what it gets. Plugins MUST NOT assume more than that: a later version may let players bring their own sets (planned in section 10, "Personal sets"), and then the set of each player's instance can differ – a plugin opts in to that in its manifest, so 1.0 plugins never see it.
+
 **Assets:** every `MediaObject.value` in `set` is either an absolute `https:` URL, or a host-relative key that the SDK resolves with `getAsset` (section 5). The host never passes `blob:` URLs, because an opaque-origin iframe cannot load the host's blob URLs.
 
 ### 4.3 Version negotiation
 
 * A host supports a set of protocol versions, one per MAJOR version (e.g. `1.4` and `2.1`). The plugin's MAJOR version must be one of them. Otherwise the host rejects with `ProtocolError { code: 'UNSUPPORTED_PROTOCOL' }` and shows the user a clear message ("this plugin needs a newer Memizy" or "this plugin is too old").
 * The negotiated version has the plugin's MAJOR and the lower of both MINOR versions. Neither side uses a method, field or feature introduced in a higher minor than the negotiated one.
-* A plugin that uses a field, value, method or setting type introduced in protocol 1.*x* declares `protocol: "1.x"` in its manifest (the minimum version it needs). A host that supports only an older minor version then rejects it before loading, instead of misreading what it does not know.
-* `manifest.appSpecific.memizy.protocol` is checked **before** loading the iframe (the host does not offer plugins it cannot run). The manifest itself (`version`, the OQSEM format) follows the [OQSE version rules](../oqse/oqse.md#versioning-and-compatibility): the host reads the OQSEM MAJOR versions it supports.
+* A plugin that uses a field, value or method introduced in protocol 1.*x* declares `protocol: "1.x"` in its manifest (the minimum version it needs). Setting types are the exception: older hosts pass their default (section 2). A host that supports only an older minor version then rejects it before loading, instead of misreading what it does not know.
+* `manifest.appSpecific.memizy.protocol` is checked **before** loading the iframe (the host does not offer plugins it cannot run). The manifest itself (`version`, the OQSEM format) follows the [OQSE version rules](https://github.com/memizy/memizy/blob/main/packages/oqse/oqse.md#versioning-and-compatibility): the host reads the OQSEM MAJOR versions it supports.
 * A host SHOULD keep supporting older MAJOR versions as long as practical (e.g. an adapter in `@memizy/host-sdk`), so older plugins keep working.
 
 ### 4.4 Display order and hidden answers
 
 The host prepares the set once per session (`prepareDisplaySet` in `@memizy/protocol`; a future server authority does the same):
 
-1. **Display order.** With a seed (normally the session id), the host shuffles `options` (mcq, unless `shuffle: false`), the options of `fill-in-select` blanks (unless `shuffle: false`), `items` of `sort-items` (never left in the correct order), `prompts` and `matches` of `match-pairs`, the sides of `match-complex`, `events` of `timeline` (unless `shuffle: false`; never left in chronological order), the entries of `categorize` and the `labels` of `diagram-label` (unless `requireTyping`). OQSE answers refer to choice IDs, so shuffling never changes an answer. Every instance sees the same order.
-2. **Public items.** In multiplayer, every instance except the authority gets the items without the fields that give the answer away and with `answerHidden: true`: `explanation`, `incorrectFeedback`, the `explanation` of every choice, `correctId`, `correctIds`, `correctAnswer(s)`, `alternativeAnswers`, `correctOrder`, `pairs`, `connections`, `correctCells`, `correctCategoryId`, zone `correctLabelId` (and the labels when `requireTyping`), the accepted texts of `fill-in-blanks`, the `correctId` of select blanks, event `date`s, `hotspots` of pin items, `back` of a flashcard, `hiddenContent` of a note, `sampleAnswer`, `rubric` and the `quote` of every source (`sources[].quote`, which often states the answer). Custom `x-` types lose `solution` (OQSE puts everything that gives their answer away there), `explanation` and `incorrectFeedback`, and also get `answerHidden: true`. `hints` stay public: a game may show them on any device while the player answers. In relay multiplayer the bundle on the server holds only public items.
-3. **Revealing.** The authority sends full items to the other instances in its own messages (the plugin SDK's `ctx.reveal`); the host does not take part.
+1. **Display order.** With a **secret** seed (random per game, kept by the host), the host shuffles `options` (mcq, unless `shuffle: false`), the options of `fill-in-select` blanks (unless `shuffle: false`), `items` of `sort-items` (never left in the correct order), `prompts` and `matches` of `match-pairs` and `match-complex`, `events` of `timeline` (unless `shuffle: false`; never left in chronological order), the entries of `categorize` and the `labels` of `diagram-label` (unless `requireTyping`). OQSE answers refer to choice IDs, so shuffling never changes an answer. Every instance sees the same order. **Each item is shuffled on its own**, with a generator seeded by the seed and the item's ID, so editing, adding or removing an item – or giving a game only part of a set – never changes the order of the other items. The seed MUST NOT be derived from anything the instances know (such as the session id): authors often write a set in the answer's order (the correct order of `sort-items` or `timeline`, prompt *i* with match *i*), so a player who could repeat the shuffle could undo it and read the answer. Instances get the shuffled items and never need the seed; a host that continues a saved game uses the same seed again.
+2. **Public items.** In multiplayer, every instance except the authority gets the items without the fields that give the answer away and with `answerHidden: true`: `explanation`, `incorrectFeedback`, the `explanation` of every choice, `correctId`, `correctIds`, `correctAnswer(s)`, `correctOrder`, `pairs`, `connections`, `correctCells`, `correctCategoryId`, zone `correctLabelId` (and the labels when `requireTyping`), the accepted texts of `fill-in-blanks`, the `correctId` of select blanks, event `date`s, `hotspots` of pin items, `back` of a flashcard, `hiddenContent` of a note, `sampleAnswer`, `rubric` and the `quote` of every source (`sources[].quote`, which often states the answer). Custom `x-` types lose `solution` (OQSE puts everything that gives their answer away there), `explanation` and `incorrectFeedback`, and also get `answerHidden: true`. `hints` stay public: a game may show them on any device while the player answers. Media (`assets`) that only removed fields refer to (the back of a flashcard, an explanation) are removed too, from the item and from the set's `meta.assets`, and a non-authority instance can fetch only media of its own items (`getAsset`). **Public items of official types keep only the fields the host knows are not part of the answer** (OQSE "Hiding answers safely"): every other field – a field from a newer OQSE version, a vendor key, an unknown field of a choice or another nested object, free-form `appSpecific` and `customData` – is removed, so that unknown data never reveals an answer. A host that sends the game to other devices sends only public items.
+3. **Choice IDs are opaque to games.** A host MAY give the instances of a session per-session IDs for choices instead of the set's IDs (the same on every instance; it maps recorded answers back to the set's IDs), e.g. because a set's IDs give the answer away (`"correct"`, or `"a"` for an answer written first). Games MUST NOT compare choice IDs with IDs written in their code; they compare answers only through `checkAnswer` and the items they get.
+4. **Revealing.** The authority sends full items to the other instances in its own messages (the plugin SDK's `ctx.reveal`); the host does not take part.
 
 Solo instances and the authority get the full items in display order.
 
@@ -255,32 +277,30 @@ All methods return Promises and reject with a `ProtocolError` (section 8.2). Met
 
 | Method | Description |
 | :--- | :--- |
-| `hello(handshake): InitPayload` | Handshake (section 4). Called exactly once. |
+| `hello(handshake): InitPayload` | Handshake (section 4). Called exactly once per instance; a second call rejects with `INVALID_ARGUMENT`. |
 | `ready(): void` | The plugin is rendered and interactive. |
 | `send(message: OutgoingMessage): void` | Sends a game message to other instances (section 6). |
-| `saveSnapshot(snapshot: unknown): void` | *authority.* Stores the latest resumable game state (overwrites the previous one). Returned as `InitPayload.snapshot` when the authority instance is recreated (reload, crash, reconnect). |
-| `recordAnswer(answer: AnswerRecord): void` | Records a learning result. The host applies its learning algorithm and stores the result in the learning progress of the given player (routing it to that player's device in multiplayer). |
-| `saveProgress(records: Record<string, ProgressRecord>): void` | *views `solo`, `controller`.* Overwrites learning progress records of `self` directly (plugins with their own rating, e.g. "traffic light" self-rating). |
+| `saveSnapshot(snapshot: unknown): void` | *authority.* Stores the latest resumable game state (overwrites the previous one). Returned as `InitPayload.snapshot` when the authority instance is recreated (reload, crash, reconnect). After `end(result)` the host discards the snapshot: a finished game is not resumed. |
+| `recordAnswer(answer: AnswerRecord): void` | *authority.* Records a learning result. The host applies its learning algorithm and stores the result in the learning progress of the given player (routing it to that player's device in multiplayer). Only the authority records: it has the answers and checks them – another instance could not prove an answer, and a modified player's device must not be able to write "correct" into a teacher's statistics. |
 | `saveData(scope: 'plugin' \| 'set', value: unknown): void` | *views `solo`, `controller`.* Replaces the plugin data of `self` in the given scope (section 5.2). |
 | `updateSettings(update: { values: Record<string, unknown>; valid: boolean; message?: string }): void` | *view `settings`.* Replaces the settings values. The host validates them against the manifest schema; `valid: false` disables Start and shows `message`. |
 | `getAsset(key: string, itemId?: string): Blob` | Raw data of an asset (resolution: item assets, then set assets). |
-| `end(result: SessionResult): void` | *authority.* The game is over. The host shows/stores the result; instances stay open until the host closes them. |
-| `resize(request: { height: number \| 'auto' }): void` | Requests a different iframe height (embedded layouts). |
-| `reportError(error: { code: string; message: string; context?: object }): void` | Non-fatal error for logs and the Lab test report. |
-| `exit(): void` | The user wants to leave (e.g. a "Close" button inside the plugin). |
-| `service(name: string, payload: unknown): unknown` | RC4. Calls a Memizy service (section 5.3). Rejects with `SERVICE_UNAVAILABLE` unless the plugin declares it and `InitPayload.services` lists it. |
+| `end(result: SessionResult): void` | *authority.* The game is over. The host shows/stores the result; instances stay open until the host closes them. Only the first call counts: later calls (also from a recreated authority) resolve and are ignored. |
+| `reportError(error: { code: string; message: string; context?: object }): void` | Non-fatal error for logs and the Lab test report. Reports beyond the rate in section 8.1 are dropped without an error. |
+| `service(name: string, payload: unknown): unknown` | Calls a Memizy service (section 5.3). Rejects with `SERVICE_UNAVAILABLE` unless the plugin declares it and `InitPayload.services` lists it. |
 
 ```ts
 interface AnswerRecord {
-  playerId?: string;          // default: self. The authority may record for any player.
+  playerId?: string;          // default: self (the authority as a player: solo, or the host playing along); required on the board
   itemId: string;
   isCorrect: boolean;
   confidence?: 1 | 2 | 3 | 4;
   timeSpentMs?: number;
   hintsUsed?: number;
   isSkipped?: boolean;
-  answer?: unknown;           // RC4: what the player answered (checkAnswer format, choice IDs; max 4 KB)
-  item?: { id: string; type: string; [key: string]: unknown };  // RC4: required for an item that is not in the set
+  score?: number;             // partial credit 0–1 (e.g. 2 of 3 pairs); isCorrect stays the pass/fail outcome
+  answer?: unknown;           // what the player answered (checkAnswer format, choice IDs; max 4 KB)
+  item?: { id: string; type: string; [key: string]: unknown };  // required for an item that is not in the set
 }
 
 interface SessionResult {
@@ -291,14 +311,14 @@ interface SessionResult {
 
 ### 5.1 Learning progress
 
-Two ways to write it:
-
-* **`recordAnswer`** – the plugin reports what happened ("player X answered item Y correctly"). The host decides the new bucket and review date with its own algorithm. This is what most plugins use, in solo and in multiplayer.
-* **`saveProgress`** – the plugin writes records of its own player directly (e.g., self-rating sets bucket 3). Only for `self`, never for other players.
+Plugins write it with **`recordAnswer`**: the plugin reports what happened ("player X answered item Y correctly"); the host decides the new bucket and review date with its own algorithm. A self-rating (a flashcard) is an answer too (OQSE Answer Formats). Writing progress records directly is reserved (`saveProgress`, section 10).
 
-RC4 additions to `recordAnswer`:
+What `recordAnswer` carries besides the result:
 
-* `answer` – what the player answered, in the format of the item type defined in [OQSE Answer Formats](../oqse/oqse.md#answer-formats) (the format `checkAnswer` takes: choice IDs, text, numbers; a flashcard's self-rating 1–4). Teachers see which wrong answers were chosen; because answers use IDs, the statistics survive edits of the set.
+* `answer` – what the player answered, in the format of the item type defined in [OQSE Answer Formats](https://github.com/memizy/memizy/blob/main/packages/oqse/oqse.md#answer-formats) (the format `checkAnswer` takes: choice IDs, text, numbers; a flashcard's self-rating 1–4). Teachers see which wrong answers were chosen; because answers use IDs, the statistics survive edits of the set.
+* `score` – partial credit between 0 and 1 for items that allow it (OQSE `pedagogy.partialCredit`, e.g. 2 of 3 correct pairs = `0.67`). `isCorrect` stays the outcome used for repetition; `score` is for statistics. The plugin computes it (`checkAnswer` returns only right or wrong).
+* **Answers that are not checked automatically** (`open-ended`, OQSE Answer Formats): the plugin records the `answer`; `isCorrect` is ignored. The host keeps the answer for a teacher (or an evaluator) and does not change the repetition schedule.
+* **One answer per question and player:** a game that lets a player try again records the **first** attempt (that is what repetition needs); later attempts are part of the game.
 * **Generated items** (from a service or a generator in the plugin) are not in the set. The plugin attaches the item (`item`, at least `id` and `type`; answer fields may be left out; max 32 KB). The host counts such answers in statistics (per `skills` and `tags`) but not in the repetition schedule, because the item never comes back.
 * Progress for teachers is aggregated per OQSE `skills` (and their parents, `chess.tactics` for `chess.tactics.fork`), which come from the content, never from the plugin. A game's own model of the player (rating, level, unlocked chapters) belongs to plugin data (section 5.2).
 
@@ -354,7 +374,7 @@ If the authority instance loses its connection or is being recreated (e.g., the
 
 * The host calls `authorityChanged({ connected: false })` on all other instances and shows them a "Waiting for the host…" overlay. Messages sent `to: 'authority'` meanwhile are rejected with `AUTHORITY_UNAVAILABLE` (the SDK does not queue them).
 * When the authority is back (resumed from its snapshot), the host calls `authorityChanged({ connected: true })`; the other instances re-synchronize with it.
-* If the authority does not come back within a host-defined time, the host ends the session (`sessionEnded('host_left')`). Handing the game over to another player is a future feature (section 10).
+* If the authority does not come back within a host-defined time, the host ends the session (`sessionEnded('host-left')`). Handing the game over to another player is a future feature (section 10).
 
 ---
 
@@ -366,10 +386,9 @@ If the authority instance loses its connection or is being recreated (e.g., the
 | `deliver(message: IncomingMessage): void` | A game message from another instance. |
 | `playersChanged(players: Player[]): void` | The roster changed (join, leave, rename, connection status). Always the full list. |
 | `authorityChanged(status: { connected: boolean }): void` | The authority became unreachable / reachable again (section 6.1). Not called on the authority itself. |
-| `setChanged(set: { meta, items }): void` | The set was edited in the host while the plugin runs (solo only). |
 | `configChanged(config: { locale, theme }): void` | Locale or theme changed. |
-| `clockChanged(clock: SessionClock): void` | Clock synchronization updated, or (RC4) the host paused / resumed the game. While `pausedAt` is set the SDK stops game time and timers, ignores actions and covers the game with a "paused" curtain. |
-| `sessionEnded(reason: 'finished' \| 'host_left' \| 'kicked' \| 'closed' \| 'error'): void` | The host is closing this instance. |
+| `clockChanged(clock: SessionClock): void` | Clock synchronization updated, or the host paused / resumed the game. While `pausedAt` is set the SDK stops game time and timers, ignores actions and covers the game with a "paused" curtain. |
+| `sessionEnded(reason: 'finished' \| 'host-left' \| 'kicked' \| 'closed' \| 'error'): void` | The host is closing this instance. |
 
 ---
 
@@ -382,13 +401,17 @@ The values are **guaranteed minimums**: a host MUST accept at least this much an
 | Limit | Guaranteed minimum | When exceeded |
 | :--- | :--- | :--- |
 | `send` message size (serialized JSON) | 64 KB | `MESSAGE_TOO_LARGE` |
-| `send` rate per instance | 30 messages/s (burst 60); the authority: 30 messages/s **per other instance** (RC4: it sends each device its own view) | `RATE_LIMITED` |
+| `send` rate per instance | 30 messages/s (burst 60); the authority: 30 messages/s **per other instance** (it sends each device its own view) | `RATE_LIMITED` |
 | `saveSnapshot` size | 1 MB | `SNAPSHOT_TOO_LARGE` |
 | `saveSnapshot` rate | 2 per second (the host keeps the latest) | coalesced, no error |
 | `saveData` size per scope | 256 KB | `DATA_TOO_LARGE` |
 | `saveData` rate | 1 per second per scope (the host keeps the latest) | coalesced, no error |
 | `hello` deadline | 10 s after iframe load | the host shows an error |
 | `recordAnswer` answer / generated item | 4 KB / 32 KB | `DATA_TOO_LARGE` |
+| `recordAnswer` rate per instance | 10 per second (burst 20); the authority: 10 per second **per player** (it records for everyone) | `RATE_LIMITED` |
+| `getAsset` size | 2 MB per asset | `DATA_TOO_LARGE` |
+| `getAsset` rate per instance | 10 per second (burst 20) | `RATE_LIMITED` |
+| `reportError` rate per instance | 5 per second (burst 10) | dropped, no error |
 | `service` request / result | 64 KB / 256 KB | `MESSAGE_TOO_LARGE` |
 | `service` rate per instance | 30 calls/min | `RATE_LIMITED` |
 
@@ -415,7 +438,8 @@ interface ProtocolError {
 | `ASSET_NOT_FOUND` | `getAsset` with an unknown key. |
 | `SESSION_ENDED` | A call after `sessionEnded`. |
 | `INTERNAL_ERROR` | A host-side failure; the plugin may retry. |
-| `SERVICE_UNAVAILABLE` | RC4. The service is not declared by the plugin or not offered by this host. |
+| `SERVICE_UNAVAILABLE` | The service is not declared by the plugin or not offered by this host. |
+| `UNKNOWN_METHOD` | The other side does not have the method (an older or newer version). Methods added in 1.x are guarded by a feature (9), so a plugin sees this only by mistake. |
 
 New codes may be added in minor versions; plugins MUST treat unknown codes like `INTERNAL_ERROR`.
 
@@ -425,12 +449,12 @@ New codes may be added in minor versions; plugins MUST treat unknown codes like
 
 ### 8.4 Security
 
-* The iframe is sandboxed with `allow-scripts allow-forms allow-modals allow-pointer-lock` – **never** `allow-same-origin`. As a consequence, browser storage (`localStorage`, IndexedDB) is not available to plugins; they use plugin data (section 5.2).
+* The iframe is sandboxed with `allow-scripts allow-forms allow-modals allow-pointer-lock allow-popups allow-popups-to-escape-sandbox` – **never** `allow-same-origin` and never `allow-top-navigation`. Popups are allowed so that links open in a new tab (the plugin SDK opens every external link there; inside the iframe a link would replace the game). As a consequence, browser storage (`localStorage`, IndexedDB) is not available to plugins; they use plugin data (section 5.2).
 * The host validates every incoming call against the schemas in `@memizy/protocol` and the limits above.
 * The host never passes credentials, user e-mail or other private data. `Player.name` is the display name chosen for the session.
-* Answers are known only to the authority (section 4.4). Everything else a plugin puts in the game state or in messages is visible to every instance: do not put secrets there.
-* **Network (RC4).** The host puts a Content Security Policy into the plugin document (`pluginContentPolicy` in `@memizy/protocol`): scripts only inline, from the library CDNs (`cdn.jsdelivr.net`, `unpkg.com`, `cdnjs.cloudflare.com`, `esm.sh`) and from the host; `fetch`, WebSocket and similar only to these and to the origins in `permissions.network`. Images and media may come from any `https:` URL (sets link them), so the policy blocks data channels but not every possible leak; hosts show the declared origins to users ("this game talks to lichess.org").
-* **Devices (RC4).** The iframe `allow` attribute grants only `permissions.devices`; the browser still asks the user.
+* Answers are known only to the authority (section 4.4), and so are the seed of the game's random numbers (section 4.2) and the seed of the display order (the host's, section 4.4). Everything else a plugin puts in the game state or in messages is visible to every instance: do not put secrets there.
+* **Network.** The host puts a Content Security Policy into the plugin document (`pluginContentPolicy` in `@memizy/protocol`): scripts only inline, from the library CDNs (`cdn.jsdelivr.net`, `unpkg.com`, `cdnjs.cloudflare.com`, `esm.sh`) and from the host; `fetch`, WebSocket and similar only to these and to the origins in `permissions.network`. Images and media may come from any `https:` URL (sets link them), so the policy blocks data channels but not every possible leak; hosts show the declared origins to users ("this game talks to lichess.org").
+* **Devices.** The iframe `allow` attribute grants only `permissions.devices`; the browser still asks the user.
 
 ---
 
@@ -446,7 +470,9 @@ From `1.0` on, the following MUST NOT change in a backward-incompatible way with
 
 Allowed in `1.x`: new optional fields, new methods guarded by a feature, new setting types, new enum values only where the receiver is required to ignore unknown values (`sessionEnded` reasons, error codes, `Player` fields).
 
-* The plugin SDK sends its own game messages inside `send` / `deliver` (actions, state and state patches, reveals). Their format is part of the SDK's contract: within SDK 1.x it only changes additively, because the devices of one game may run different 1.x versions (a cached copy). Receivers ignore message types and fields they do not know.
+* The plugin SDK sends its own game messages inside `send` / `deliver` (actions, state and state patches, reveals). Their format is part of the SDK's contract: within SDK 1.x it only changes additively, because the devices of one game may run different 1.x versions (a cached copy). Receivers ignore message types and fields they do not know. State patches carry the version of their format (`f`, today `1`: the patches of mutative 2); a receiver that does not know the format asks for the full state instead of applying them, so the patch format can change within 1.x.
+* **Reserved names** (so that a game never collides with a later SDK): action names and timer keys starting with `$` (the SDK rejects them in a game); HTML attributes starting with `data-mz-` (new SDK attributes use this prefix; the existing `data-act`, `data-local`, `data-payload`, `data-setting`, `data-keep`, `data-key` stay); CSS classes starting with `mz-`. Fields the SDK keeps in the game state exist only on request: today `phase`, `phaseSeq` and `phaseEndsAt`, only in games with `phases`. Any later field of the SDK will also be opt-in (a new option of the game definition), never added to the state of an existing game.
+* The public API of `@memizy/protocol` is what its entry point exports; `@memizy/protocol/internal` (helpers shared by the Memizy packages) is not covered by these rules. The functions (`safeParsePluginManifest`, `resolveSettings`, … and in `@memizy/oqse` `loadOQSEFile`, `safeValidateOQSEFile`, …) and the published JSON Schemas are the stable way to validate. The exported `*Schema` objects are Zod schemas whose `parse` / `safeParse` behaviour is covered; their Zod-specific API (`.extend`, `.shape`, `.pick`, the Zod major version) is not – a 1.x release may move to a newer Zod (noted in the changelog).
 * Libraries inside the SDK and the host SDK (sanitizer, Markdown parser…) may be updated in any 1.x release, including security fixes; only the wire formats above are fixed.
 * Plugins load the SDK as `https://cdn.jsdelivr.net/npm/@memizy/plugin-sdk@1` (the self-contained bundle of the package): every 1.x release reaches them without a change of the plugin.
 
@@ -464,12 +490,17 @@ What was decided and why, and what is **reserved** (name and intent fixed, not i
 4. **"Always new" exercises come from generators** that return ordinary OQSE items (in the plugin with `ctx.random()`, or as a service with a database or AI behind it). Everything else – rendering, `checkAnswer`, recording – works the same; answers are recorded as generated items.
 5. **Progress for teachers** = `recordAnswer` + OQSE `skills` from the content (hierarchical IDs from a shared vocabulary); a game's own model of the player stays in plugin data.
 6. **Choices have IDs** (OQSE): answers and statistics survive edits of a set; the host shuffles freely.
-7. **`playerView`** (per-player views of the state) is an optional SDK feature, not a protocol requirement: games without secrets need nothing.
+7. **Questions have two independent axes.** *Whose content*: one shared set for everyone (the authority checks the answers, which stay hidden – fair, competitive) or each player's own set (planned, "Personal sets": the player's device checks – relaxed, based on trust). *How questions are chosen*: the same for everyone (a fair race) or different for each player (randomly, at their own pace, or by their own progress – planned `pickItems`). The second axis is the game's rule, not a manifest declaration. Learning progress always belongs to each player; a class view is an aggregate of the players' progress.
+8. **`playerView`** (per-player views of the state) is an optional SDK feature, not a protocol requirement: games without secrets need nothing.
 
 **Reserved**
 
 | Name | Intent |
 | :--- | :--- |
+| Manifest `modes.multiplayer.sets`, feature `personal-sets`, `Player.set` | **Personal sets** ("everyone their own questions"): in multiplayer each player brings their own set (e.g., Spanish for one, chemistry for another, HSK 1 and HSK 3) and plays on one shared map. Values `"shared"` (today, the default) and `"personal"`. In `personal`, a player's instance gets that player's own full set and checks the answers itself on the player's device (trust, not fairness – a relaxed game among friends); the other instances and the authority get only the outcomes through the game's messages, and the board gets an empty set. `Player.set` (`{ id, title, language }`) tells the board who learns what. The player's set never travels through the relay. Plugins opt in; 1.0 plugins stay `"shared"`. |
+| Host method `pickItems(playerId, count)` | **Questions by each player's progress**: the host chooses the next items for a player with its learning algorithm (due items first), so a shared-set game can give every player different questions by their own progress without knowing it. Guarded by a feature. |
+| Host method `openSource({ setId, itemId, quote })` | "Where to learn this" from inside a game: the host opens the lesson an item's `sources` point to (OQSE `SourceReference.itemId` and `quote`) over the game, without leaving it. Hosts already show these links in their own review of mistakes after a game. |
+| Host method `markItem(itemId, { starred })` | A star on an item from inside a game (OQSEP `starred`); hosts offer "practise only starred" by filtering the set before the game. |
 | Address `"server"` | Server authority: official games run their rules on a server (graded homework, larger games). The display order and public items of section 4.4 already work the same there. |
 | Item field `generated: { by, seed }` | Where a generated item comes from (service or generator) and how to recreate it. |
 | Host method `uploadAsset` | Files created by players (drawings, photos) stored by the host and referenced like set assets. |
@@ -479,12 +510,17 @@ What was decided and why, and what is **reserved** (name and intent fixed, not i
 | Feature `teams` | Teams managed by the host (today every game handles teams itself). |
 | Hot-seat | Several players sharing one device; v1 assumes one player per instance. |
 | Host migration | Moving the authority to another device when its device is gone for good; v1 resumes the same authority from the snapshot. |
+| Host method `exit` | Leaving the game from inside it: a "back to the menu" button of a full-screen game; the host closes the game or returns to its menu. |
+| Host method `resize` | Auto height for games embedded in articles and course pages: the game reports the height of its content, the host sizes the frame (switched on in the manifest; the SDK measures it). |
+| Plugin method `setChanged`, host method `chooseSet`, manifest key `appSpecific.memizy.setChanges` | **Changing the set of a running game**: the author edits it (in the Lab, or reloads it with changes), the teacher switches the class set, a game is continued with another set, or – with personal sets – a player picks another set of their own. A game opts in with `setChanges` (a feature in the handshake); other games never get a change. The host calls `setChanged` with the new set of each instance (full or public items, the progress and the `set` plugin data that belong to it). The SDK compares the items by ID and calls a hook where the items live: for a shared set on the authority, `itemsChanged(state, ctx, { added, removed, changed })`, as a system action (deterministic, recorded for replays); for a personal set on the player's device (its own question flow, e.g. the queue in `ui.local`), while the authority only sees the new `Player.set`; an edited item keeps its ID, so the game state stays valid, and its display order does not move (4.4). `chooseSet()` lets a game open the host's set picker from its own UI (a game never sees the player's library). With personal sets a change concerns only that player's instance: the authority is not involved. |
+| Host method `saveProgress` | Writing learning progress directly, e.g. a placement test ("these items are known"); the host may refuse or limit it. |
+| Feature `replay` | Recording a game and replaying it: the host keeps the session's inputs (the `InitPayload` with the seed and the display order, every action with its sender and game time, pauses) and replays the game by running the same plugin version on them. This works because the rules are deterministic (`ctx.random`, `ctx.now`, no `Math.random` / `Date.now` in actions); keep that rule. |
 
 ---
 
 ## Changelog
 
-* **1.0 (unreleased):** the transport (Penpal 8), the SDK message format and the protocol declaration of plugins using 1.x additions are fixed rules (4, 4.3, 9); plugins load the SDK from `…/plugin-sdk@1`. `appSpecific.memizy.set` (`required` / `optional` / `none`): games without questions; OQSEM `capabilities` and `actions` may be omitted. Public items (4.4) also lose `sources[].quote`; custom `x-` items lose `solution`, `explanation` and `incorrectFeedback` and get `answerHidden: true` (they were passed unchanged); `hints` stay public. `recordAnswer.answer` follows OQSE Answer Formats (a flashcard answer is a self-rating 1–4; `ui.question` offers four ratings). OQSE 1.0 sets and OQSEM 1.0 manifests (`"version": "1.0"`; other MAJOR versions are not read as 1.x). A host may support several protocol MAJOR versions at once (4.3); supporting older ones is a SHOULD instead of a MUST.
+* **1.0 (2026-10-14):** the term *host* (3.1): the application that embeds the plugin on a device, also on a player's device; the host ends a player's instance with `sessionEnded` (also `kicked`, `host-left`) before removing it. Removed before 1.0 and reserved (10): `exit`, `resize`, `setChanged`, `saveProgress` (a self-rating is an answer). `InitPayload.services` and the pause fields of `SessionClock` are always present; `sessionEnded` reason `host-left` (was `host_left`); `SETTINGS_ADDRESS` is defined here; the relay type of a room player is `RoomPlayer`. State patches carry their format (`f`); reserved names `$…`, `data-mz-…`, `mz-…` and opt-in state fields; `@memizy/protocol/internal`; Zod 4 (9). Renamed before 1.0: `ui.renderNote` → `ui.note` (SDK), the type `Theme` → `HostConfig`. Player names and personal data: plugins MUST NOT ask for real names or other personal data (3.3); `setChanged` is optional for hosts (7); `replay` reserved (10). The sandbox allows popups that escape it, links open in a new tab (8.4). Error code `UNKNOWN_METHOD` (8.2). Continuing a saved game is described (3.3; host feature, no protocol change). After `end(result)` the host discards the snapshot (5). The transport (Penpal 8), the SDK message format (actions carry the `phaseSeq` the player saw and the tap time `actedAt`; devices of one game may run different SDK 1.x versions) and the protocol declaration of plugins using 1.x additions are fixed rules (4, 4.3, 9); plugins load the SDK from `…/plugin-sdk@1`. `appSpecific.memizy.set` (`required` / `optional` / `none`): games without questions; OQSEM `capabilities` and `actions` may be omitted. Public items (4.4) also lose `sources[].quote`; custom `x-` items lose `solution`, `explanation` and `incorrectFeedback` and get `answerHidden: true` (they were passed unchanged); `hints` stay public. `recordAnswer.answer` follows OQSE Answer Formats (a flashcard answer is a self-rating 1–4; `ui.question` offers four ratings). OQSE 1.0 sets and OQSEM 1.0 manifests (`"version": "1.0"`; other MAJOR versions are not read as 1.x). A host may support several protocol MAJOR versions at once (4.3); supporting older ones is a SHOULD instead of a MUST. Forward compatibility: public items keep only fields known not to be part of the answer (4.4); `InitPayload.set` holds the questions of this instance (4.2); unknown setting types are hidden and get their default, so new setting types need no newer protocol (2, 4.3); `AnswerRecord.score` (partial credit). Decided: the two axes of questions (10). Reserved: personal sets (`modes.multiplayer.sets`, feature `personal-sets`, `Player.set`), `pickItems`, `openSource`, `markItem` (10). `recordAnswer` is an *authority* method (5): other instances cannot prove an answer. The seed of the display order is secret and random (4.4; it was the session id by default, so a player could undo the shuffle). Public items lose media that only hidden fields use; `getAsset` gives an instance only media of its own set (4.4). Choice IDs are opaque to games; a host may give per-session IDs (4.4). `InitPayload.seed`: a secret seed for the game's random numbers, only for the authority (4.2, 8.4) – before, the SDK seeded them with the session id that every instance knows. The Penpal 8 wire format is described (4). A host may give a game a part of a large set (4.2). Answers to `open-ended` items do not change repetition; games record the first attempt (5.1). Each item is shuffled with its own seed (4.4); a continued game uses the same set (3.3); planned set changes (`setChanged`, `chooseSet`, `setChanges`, 10). Zod: only `parse` / `safeParse` of the exported schemas are covered (9). Final rules: a second `hello` of an instance rejects with `INVALID_ARGUMENT`, only the first `end(result)` counts (5); guaranteed rates of `recordAnswer` (per player for the authority), `getAsset` and `reportError` (dropped beyond it) and an asset size of 2 MB (8.1); the address `"settings"` (3.1).
 * **RC1 (2026-10-04):** first release candidate.
 * **RC2 (2026-10-06):** `SettingDefinition.modes`; the host may show solo settings before the start (section 3.3). Additive: RC1 plugins and hosts keep working.
 * **RC4 (2026-10-07):** OQSE 0.3 sets (choices with IDs; the RC3 `correctOrder` / `correctMatches` display fields are gone because answers refer to IDs); `recordAnswer.answer` and generated items (5.1); services (5.3, `service`, `InitPayload.services`, `SERVICE_UNAVAILABLE`); pauses (`SessionClock`); `permissions` with a Content Security Policy and device grants (8.4); decisions and reservations (section 10). Additive for the protocol except the OQSE version: plugins must read choices (`option.text`, `option.id`).

package/dist/errors.cjs

@@ -1 +1 @@
-var e=[`UNSUPPORTED_PROTOCOL`,`INVALID_ARGUMENT`,`NOT_AUTHORITY`,`NOT_ALLOWED_IN_VIEW`,`AUTHORITY_UNAVAILABLE`,`MESSAGE_TOO_LARGE`,`SNAPSHOT_TOO_LARGE`,`DATA_TOO_LARGE`,`RATE_LIMITED`,`ASSET_NOT_FOUND`,`SESSION_ENDED`,`INTERNAL_ERROR`,`SERVICE_UNAVAILABLE`],t=/^\[([A-Z_]+)\]\s?/,n=class extends Error{code;constructor(e,t){super(`[${e}] ${t}`),this.name=`ProtocolError`,this.code=e}get detail(){return this.message.replace(t,``)}};function r(t){return typeof t==`string`&&e.includes(t)}function i(e){if(e instanceof n)return e;let i=e instanceof Error?e.message:String(e),a=t.exec(i);return new n(a&&r(a[1])?a[1]:`INTERNAL_ERROR`,a?i.slice(a[0].length):i)}exports.PROTOCOL_ERROR_CODES=e,exports.ProtocolError=n,exports.isProtocolErrorCode=r,exports.toProtocolError=i;
+var e=[`UNSUPPORTED_PROTOCOL`,`INVALID_ARGUMENT`,`NOT_AUTHORITY`,`NOT_ALLOWED_IN_VIEW`,`AUTHORITY_UNAVAILABLE`,`MESSAGE_TOO_LARGE`,`SNAPSHOT_TOO_LARGE`,`DATA_TOO_LARGE`,`RATE_LIMITED`,`ASSET_NOT_FOUND`,`SESSION_ENDED`,`INTERNAL_ERROR`,`SERVICE_UNAVAILABLE`,`UNKNOWN_METHOD`],t=/^\[([A-Z_]+)\]\s?/,n=class extends Error{code;constructor(e,t){super(`[${e}] ${t}`),this.name=`ProtocolError`,this.code=e}get detail(){return this.message.replace(t,``)}};function r(t){return typeof t==`string`&&e.includes(t)}function i(e){if(e instanceof n)return e;let i=e instanceof Error?e.message:String(e);if(e?.code===`METHOD_NOT_FOUND`)return new n(`UNKNOWN_METHOD`,i);let a=t.exec(i);return new n(a&&r(a[1])?a[1]:`INTERNAL_ERROR`,a?i.slice(a[0].length):i)}exports.PROTOCOL_ERROR_CODES=e,exports.ProtocolError=n,exports.isProtocolErrorCode=r,exports.toProtocolError=i;

package/dist/errors.js

@@ -12,7 +12,8 @@ var e = [
 	"ASSET_NOT_FOUND",
 	"SESSION_ENDED",
 	"INTERNAL_ERROR",
-	"SERVICE_UNAVAILABLE"
+	"SERVICE_UNAVAILABLE",
+	"UNKNOWN_METHOD"
 ], t = /^\[([A-Z_]+)\]\s?/, n = class extends Error {
 	code;
 	constructor(e, t) {
@@ -27,7 +28,9 @@ function r(t) {
 }
 function i(e) {
 	if (e instanceof n) return e;
-	let i = e instanceof Error ? e.message : String(e), a = t.exec(i);
+	let i = e instanceof Error ? e.message : String(e);
+	if (e?.code === "METHOD_NOT_FOUND") return new n("UNKNOWN_METHOD", i);
+	let a = t.exec(i);
 	return new n(a && r(a[1]) ? a[1] : "INTERNAL_ERROR", a ? i.slice(a[0].length) : i);
 }
 //#endregion

package/dist/index.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./version.cjs"),t=require("./errors.cjs"),n=require("./limits.cjs"),r=require("./settingsSchema.cjs"),i=require("./settings.cjs"),a=require("./pluginRuntime.cjs"),o=require("./manifestSchema.cjs"),s=require("./types.cjs"),c=require("./schemas.cjs"),l=require("./relay.cjs"),u=require("./items.cjs"),d=require("./security.cjs"),f=require("./polyfills.cjs");exports.AddressSchema=c.AddressSchema,exports.AnswerRecordSchema=c.AnswerRecordSchema,exports.BOARD_ADDRESS=s.BOARD_ADDRESS,exports.DataScopeSchema=c.DataScopeSchema,exports.ErrorReportSchema=c.ErrorReportSchema,exports.HOST_API_ARGS=c.HOST_API_ARGS,exports.HOST_API_METHODS=s.HOST_API_METHODS,exports.HandshakeSchema=c.HandshakeSchema,exports.HostAsSchema=o.HostAsSchema,exports.LIBRARY_ORIGINS=d.LIBRARY_ORIGINS,exports.LIMITS=n.LIMITS,exports.LocalizedTextSchema=r.LocalizedTextSchema,exports.MemizyRuntimeSchema=o.MemizyRuntimeSchema,exports.MultiplayerModeSchema=o.MultiplayerModeSchema,exports.OutgoingMessageSchema=c.OutgoingMessageSchema,exports.PLUGIN_API_METHODS=s.PLUGIN_API_METHODS,exports.PLUGIN_DEVICES=d.PLUGIN_DEVICES,exports.PROTOCOL_ERROR_CODES=t.PROTOCOL_ERROR_CODES,exports.PROTOCOL_VERSION=e.PROTOCOL_VERSION,exports.PluginManifestError=o.PluginManifestError,exports.PluginPermissionsSchema=o.PluginPermissionsSchema,exports.ProgressRecordsSchema=c.ProgressRecordsSchema,exports.ProtocolError=t.ProtocolError,exports.RELAY_LIMITS=l.RELAY_LIMITS,exports.RELAY_PROTOCOL=l.RELAY_PROTOCOL,exports.RateLimiter=n.RateLimiter,exports.ResizeRequestSchema=c.ResizeRequestSchema,exports.SERVER_ADDRESS=s.SERVER_ADDRESS,exports.ServiceNameSchema=o.ServiceNameSchema,exports.SessionResultSchema=c.SessionResultSchema,exports.SettingDefinitionSchema=r.SettingDefinitionSchema,exports.SettingsUpdateSchema=c.SettingsUpdateSchema,exports.assertJsonWithin=n.assertJsonWithin,exports.compareProtocolVersions=e.compareProtocolVersions,exports.displayItem=u.displayItem,exports.ensureConnectionPolyfills=f.ensureConnectionPolyfills,exports.extractManifestFromHtml=a.extractManifestFromHtml,exports.findNonJson=n.findNonJson,exports.injectContentPolicy=d.injectContentPolicy,exports.isPin=l.isPin,exports.isProtocolErrorCode=t.isProtocolErrorCode,exports.isProtocolSupported=e.isProtocolSupported,exports.jsonByteSize=n.jsonByteSize,exports.localize=i.localize,exports.negotiateProtocolVersion=e.negotiateProtocolVersion,exports.normalizePlayerName=l.normalizePlayerName,exports.parseHostCall=c.parseHostCall,exports.parsePluginManifest=o.parsePluginManifest,exports.parseProtocolVersion=e.parseProtocolVersion,exports.pluginAllowAttribute=d.pluginAllowAttribute,exports.pluginContentPolicy=d.pluginContentPolicy,exports.prepareDisplaySet=u.prepareDisplaySet,exports.publicItem=u.publicItem,exports.readPluginManifestFromHtml=o.readPluginManifestFromHtml,exports.resolveSettings=i.resolveSettings,exports.safeParsePluginManifest=o.safeParsePluginManifest,exports.seededRandom=u.seededRandom,exports.settingsForMode=i.settingsForMode,exports.toProtocolError=t.toProtocolError,exports.toRuntime=a.toRuntime,exports.validateSettingValue=i.validateSettingValue;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./version.cjs"),t=require("./errors.cjs"),n=require("./limits.cjs"),r=require("./settings.cjs"),i=require("./settingsSchema.cjs"),a=require("./pluginRuntime.cjs"),o=require("./manifestSchema.cjs"),s=require("./types.cjs"),c=require("./schemas.cjs"),l=require("./relay.cjs"),u=require("./items.cjs"),d=require("./security.cjs");exports.AddressSchema=c.AddressSchema,exports.AnswerRecordSchema=c.AnswerRecordSchema,exports.BOARD_ADDRESS=s.BOARD_ADDRESS,exports.DataScopeSchema=c.DataScopeSchema,exports.ErrorReportSchema=c.ErrorReportSchema,exports.HOST_API_METHODS=s.HOST_API_METHODS,exports.HandshakeSchema=c.HandshakeSchema,exports.HostAsSchema=o.HostAsSchema,exports.LIMITS=n.LIMITS,exports.LocalizedTextSchema=i.LocalizedTextSchema,exports.MemizyRuntimeSchema=o.MemizyRuntimeSchema,exports.MultiplayerModeSchema=o.MultiplayerModeSchema,exports.OutgoingMessageSchema=c.OutgoingMessageSchema,exports.PLUGIN_API_METHODS=s.PLUGIN_API_METHODS,exports.PLUGIN_DEVICES=d.PLUGIN_DEVICES,exports.PROTOCOL_ERROR_CODES=t.PROTOCOL_ERROR_CODES,exports.PROTOCOL_VERSION=e.PROTOCOL_VERSION,exports.PluginManifestError=o.PluginManifestError,exports.PluginPermissionsSchema=o.PluginPermissionsSchema,exports.ProtocolError=t.ProtocolError,exports.RELAY_PROTOCOL=l.RELAY_PROTOCOL,exports.SERVER_ADDRESS=s.SERVER_ADDRESS,exports.SETTINGS_ADDRESS=s.SETTINGS_ADDRESS,exports.SETTING_TYPES=r.SETTING_TYPES,exports.ServiceNameSchema=o.ServiceNameSchema,exports.SessionResultSchema=c.SessionResultSchema,exports.SettingDefinitionSchema=i.SettingDefinitionSchema,exports.SettingsUpdateSchema=c.SettingsUpdateSchema,exports.UnknownSettingSchema=i.UnknownSettingSchema,exports.compareProtocolVersions=e.compareProtocolVersions,exports.extractManifestFromHtml=a.extractManifestFromHtml,exports.isKnownSetting=r.isKnownSetting,exports.isProtocolErrorCode=t.isProtocolErrorCode,exports.isProtocolSupported=e.isProtocolSupported,exports.localize=r.localize,exports.negotiateProtocolVersion=e.negotiateProtocolVersion,exports.parsePluginManifest=o.parsePluginManifest,exports.parseProtocolVersion=e.parseProtocolVersion,exports.prepareDisplaySet=u.prepareDisplaySet,exports.readPluginManifestFromHtml=o.readPluginManifestFromHtml,exports.resolveSettings=r.resolveSettings,exports.safeParsePluginManifest=o.safeParsePluginManifest,exports.settingsForMode=r.settingsForMode,exports.toProtocolError=t.toProtocolError,exports.validateSettingValue=r.validateSettingValue;

package/dist/index.js

@@ -1,14 +1,13 @@
 import { PROTOCOL_VERSION as e, compareProtocolVersions as t, isProtocolSupported as n, negotiateProtocolVersion as r, parseProtocolVersion as i } from "./version.js";
 import { PROTOCOL_ERROR_CODES as a, ProtocolError as o, isProtocolErrorCode as s, toProtocolError as c } from "./errors.js";
-import { LIMITS as l, RateLimiter as u, assertJsonWithin as d, findNonJson as f, jsonByteSize as p } from "./limits.js";
-import { LocalizedTextSchema as m, SettingDefinitionSchema as h } from "./settingsSchema.js";
-import { localize as g, resolveSettings as _, settingsForMode as v, validateSettingValue as y } from "./settings.js";
-import { extractManifestFromHtml as b, toRuntime as x } from "./pluginRuntime.js";
-import { HostAsSchema as S, MemizyRuntimeSchema as C, MultiplayerModeSchema as w, PluginManifestError as T, PluginPermissionsSchema as E, ServiceNameSchema as D, parsePluginManifest as O, readPluginManifestFromHtml as k, safeParsePluginManifest as A } from "./manifestSchema.js";
-import { BOARD_ADDRESS as j, HOST_API_METHODS as M, PLUGIN_API_METHODS as N, SERVER_ADDRESS as P } from "./types.js";
-import { AddressSchema as F, AnswerRecordSchema as I, DataScopeSchema as L, ErrorReportSchema as R, HOST_API_ARGS as z, HandshakeSchema as B, OutgoingMessageSchema as V, ProgressRecordsSchema as H, ResizeRequestSchema as U, SessionResultSchema as W, SettingsUpdateSchema as G, parseHostCall as K } from "./schemas.js";
-import { RELAY_LIMITS as q, RELAY_PROTOCOL as J, isPin as Y, normalizePlayerName as X } from "./relay.js";
-import { displayItem as Z, prepareDisplaySet as Q, publicItem as $, seededRandom as ee } from "./items.js";
-import { LIBRARY_ORIGINS as te, PLUGIN_DEVICES as ne, injectContentPolicy as re, pluginAllowAttribute as ie, pluginContentPolicy as ae } from "./security.js";
-import { ensureConnectionPolyfills as oe } from "./polyfills.js";
-export { F as AddressSchema, I as AnswerRecordSchema, j as BOARD_ADDRESS, L as DataScopeSchema, R as ErrorReportSchema, z as HOST_API_ARGS, M as HOST_API_METHODS, B as HandshakeSchema, S as HostAsSchema, te as LIBRARY_ORIGINS, l as LIMITS, m as LocalizedTextSchema, C as MemizyRuntimeSchema, w as MultiplayerModeSchema, V as OutgoingMessageSchema, N as PLUGIN_API_METHODS, ne as PLUGIN_DEVICES, a as PROTOCOL_ERROR_CODES, e as PROTOCOL_VERSION, T as PluginManifestError, E as PluginPermissionsSchema, H as ProgressRecordsSchema, o as ProtocolError, q as RELAY_LIMITS, J as RELAY_PROTOCOL, u as RateLimiter, U as ResizeRequestSchema, P as SERVER_ADDRESS, D as ServiceNameSchema, W as SessionResultSchema, h as SettingDefinitionSchema, G as SettingsUpdateSchema, d as assertJsonWithin, t as compareProtocolVersions, Z as displayItem, oe as ensureConnectionPolyfills, b as extractManifestFromHtml, f as findNonJson, re as injectContentPolicy, Y as isPin, s as isProtocolErrorCode, n as isProtocolSupported, p as jsonByteSize, g as localize, r as negotiateProtocolVersion, X as normalizePlayerName, K as parseHostCall, O as parsePluginManifest, i as parseProtocolVersion, ie as pluginAllowAttribute, ae as pluginContentPolicy, Q as prepareDisplaySet, $ as publicItem, k as readPluginManifestFromHtml, _ as resolveSettings, A as safeParsePluginManifest, ee as seededRandom, v as settingsForMode, c as toProtocolError, x as toRuntime, y as validateSettingValue };
+import { LIMITS as l } from "./limits.js";
+import { SETTING_TYPES as u, isKnownSetting as d, localize as f, resolveSettings as p, settingsForMode as m, validateSettingValue as h } from "./settings.js";
+import { LocalizedTextSchema as g, SettingDefinitionSchema as _, UnknownSettingSchema as v } from "./settingsSchema.js";
+import { extractManifestFromHtml as y } from "./pluginRuntime.js";
+import { HostAsSchema as b, MemizyRuntimeSchema as x, MultiplayerModeSchema as S, PluginManifestError as C, PluginPermissionsSchema as w, ServiceNameSchema as T, parsePluginManifest as E, readPluginManifestFromHtml as D, safeParsePluginManifest as O } from "./manifestSchema.js";
+import { BOARD_ADDRESS as k, HOST_API_METHODS as A, PLUGIN_API_METHODS as j, SERVER_ADDRESS as M, SETTINGS_ADDRESS as N } from "./types.js";
+import { AddressSchema as P, AnswerRecordSchema as F, DataScopeSchema as I, ErrorReportSchema as L, HandshakeSchema as R, OutgoingMessageSchema as z, SessionResultSchema as B, SettingsUpdateSchema as V } from "./schemas.js";
+import { RELAY_PROTOCOL as H } from "./relay.js";
+import { prepareDisplaySet as U } from "./items.js";
+import { PLUGIN_DEVICES as W } from "./security.js";
+export { P as AddressSchema, F as AnswerRecordSchema, k as BOARD_ADDRESS, I as DataScopeSchema, L as ErrorReportSchema, A as HOST_API_METHODS, R as HandshakeSchema, b as HostAsSchema, l as LIMITS, g as LocalizedTextSchema, x as MemizyRuntimeSchema, S as MultiplayerModeSchema, z as OutgoingMessageSchema, j as PLUGIN_API_METHODS, W as PLUGIN_DEVICES, a as PROTOCOL_ERROR_CODES, e as PROTOCOL_VERSION, C as PluginManifestError, w as PluginPermissionsSchema, o as ProtocolError, H as RELAY_PROTOCOL, M as SERVER_ADDRESS, N as SETTINGS_ADDRESS, u as SETTING_TYPES, T as ServiceNameSchema, B as SessionResultSchema, _ as SettingDefinitionSchema, V as SettingsUpdateSchema, v as UnknownSettingSchema, t as compareProtocolVersions, y as extractManifestFromHtml, d as isKnownSetting, s as isProtocolErrorCode, n as isProtocolSupported, f as localize, r as negotiateProtocolVersion, E as parsePluginManifest, i as parseProtocolVersion, U as prepareDisplaySet, D as readPluginManifestFromHtml, p as resolveSettings, O as safeParsePluginManifest, m as settingsForMode, c as toProtocolError, h as validateSettingValue };

package/dist/internal.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./limits.cjs"),t=require("./pluginRuntime.cjs"),n=require("./schemas.cjs"),r=require("./relay.cjs"),i=require("./items.cjs"),a=require("./security.cjs"),o=require("./polyfills.cjs");exports.HOST_API_ARGS=n.HOST_API_ARGS,exports.LIBRARY_ORIGINS=a.LIBRARY_ORIGINS,exports.RELAY_LIMITS=r.RELAY_LIMITS,exports.RateLimiter=e.RateLimiter,exports.assertJsonWithin=e.assertJsonWithin,exports.displayItem=i.displayItem,exports.ensureConnectionPolyfills=o.ensureConnectionPolyfills,exports.findNonJson=e.findNonJson,exports.injectContentPolicy=a.injectContentPolicy,exports.isPin=r.isPin,exports.jsonByteSize=e.jsonByteSize,exports.normalizePlayerName=r.normalizePlayerName,exports.parseHostCall=n.parseHostCall,exports.pluginAllowAttribute=a.pluginAllowAttribute,exports.pluginContentPolicy=a.pluginContentPolicy,exports.publicItem=i.publicItem,exports.seededRandom=i.seededRandom,exports.toRuntime=t.toRuntime;