@hypersoniclabs/helix-manifest 0.3.0 → 0.3.2

package/dist/src/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PACKAGE_ENVELOPE_VERSION = exports.PLATFORM_MAX_PLAYERS_PER_ROOM = exports.MAIN_BACKEND_CONTENT_RATING = exports.MAIN_BACKEND_PACKAGE_TYPE = exports.BUNDLE_KINDS = exports.PERMISSIONS_V03 = exports.PERMISSIONS_V01 = exports.MANIFEST_VERSIONS = exports.MANIFEST_FILENAME = void 0;
+exports.PACKAGE_ENVELOPE_VERSION = exports.VAR_TYPES = exports.MULTIPLAYER_CAPS = exports.PLATFORM_MAX_PLAYERS_PER_ROOM = exports.MAIN_BACKEND_CONTENT_RATING = exports.MAIN_BACKEND_PACKAGE_TYPE = exports.BUNDLE_KINDS = exports.PERMISSIONS_V03 = exports.PERMISSIONS_V01 = exports.MANIFEST_VERSIONS = exports.MANIFEST_FILENAME = void 0;
 exports.validateManifest = validateManifest;
 exports.parseManifest = parseManifest;
 exports.validatePackageEnvelope = validatePackageEnvelope;
@@ -31,9 +31,12 @@ const package_envelope_v1_schema_json_1 = __importDefault(require("../schema/pac
 exports.MANIFEST_FILENAME = 'helix.json';
 exports.MANIFEST_VERSIONS = ['0.1', '0.2', '0.3'];
 exports.PERMISSIONS_V01 = ['auth.profile'];
-// v0.3 adds multiplayer + the reserved voice.* perms. The per-version JSON Schema still gates which
-// of these a given manifest may declare (v0.1/v0.2 accept only auth.profile); this is the full union.
-exports.PERMISSIONS_V03 = ['auth.profile', 'multiplayer', 'voice.room', 'voice.proximity'];
+// v0.3 adds multiplayer + the reserved voice.* perms + camera.capture. The per-version JSON Schema
+// still gates which of these a given manifest may declare (v0.1/v0.2 accept only auth.profile); this
+// is the full union. camera.capture: save a photo taken with the in-engine world camera to the
+// player's account album (the phone Gallery, cross-device). Player-authed via the shell — login is
+// prompted on save, not on entry, so it does NOT imply requiresAuth.
+exports.PERMISSIONS_V03 = ['auth.profile', 'multiplayer', 'voice.room', 'voice.proximity', 'camera.capture'];
 /**
  * Bundle vocabulary, pinned for main-backend compatibility. A **system** is a
  * versioned runtime framework that hosts abilities (the humanoid character is
@@ -55,6 +58,27 @@ exports.MAIN_BACKEND_PACKAGE_TYPE = {
     ability: 'Ability', // proposed
     'asset-pack': 'AssetPack', // proposed
 };
+// §6 (4.5.8) the entity kind a zone's `tracks` targets, or undefined for the default 'players'. A zone tracking
+// 'entity:<kind>' tests entities of that kind (not players) and binds `self` = the entering entity of that kind.
+function entityTrackKind(tracks) {
+    return typeof tracks === 'string' && tracks.startsWith('entity:') ? tracks.slice('entity:'.length) : undefined;
+}
+// §6 (4.5.8) zone-reference → the entity kind its `self` binds to (only zones tracking 'entity:<kind>'). Keyed by
+// the same string a zone event's `when.zone` carries: a static zone's id, or an attached zone's carrier kind.
+function buildZoneSelfKinds(m) {
+    const map = new Map();
+    for (const z of m.multiplayer?.zones ?? []) {
+        const k = entityTrackKind(z.tracks);
+        if (k)
+            map.set(z.id, k);
+    }
+    for (const [kind, ent] of Object.entries(m.multiplayer?.entities ?? {})) {
+        const k = ent.zone && entityTrackKind(ent.zone.tracks);
+        if (k)
+            map.set(kind, k);
+    }
+    return map;
+}
 /**
  * contentRating → main-backend ContentRating. 'unrated' has no counterpart there (their enum is
  * Everyone/Teen/Mature) — an unrated bundle cannot federate into the catalog until it is rated.
@@ -68,8 +92,93 @@ exports.MAIN_BACKEND_CONTENT_RATING = {
 // The platform caps CONCURRENT players PER ROOM at this number regardless of the manifest's maxPlayers
 // (the room auto-locks here and spills extra players into additional room instances). A manifest above
 // this is VALID but warned at publish so the author isn't surprised by the runtime cap. MUST match the
-// room server's ROOM_MAX_CLIENTS_CAP (helix-colyseus-server src/validation.ts).
+// room server's ROOM_MAX_CLIENTS_CAP (helix-colyseus-server src/tuning.ts — the runtime tuning home).
 exports.PLATFORM_MAX_PLAYERS_PER_ROOM = 24;
+// §11.1 closed cap table — THE publish-time tuning home: platform limits on declared world config, enforced
+// at publish so a world can't blow the room's per-tick/state budget. Tweak a ceiling here and worlds are
+// re-validated against it. (The other two tuning homes: runtime room knobs — sim rate, movement-gate speed,
+// capacity — in helix-colyseus-server src/tuning.ts; message rates + the wire contract in
+// @hypersoniclabs/helix-sdk/multiplayer-contract.) The table grows per phase as new declarable dimensions
+// land. (Var-NAME length is capped by the schema's varDecls propertyNames pattern — 32 chars — not here.)
+// Over any cap → publish fails.
+exports.MULTIPLAYER_CAPS = {
+    /** Accepted `multiplayer.uploadHz` tiers (client→server upload cadence). 10 = default, 20 = opt-in fast tier.
+     *  SYNC: mirrors the contract's MESSAGE_RATE.{stateHz=10, maxUploadHz=20} (helix-sdk multiplayer-contract) — the
+     *  manifest takes no SDK dep, so widen both in lockstep if a tier is ever added. */
+    uploadHzAllowed: [10, 20],
+    /** The 20 Hz player cap: `uploadHz:20` requires maxPlayers ≤ this (the ~2× upstream cost is bounded by capacity).
+     *  SYNC: mirrors the room's ROOM_MAX_CLIENTS_CAP_20HZ (helix-colyseus-server src/tuning.ts) — publish gate here,
+     *  runtime backstop there. */
+    maxPlayersAt20Hz: 12,
+    /** Declared room-level vars. */
+    roomVars: 64,
+    /** Declared per-player vars (these are realized once PER PLAYER at runtime, so the effective cost scales). */
+    playerVars: 64,
+    /** Ceiling on a string var's declared `maxLen` (bounds a single synced string). */
+    stringMaxLen: 1024,
+    /** Values in a string var's `enum`. */
+    enumValues: 64,
+    /** Ceiling on a `list` collection var's declared `maxLen` (4.5.13 — bounds a single synced array). */
+    listMaxLen: 256,
+    /** Keys in a `counterMap` collection var's declared key enum (4.5.13). */
+    counterKeys: 64,
+    /** Fields in a `list` of `record` element (P3 Collections — bounds one synced record's flat scalar fields). */
+    recordFields: 8,
+    /** Declared behavior rules (Tier 2 Phase 2). */
+    rules: 128,
+    /** Effects in a single rule's `then`. */
+    ruleThen: 16,
+    /** Max nesting depth of a condition expression (`if`). */
+    exprDepth: 8,
+    /** Max total nodes in a single condition expression. */
+    exprNodes: 64,
+    /** Declared state-machine phases (Tier 2 Phase 3, spec §8). One room-scoped machine; this caps its phase set. */
+    phases: 32,
+    /** Declared timers (Tier 2 Phase 3, spec §8). Each active timer (room-scoped, or × live members when keyed in
+     *  3.3) reifies a deadline into synced state — this caps the declared name count. */
+    timers: 32,
+    /** Floor on a `startTimer` duration (seconds) = one sim tick (1/20s). A shorter timer can't resolve below the
+     *  tick rate; rejecting it stops a 0s timer from same-tick start→elapse churn. MUST track the room's SIM_HZ. */
+    timerMinSeconds: 0.05,
+    /** Effects in a single phase's `joinPolicy.onLateJoin` (Tier 2 Phase 3.5). Runs once per late join (≤ player
+     *  cap/tick), so it's bounded like a playerJoin rule's `then`. */
+    joinPolicyEffects: 16,
+    /** §3.6/§11.3 cascade-drain depth — the longest within-tick chain of stateEnter/stateExit → transitionTo →
+     *  stateEnter… Computed statically at publish (a cycle is rejected outright); a config whose chain exceeds
+     *  this fails publish. Bounds the ×(1+maxCascadeDepth) budget term + MUST stay ≤ the room's MAX_CASCADE_DEPTH
+     *  runtime backstop (helix-colyseus-server src/tuning.ts). */
+    maxCascadeDepth: 16,
+    /** Declared zones (Tier 2 Phase 2.3). Membership is O(members × zones)/tick, both capped. */
+    zones: 64,
+    /** Declared broadcast events (Tier 2 Phase 2.5). */
+    events: 64,
+    /** Fields in a single broadcast event's payload. */
+    broadcastFields: 16,
+    /** Declared client→server actions (Tier 2 Phase 2.5b). */
+    actions: 64,
+    /** Args in a single action's schema. */
+    actionArgs: 16,
+    /** Declared entity archetypes (Tier 2 Phase 4, spec §9). */
+    entityKinds: 32,
+    /** Max declared vars per entity kind (realized once PER live entity at runtime, so the effective cost scales). */
+    entityVars: 64,
+    /** Max live entities of a single kind in a room — bounds the synced entities collection + per-tick entity work.
+     *  Enforced at RUNTIME (a spawn over the cap is skipped + counted in the H3 metric, never throws). */
+    entitiesPerKind: 256,
+    /** networked-physics (Phase 0): max entity kinds that may declare a `physics` block per world. Bounds the
+     *  client-side dynamic-body count alongside entitiesPerKind — the worst case a client may simulate is
+     *  physicsKinds × entitiesPerKind dynamic Rapier bodies, so keep this small (a casual world needs 1–2). */
+    physicsKinds: 8,
+    /** Ceiling on a zone's extent — any box dimension or a sphere radius, in meters. A sanity bound (a zone
+     *  test is O(1) regardless of size), generous enough for whole-level kill-planes. */
+    zoneMaxExtent: 10000,
+    /** §11.2 per-tick budget — the worst-case node-evaluations across ALL rules in one tick: Σ over rules of
+     *  fireCount(event) × ruleCost, where reductions (aggregate/nearest*) + forEach fanout are weighted by the
+     *  player cap and contact events by playerCap², all ×(1 + maxCascadeDepth) for the Phase-3 cascade drain
+     *  (analyzeCascade computes the cycle-free longest chain). Over this → publish fails. PROVISIONAL: a generous
+     *  bound that catches pathological configs; the precise number wants the S6 load test. */
+    tickNodeBudget: 100_000,
+};
 const ajv = new _2020_1.Ajv2020({ allErrors: true, useDefaults: true });
 const validateV01 = ajv.compile(manifest_v0_1_schema_json_1.default);
 const validateV02 = ajv.compile(manifest_v0_2_schema_json_1.default);
@@ -77,7 +186,7 @@ const validateV03 = ajv.compile(manifest_v0_3_schema_json_1.default);
 // Cross-field rules JSON Schema can't express cleanly, run after schema validation on the normalized
 // v0.3 manifest. Returns errors (empty = ok) + non-fatal warnings, and may normalize in place. Both the
 // CLI (pre-upload) and the API (finalize) call validateManifest, so these can never disagree.
-function applyV03CrossFieldRules(m) {
+function applyV03CrossFieldRules(m, strict) {
     const errors = [];
     const warnings = [];
     const perms = m.permissions ?? [];
@@ -98,8 +207,2784 @@ function applyV03CrossFieldRules(m) {
     if (multiplayer && m.maxPlayers > exports.PLATFORM_MAX_PLAYERS_PER_ROOM) {
         warnings.push(`manifest: maxPlayers ${m.maxPlayers} exceeds the platform per-room cap of ${exports.PLATFORM_MAX_PLAYERS_PER_ROOM} — each room holds at most ${exports.PLATFORM_MAX_PLAYERS_PER_ROOM} concurrent players; extra players spill into additional room instances`);
     }
+    // §14 (4.5) the declared playable floor can't exceed the ceiling (the schema already bounds minPlayers ≥ 1).
+    const minPlayers = m.multiplayer?.minPlayers;
+    if (minPlayers !== undefined && minPlayers > m.maxPlayers) {
+        errors.push(`manifest: multiplayer.minPlayers ${minPlayers} exceeds maxPlayers ${m.maxPlayers}`);
+    }
+    // Upload-rate tier. The schema enum normally gates the value (and defaults absent → 10); this defensive enum check
+    // covers manifests built outside the schema path. The maxPlayers coupling is cross-field, so it lives here only.
+    const uploadHz = m.multiplayer?.uploadHz;
+    if (uploadHz !== undefined) {
+        if (!exports.MULTIPLAYER_CAPS.uploadHzAllowed.includes(uploadHz)) {
+            errors.push(`manifest: multiplayer.uploadHz ${uploadHz} must be ${exports.MULTIPLAYER_CAPS.uploadHzAllowed.join(' or ')}`);
+        }
+        else if (uploadHz === 20 && m.maxPlayers > exports.MULTIPLAYER_CAPS.maxPlayersAt20Hz) {
+            errors.push(`manifest: multiplayer.uploadHz 20 caps maxPlayers at ${exports.MULTIPLAYER_CAPS.maxPlayersAt20Hz} (got ${m.maxPlayers}) — lower maxPlayers to ${exports.MULTIPLAYER_CAPS.maxPlayersAt20Hz} or uploadHz to 10`);
+        }
+    }
+    // v0.3 declared state (Tier 2 Phase 1.3): the JSON schema validated each VarType's SHAPE; here we add the
+    // cross-field semantics it can't express — declared state requires the multiplayer permission, and every
+    // var's default must satisfy its own declared constraints.
+    const state = m.multiplayer?.state;
+    if (state && !multiplayer)
+        errors.push('manifest: multiplayer.state requires the "multiplayer" permission');
+    if (state) {
+        errors.push(...checkStateCaps(state)); // §11.1 caps first — a precise "over the cap" message
+        const bags = [
+            ['roomVars', state.roomVars],
+            ['playerVars', state.playerVars],
+        ];
+        for (const [scope, decls] of bags) {
+            if (!decls)
+                continue;
+            // A declared var may not shadow a reserved built-in (else it's silently unreadable/unwritable — the built-in
+            // wins). roomVars vs room built-ins (phase); playerVars vs player built-ins (position/connected/active).
+            const reserved = scope === 'roomVars' ? ROOM_BUILTIN_TYPES : PLAYER_BUILTIN_TYPES;
+            for (const [name, vt] of Object.entries(decls)) {
+                if (name in reserved)
+                    errors.push(`multiplayer.state.${scope}.${name}: "${name}" is a reserved ${scope === 'roomVars' ? 'room' : 'player'} built-in — rename the var`);
+                errors.push(...checkVarDefault(`multiplayer.state.${scope}.${name}`, vt));
+            }
+        }
+    }
+    const entities = m.multiplayer?.entities;
+    if (entities) {
+        if (!multiplayer)
+            errors.push('manifest: multiplayer.entities requires the "multiplayer" permission');
+        const en = checkEntities(entities);
+        errors.push(...en.errors);
+        warnings.push(...en.warnings);
+    }
+    const zones = m.multiplayer?.zones;
+    if (zones) {
+        if (!multiplayer)
+            errors.push('manifest: multiplayer.zones requires the "multiplayer" permission');
+        const z = checkZones(zones, new Set(Object.keys(entities ?? {})));
+        errors.push(...z.errors);
+        warnings.push(...z.warnings);
+    }
+    const events = m.multiplayer?.events;
+    if (events) {
+        if (!multiplayer)
+            errors.push('manifest: multiplayer.events requires the "multiplayer" permission');
+        errors.push(...checkEvents(events));
+    }
+    const actions = m.multiplayer?.actions;
+    if (actions) {
+        if (!multiplayer)
+            errors.push('manifest: multiplayer.actions requires the "multiplayer" permission');
+        errors.push(...checkActions(actions));
+    }
+    const states = m.multiplayer?.states;
+    if (states) {
+        if (!multiplayer)
+            errors.push('manifest: multiplayer.states requires the "multiplayer" permission');
+        errors.push(...checkStates(states));
+        errors.push(...checkJoinPolicy(m)); // §8/3.5 per-phase late-join policies
+    }
+    const timers = m.multiplayer?.timers;
+    if (timers) {
+        if (!multiplayer)
+            errors.push('manifest: multiplayer.timers requires the "multiplayer" permission');
+        const names = Object.keys(timers);
+        if (names.length > exports.MULTIPLAYER_CAPS.timers)
+            errors.push(`manifest: multiplayer.timers declares ${names.length} timers — the cap is ${exports.MULTIPLAYER_CAPS.timers}`);
+        // §9 (Phase 4.5) an entity-keyed timer's `keyed:'entity:<kind>'` must name a declared entity kind.
+        const entityKinds = new Set(Object.keys(m.multiplayer?.entities ?? {}));
+        for (const [name, t] of Object.entries(timers)) {
+            if (typeof t.keyed === 'string' && t.keyed.startsWith('entity:')) {
+                const kind = t.keyed.slice('entity:'.length);
+                if (!entityKinds.has(kind))
+                    errors.push(`multiplayer.timers."${name}": keyed:'entity:${kind}' references unknown entity kind "${kind}"${didYouMean(kind, [...entityKinds])} (declared entities: ${[...entityKinds].join(', ') || 'none'})`);
+            }
+        }
+    }
+    if (m.multiplayer?.rules) {
+        if (!multiplayer)
+            errors.push('manifest: multiplayer.rules requires the "multiplayer" permission');
+        errors.push(...checkRules(m));
+        // §5.2 (4.9) accept + loud-no-op: a reserved future node warns (strict → errors), a typo errors did-you-mean.
+        const future = checkFutureNodes(m, strict);
+        errors.push(...future.errors);
+        warnings.push(...future.warnings);
+        // §9/§11.6 (4.6b) cross-player FIREWALL: a client-uploaded owner-entity id can't aim a cross-player effect.
+        errors.push(...checkFirewall(m));
+        // §3.6/§11.3 cascade analysis: reject a within-tick re-fire cycle + compute maxCascadeDepth for the budget.
+        const cascade = analyzeCascade(m.multiplayer.rules, states?.phases ?? []);
+        errors.push(...cascade.errors);
+        // §9/§11.3 (4.5) reject a within-tick unbounded entitySpawn → spawnEntity loop (the entity twin of the above).
+        errors.push(...analyzeEntityCascade(m.multiplayer.rules));
+        errors.push(...checkBudget(m.multiplayer.rules, m.multiplayer.timers ?? {}, cascade.maxDepth, states, maxDeclaredListLen(m)));
+        // §14 (4.5) single-player-safe gate: a solo-declared world (minPlayers 1) must not gate a phase transition
+        // behind playerCount ≥ 2 (a solo player would be soft-locked). Warns; strict (launch) flips it to an error.
+        const solo = checkSoloSafety(m, strict);
+        errors.push(...solo.errors);
+        warnings.push(...solo.warnings);
+    }
     return { errors, warnings };
 }
+// §8 state machine: the phase set is capped + `initial` must be one of the declared phases (the schema already
+// enforced unique names + the identifier pattern). One room-scoped machine per world.
+function checkStates(states) {
+    const e = [];
+    if (states.phases.length > exports.MULTIPLAYER_CAPS.phases) {
+        e.push(`manifest: multiplayer.states declares ${states.phases.length} phases — the cap is ${exports.MULTIPLAYER_CAPS.phases}`);
+    }
+    if (!states.phases.includes(states.initial)) {
+        e.push(`manifest: multiplayer.states.initial "${states.initial}"${didYouMean(states.initial, states.phases)} is not one of phases [${states.phases.join(', ')}]`);
+    }
+    return e;
+}
+// §8/3.5 per-phase late-join policy: each keyed phase must be declared; each onLateJoin effect validates like a
+// playerJoin rule's `then` (bound self = the joiner) — full effect grammar + timer resolution — under the
+// onLateJoin effect cap. Gathers the symbol tables from the manifest (independent of the `rules` array).
+function checkJoinPolicy(m) {
+    const states = m.multiplayer?.states;
+    if (!states?.joinPolicy)
+        return [];
+    const e = [];
+    const phases = new Set(states.phases);
+    const roomVars = m.multiplayer?.state?.roomVars ?? {};
+    const playerVars = m.multiplayer?.state?.playerVars ?? {};
+    const zoneIds = new Set((m.multiplayer?.zones ?? []).map((z) => z.id));
+    const events = m.multiplayer?.events ?? {};
+    const timersDecl = m.multiplayer?.timers ?? {};
+    const ec = buildEntityCtx(m);
+    const joinBound = new Set(['self']); // the joiner is `self` in onLateJoin
+    for (const [phase, policy] of Object.entries(states.joinPolicy)) {
+        const path = `multiplayer.states.joinPolicy."${phase}"`;
+        if (!phases.has(phase)) {
+            e.push(`${path}: unknown phase "${phase}"${didYouMean(phase, [...phases])} (declared phases: ${[...phases].join(', ') || 'none'})`);
+        }
+        const effects = policy.onLateJoin ?? [];
+        if (effects.length > exports.MULTIPLAYER_CAPS.joinPolicyEffects) {
+            e.push(`${path}.onLateJoin has ${effects.length} effects — the cap is ${exports.MULTIPLAYER_CAPS.joinPolicyEffects}`);
+        }
+        effects.forEach((eff, k) => e.push(...checkEffect(`${path}.onLateJoin[${k}]`, eff, joinBound, roomVars, playerVars, zoneIds, events, phases, ec)));
+        e.push(...checkTimerRefs(`${path}.onLateJoin`, { when: { on: 'playerJoin' }, then: effects }, timersDecl, joinBound, roomVars, playerVars, zoneIds, ec));
+    }
+    return e;
+}
+// §3.6/§11.3 cascade analysis over the phase graph: an edge P→Q exists when a stateEnter:P / stateExit:P rule
+// has a transitionTo:Q (Q≠P — a transitionTo to the just-entered phase is a runtime no-op). A CYCLE means a
+// within-tick infinite re-fire → publish REJECTS it. Otherwise maxCascadeDepth = the longest path (the BFS
+// levels the runtime drain can reach), feeding the §11.2 budget. Sound + conservative: stateExit edges are
+// included (the runtime MAX_CASCADE_DEPTH backstop is the final guard for any exotic case this misses).
+function analyzeCascade(rules, phases) {
+    const adj = new Map();
+    for (const p of phases)
+        adj.set(p, new Set());
+    for (const rule of rules) {
+        const w = rule.when;
+        if (w.on !== 'stateEnter' && w.on !== 'stateExit')
+            continue;
+        const from = w.phase;
+        if (!adj.has(from))
+            adj.set(from, new Set());
+        for (const target of transitionTargets(rule.then))
+            if (target !== from)
+                adj.get(from).add(target);
+    }
+    // Cycle detection (DFS colouring) — any back-edge is a within-tick re-fire loop.
+    const WHITE = 0, GREY = 1, BLACK = 2;
+    const color = new Map();
+    let cyclic = false;
+    const visit = (n) => {
+        color.set(n, GREY);
+        for (const m of adj.get(n) ?? []) {
+            const c = color.get(m) ?? WHITE;
+            if (c === GREY)
+                cyclic = true;
+            else if (c === WHITE)
+                visit(m);
+        }
+        color.set(n, BLACK);
+    };
+    for (const n of adj.keys())
+        if ((color.get(n) ?? WHITE) === WHITE)
+            visit(n);
+    if (cyclic) {
+        return { errors: ['manifest: multiplayer.rules has a stateEnter/stateExit → transitionTo cycle that would re-fire forever within a tick — break the loop (gate a transition behind a tick/timer/event instead)'], maxDepth: 0 };
+    }
+    // Longest path in the DAG (memoized DFS) = the deepest cascade chain.
+    const depth = new Map();
+    const longest = (n) => {
+        const memo = depth.get(n);
+        if (memo !== undefined)
+            return memo;
+        let best = 0;
+        for (const m of adj.get(n) ?? [])
+            best = Math.max(best, 1 + longest(m));
+        depth.set(n, best);
+        return best;
+    };
+    let maxDepth = 0;
+    for (const n of adj.keys())
+        maxDepth = Math.max(maxDepth, longest(n));
+    return { errors: [], maxDepth };
+}
+// The transitionTo target phases reachable in an effect list (top level + inside a forEachPlayer body).
+function transitionTargets(effects) {
+    const out = [];
+    for (const eff of effects) {
+        if (eff.do === 'transitionTo')
+            out.push(eff.phase);
+        else if (eff.do === 'forEachPlayer' || eff.do === 'forEachEntity')
+            out.push(...transitionTargets(eff.then));
+    }
+    return out;
+}
+// §9/§11.3 (Phase 4.5) entity-cascade analysis: an edge K→K2 exists when an `entitySpawn:K` rule mints a K2 —
+// handling one spawn enqueues another. A CYCLE is a within-tick UNBOUNDED spawn loop (spawning A eventually
+// spawns A again, a fresh entity each pass) → publish REJECTS it. Only `entitySpawn` events seed edges:
+// `entityDestroy`/`tick`/etc. spawns are bounded (finite live entities each destroyed once; a tick spawns once,
+// capped by the budget + MAX_ENTITIES_PER_KIND). Sound + conservative — no false positives (every edge is a real
+// spawn→spawn re-trigger); the runtime MAX_CASCADE_DEPTH + MAX_ENTITIES_PER_KIND backstops catch anything subtler.
+function analyzeEntityCascade(rules) {
+    const adj = new Map();
+    for (const rule of rules) {
+        if (rule.when.on !== 'entitySpawn')
+            continue;
+        const from = rule.when.kind;
+        if (!adj.has(from))
+            adj.set(from, new Set());
+        for (const target of spawnTargets(rule.then))
+            adj.get(from).add(target);
+    }
+    const WHITE = 0, GREY = 1, BLACK = 2;
+    const color = new Map();
+    let cyclic = false;
+    const visit = (n) => {
+        color.set(n, GREY);
+        for (const m of adj.get(n) ?? []) {
+            const c = color.get(m) ?? WHITE;
+            if (c === GREY)
+                cyclic = true;
+            else if (c === WHITE)
+                visit(m);
+        }
+        color.set(n, BLACK);
+    };
+    for (const n of adj.keys())
+        if ((color.get(n) ?? WHITE) === WHITE)
+            visit(n);
+    return cyclic
+        ? ['manifest: multiplayer.rules has an entitySpawn → spawnEntity cycle that would mint entities forever within a tick — break the loop (gate the spawn behind a tick/timer/non-entity event instead)']
+        : [];
+}
+// The entity kinds a spawnEntity mints anywhere in an effect list (top level + inside a forEachPlayer body).
+function spawnTargets(effects) {
+    const out = [];
+    for (const eff of effects) {
+        if (eff.do === 'spawnEntity')
+            out.push(eff.kind);
+        else if (eff.do === 'forEachPlayer' || eff.do === 'forEachEntity')
+            out.push(...spawnTargets(eff.then));
+    }
+    return out;
+}
+// §14 (4.5) does this condition REQUIRE playerCount ≥ 2 (i.e. is it unsatisfiable with a single player)? Detects
+// the explicit `playerCount <cmp> n` patterns (either operand order), AND (any child requires), OR (all children
+// require). Conservative — anything it can't prove returns false, so the solo gate only warns on a clear soft-lock.
+function requiresMultiplePlayers(expr) {
+    if (typeof expr !== 'object' || expr === null || 'vec3' in expr || 'var' in expr || 'ref' in expr)
+        return false;
+    const n = expr;
+    if (n.op === 'and')
+        return Array.isArray(n.of) && n.of.some(requiresMultiplePlayers);
+    if (n.op === 'or')
+        return Array.isArray(n.of) && n.of.length > 0 && n.of.every(requiresMultiplePlayers);
+    const cmps = ['==', '<', '<=', '>', '>='];
+    if (n.op === undefined || !cmps.includes(n.op))
+        return false;
+    // playerCount OR its exact equivalent — an UNFILTERED count over the whole player domain. A `where` makes the
+    // value ≤ playerCount (and 0-or-1 at a single player), so the value-at-1 substitution below no longer holds:
+    // stay conservative and don't treat a filtered count as playerCount. (P2 — catches aggregate-count soft-locks.)
+    const isPc = (x) => {
+        if (typeof x !== 'object' || x === null)
+            return false;
+        const o = x;
+        return o.op === 'playerCount' || (o.op === 'aggregate' && o.agg === 'count' && o.scope === 'players' && o.where === undefined);
+    };
+    const flip = { '==': '==', '<': '>', '<=': '>=', '>': '<', '>=': '<=' };
+    let pcOp;
+    let threshold;
+    if (isPc(n.a) && typeof n.b === 'number') {
+        pcOp = n.op;
+        threshold = n.b;
+    }
+    else if (isPc(n.b) && typeof n.a === 'number') {
+        pcOp = flip[n.op];
+        threshold = n.a;
+    }
+    if (pcOp === undefined || threshold === undefined)
+        return false;
+    // "playerCount <pcOp> threshold" requires ≥2 iff playerCount == 1 does NOT satisfy it.
+    const satisfiedAtOne = pcOp === '==' ? 1 === threshold : pcOp === '<' ? 1 < threshold : pcOp === '<=' ? 1 <= threshold : pcOp === '>' ? 1 > threshold : 1 >= threshold;
+    return !satisfiedAtOne;
+}
+// §14 (4.5) single-player-safe gate: a world that declares itself solo-playable (minPlayers 1, the default) must
+// not gate a phase TRANSITION behind playerCount ≥ 2 — a solo player could never trigger it and would be stuck.
+// Warns per offending rule; strict (the launch pipeline) flips the warnings to errors. A world that genuinely
+// needs multiple players declares minPlayers ≥ 2 and the gate stands down. Only meaningful with a state machine.
+function checkSoloSafety(m, strict) {
+    const out = { errors: [], warnings: [] };
+    const mp = m.multiplayer;
+    if (!mp || !mp.states || (mp.minPlayers ?? 1) > 1)
+        return out;
+    (mp.rules ?? []).forEach((rule, i) => {
+        if (!requiresMultiplePlayers(rule.if))
+            return;
+        const targets = transitionTargets(rule.then);
+        if (targets.length === 0)
+            return;
+        const msg = `multiplayer.rules[${i}]: the transition (→ ${targets.join('/')}) only fires when playerCount ≥ 2, but the world is single-player-safe (minPlayers 1) — a solo player can't trigger it. Add a solo/timer path, or set multiplayer.minPlayers ≥ 2 if the world needs multiple players.`;
+        if (strict)
+            out.errors.push(`${msg} [rejected: pre-launch strict mode]`);
+        else
+            out.warnings.push(msg);
+    });
+    return out;
+}
+// §8 the single timer-validation authority: every timerElapsed/startTimer/cancelTimer/timerRemaining names a
+// declared timer (did-you-mean on a miss); keyed-ness agreement (a keyed:'player' timer needs a player `key`,
+// a room-scoped one takes none — N15: keyed-ness is static per name); the `key` ref resolves; the startTimer
+// 1-tick floor. Best-effort over the realistic placements — the runtime treats an unknown/inactive timer as 0
+// and a null key as a no-op (never throws), so an unresolved use is a publish-UX error, not unsafe.
+function checkTimerRefs(path, rule, timers, bound, roomVars, playerVars, zoneIds, ec) {
+    const e = [];
+    const declared = Object.keys(timers);
+    const uses = [];
+    if (rule.if !== undefined)
+        for (const u of exprTimerUses(rule.if))
+            uses.push({ ...u, path: `${path}.if`, bound });
+    collectEffectTimerUses(rule.then, `${path}.then`, bound, uses, e);
+    // timerElapsed (the event) — name existence only; its self-binding is derived from keyed-ness in boundNames.
+    if (rule.when.on === 'timerElapsed' && !(rule.when.timer in timers)) {
+        e.push(`${path}.when: timerElapsed references unknown timer "${rule.when.timer}"${didYouMean(rule.when.timer, declared)} (declared timers: ${declared.join(', ') || 'none — add multiplayer.timers'})`);
+    }
+    for (const u of uses) {
+        if (!(u.timer in timers)) {
+            e.push(`${u.path}: references unknown timer "${u.timer}"${didYouMean(u.timer, declared)} (declared timers: ${declared.join(', ') || 'none — add multiplayer.timers'})`);
+            continue;
+        }
+        const keyedKind = timers[u.timer]?.keyed; // undefined | 'player' | 'entity:<kind>'
+        if (keyedKind !== undefined && u.key === undefined) {
+            const refHint = keyedKind === 'player' ? 'a player ref, e.g. "self"' : `an entity ref (a ${keyedKind})`;
+            e.push(`${u.path}: timer "${u.timer}" is keyed:'${keyedKind}' — it needs a "key" (${refHint})`);
+        }
+        if (keyedKind === undefined && u.key !== undefined)
+            e.push(`${u.path}: timer "${u.timer}" is room-scoped — it takes no "key" (or declare it keyed)`);
+        if (u.key !== undefined) {
+            const kr = resolveRefSlot(`${u.path}.key`, u.key, u.bound, roomVars, playerVars, zoneIds, ec);
+            e.push(...kr.errors);
+            // §9 (4.5, row 15) the key's static kind must match the timer's keyed kind — a wrong-kind key would key a
+            // dead instance at runtime (no-op). Only checked when the key's kind is statically known (else no false positive).
+            if (kr.errors.length === 0 && keyedKind !== undefined && kr.kind !== undefined) {
+                const wantEntity = keyedKind.startsWith('entity:');
+                const gotEntity = kr.kind.type === 'entity';
+                const gotKind = bindingKind(kr.kind);
+                if (wantEntity !== gotEntity || (wantEntity && gotKind !== keyedKind.slice('entity:'.length))) {
+                    const got = gotEntity ? `entity:${gotKind}` : 'player';
+                    e.push(`${u.path}.key: timer "${u.timer}" is keyed:'${keyedKind}' but its key resolves to a ${got} ref — they must match`);
+                }
+            }
+        }
+    }
+    return e;
+}
+// The timerRemaining uses (timer + optional key) anywhere in an expression tree (logic / arithmetic / cmp).
+function exprTimerUses(expr) {
+    if (typeof expr !== 'object' || expr === null || 'vec3' in expr || 'var' in expr || 'ref' in expr)
+        return [];
+    const node = expr;
+    if (node.op === 'timerRemaining')
+        return node.timer ? [{ timer: node.timer, key: node.key }] : [];
+    if (node.op === 'and' || node.op === 'or')
+        return node.of.flatMap(exprTimerUses);
+    if (node.op === 'not')
+        return exprTimerUses(node.of);
+    if (node.a !== undefined)
+        return [...exprTimerUses(node.a), ...exprTimerUses(node.b)];
+    return [];
+}
+// Walk an effect list (incl. nested forEachPlayer, which widens `bound` with its `as`) collecting startTimer/
+// cancelTimer uses (+ the startTimer duration floor) and any timerRemaining uses in their value-exprs.
+function collectEffectTimerUses(effects, path, bound, uses, e) {
+    effects.forEach((eff, j) => {
+        const p = `${path}[${j}]`;
+        if (eff.do === 'startTimer') {
+            uses.push({ timer: eff.timer, key: eff.key, path: p, bound });
+            // The static floor only binds a LITERAL duration; an expression's value is unknown at publish, so its
+            // sub-floor/NaN/∞/negative handling is deferred to the runtime clamp/skip (spec §3.2). The expr's type +
+            // node budget are validated in validateEffect like any other effect-borne expression.
+            if (typeof eff.seconds === 'number' && eff.seconds < exports.MULTIPLAYER_CAPS.timerMinSeconds)
+                e.push(`${p}: startTimer "${eff.timer}" seconds ${eff.seconds} is below the ${exports.MULTIPLAYER_CAPS.timerMinSeconds}s floor (one sim tick)`);
+        }
+        else if (eff.do === 'cancelTimer') {
+            uses.push({ timer: eff.timer, key: eff.key, path: p, bound });
+        }
+        else if (eff.do === 'set' || eff.do === 'teleport' || eff.do === 'respawn') {
+            for (const u of exprTimerUses(eff.to))
+                uses.push({ ...u, path: p, bound });
+        }
+        else if (eff.do === 'forEachPlayer' || eff.do === 'forEachEntity') {
+            const inner = new Set([...bound, eff.as]);
+            if (eff.where !== undefined)
+                for (const u of exprTimerUses(eff.where))
+                    uses.push({ ...u, path: p, bound: inner });
+            collectEffectTimerUses(eff.then, `${p}.then`, inner, uses, e);
+        }
+        else if (eff.do === 'broadcast') {
+            for (const v of Object.values(eff.payload ?? {}))
+                for (const u of exprTimerUses(v))
+                    uses.push({ ...u, path: p, bound });
+        }
+    });
+}
+// Wire message-type names a declared event (or action) name may not shadow — kept in sync with
+// RESERVED_MESSAGE_TYPES in @hypersoniclabs/helix-sdk/multiplayer-contract (the manifest takes no SDK dep).
+const RESERVED_EVENT_NAMES = new Set(['state', 'ability', 'action', 'entityState', 'entityStateBatch', 'ping', 'pong', 'stateAck', 'entityStateAck']);
+// §10.3 events: count + reserved-name + payload-field caps. A `ref` payload field must declare `of` (the
+// schema enforces shape + the identifier name pattern; this adds the cross-field semantics).
+function checkEvents(events) {
+    const e = [];
+    const names = Object.keys(events);
+    if (names.length > exports.MULTIPLAYER_CAPS.events)
+        e.push(`manifest: multiplayer.events declares ${names.length} events — the cap is ${exports.MULTIPLAYER_CAPS.events}`);
+    for (const name of names) {
+        if (RESERVED_EVENT_NAMES.has(name))
+            e.push(`multiplayer.events."${name}": is a reserved wire message name — rename the event`);
+        const payload = events[name].payload ?? {};
+        const fields = Object.keys(payload);
+        if (fields.length > exports.MULTIPLAYER_CAPS.broadcastFields) {
+            e.push(`multiplayer.events."${name}": payload has ${fields.length} fields — the cap is ${exports.MULTIPLAYER_CAPS.broadcastFields}`);
+        }
+        for (const f of fields) {
+            const ft = payload[f];
+            if (ft.type === 'ref' && ft.of === undefined)
+                e.push(`multiplayer.events."${name}".payload.${f}: a ref field must declare "of"`);
+            // §10.3 (P3-B6) a collection-snapshot field — validate its element/keys shape like a var collection.
+            if (ft.type === 'list' && typeof ft.of === 'object' && ft.of.type === 'record') {
+                const rfields = Object.keys(ft.of.fields);
+                if (rfields.length > exports.MULTIPLAYER_CAPS.recordFields)
+                    e.push(`multiplayer.events."${name}".payload.${f}: a record element declares ${rfields.length} fields — the cap is ${exports.MULTIPLAYER_CAPS.recordFields}`);
+                for (const rn of rfields)
+                    e.push(...checkRecordField(`multiplayer.events."${name}".payload.${f}.of.fields.${rn}`, ft.of.fields[rn]));
+            }
+            if (ft.type === 'counterMap') {
+                if (ft.keys.length === 0)
+                    e.push(`multiplayer.events."${name}".payload.${f}: counterMap needs at least one key`);
+                else if (ft.keys.length > exports.MULTIPLAYER_CAPS.counterKeys)
+                    e.push(`multiplayer.events."${name}".payload.${f}: counterMap has ${ft.keys.length} keys — the cap is ${exports.MULTIPLAYER_CAPS.counterKeys}`);
+                if (new Set(ft.keys).size !== ft.keys.length)
+                    e.push(`multiplayer.events."${name}".payload.${f}: counterMap keys must be unique`);
+            }
+        }
+    }
+    return e;
+}
+// §11.5 actions: count + reserved-name + arg-count caps + arg-shape cross-fields (ref needs `of`; number
+// min ≤ max). The room validates a client's args against this schema (type/bounds/liveness) before firing.
+function checkActions(actions) {
+    const e = [];
+    const names = Object.keys(actions);
+    if (names.length > exports.MULTIPLAYER_CAPS.actions)
+        e.push(`manifest: multiplayer.actions declares ${names.length} actions — the cap is ${exports.MULTIPLAYER_CAPS.actions}`);
+    for (const name of names) {
+        if (RESERVED_EVENT_NAMES.has(name))
+            e.push(`multiplayer.actions."${name}": is a reserved wire message name — rename the action`);
+        const args = actions[name].args ?? {};
+        const argNames = Object.keys(args);
+        if (argNames.length > exports.MULTIPLAYER_CAPS.actionArgs)
+            e.push(`multiplayer.actions."${name}": ${argNames.length} args — the cap is ${exports.MULTIPLAYER_CAPS.actionArgs}`);
+        for (const a of argNames) {
+            const at = args[a];
+            if (at.type === 'ref' && at.of === undefined)
+                e.push(`multiplayer.actions."${name}".args.${a}: a ref arg must declare "of"`);
+            if (at.type === 'number' && at.min !== undefined && at.max !== undefined && at.min > at.max)
+                e.push(`multiplayer.actions."${name}".args.${a}: min ${at.min} exceeds max ${at.max}`);
+        }
+    }
+    return e;
+}
+// §11.2 static per-tick budget: a conservative WORST-CASE count of node-evaluations one tick could do across
+// §5 (P3 ext) the worst-case element count the cost model charges a list-scan op (forEachInList / removeWhere /
+// listCount / listIndexOf) — set to the LARGEST declared list maxLen in the config (a sound, much tighter bound than
+// the global listMaxLen cap, since no list can exceed its own declared maxLen, and a {ref,var} scan can't exceed the
+// largest declared list). checkBudget assigns it before the cost walk; defaults to the global cap (no lists declared).
+let budgetListCap = exports.MULTIPLAYER_CAPS.listMaxLen;
+// The largest declared `list` maxLen across roomVars / playerVars / every entity kind's vars (capped at the global
+// ceiling); the global cap when no list is declared. Bounds the per-tick cost of list-scan ops precisely.
+function maxDeclaredListLen(m) {
+    let max = 0;
+    const scan = (decls) => {
+        for (const vt of Object.values(decls ?? {}))
+            if (vt.type === 'list')
+                max = Math.max(max, vt.maxLen);
+    };
+    scan(m.multiplayer?.state?.roomVars);
+    scan(m.multiplayer?.state?.playerVars);
+    for (const e of Object.values(m.multiplayer?.entities ?? {}))
+        scan(e.vars);
+    return max > 0 ? Math.min(max, exports.MULTIPLAYER_CAPS.listMaxLen) : exports.MULTIPLAYER_CAPS.listMaxLen;
+}
+// all rules — Σ fireCount(event) × ruleCost. fireCount is how many times an event can fire per tick (tick=1;
+// player/zone events ≤ playerCap; playerContact ≤ playerCap²; self varReached ≤ playerCap; a keyed timerElapsed
+// ≤ playerCap / entitiesPerKind — so `timers` is threaded in). ruleCost sums the `if` + each effect, weighting
+// reductions (aggregate/nearest*) + forEach fanout by the player cap. Over budget → publish fails. Shape-based,
+// so it runs after the schema validated the rule shapes. `listCap` bounds list-scan cost (largest declared maxLen).
+function checkBudget(rules, timers, maxCascadeDepth = 0, states, listCap = exports.MULTIPLAYER_CAPS.listMaxLen) {
+    budgetListCap = listCap; // set before the cost walk (covers ruleCost + joinLateCost list-scan charges)
+    let base = 0;
+    for (const rule of rules)
+        base += fireCount(rule.when, timers) * ruleCost(rule);
+    // §11.2 cascade term (N9): each cascade level can re-evaluate the matched state rules, so the worst case is
+    // the base batch ×(1 + maxCascadeDepth). maxCascadeDepth is the cycle-free longest chain from analyzeCascade.
+    // `joinLate` is the worst-case onLateJoin cost (≤ player cap joins/tick) from joinPolicy (§8/3.5).
+    const total = base * (1 + maxCascadeDepth) + joinLateCost(states);
+    if (total > exports.MULTIPLAYER_CAPS.tickNodeBudget) {
+        return [
+            `manifest: multiplayer.rules worst-case ~${total} node-evaluations/tick (incl. the ×${1 + maxCascadeDepth} cascade factor) exceeds the per-tick budget of ${exports.MULTIPLAYER_CAPS.tickNodeBudget} — simplify rules (fewer effects, less forEach/aggregate, fewer playerContact rules, shallower phase cascades) or split the world`,
+        ];
+    }
+    return [];
+}
+// §8/3.5 the worst-case onLateJoin cost charged to the per-tick budget: a join runs one phase's onLateJoin, and
+// up to a roomful can join in a tick — so sum the effect costs across all phases' policies × the player cap (a
+// safe over-estimate; only the current phase's policy actually fires).
+function joinLateCost(states) {
+    if (!states?.joinPolicy)
+        return 0;
+    let sum = 0;
+    for (const policy of Object.values(states.joinPolicy))
+        sum += (policy.onLateJoin ?? []).reduce((s, eff) => s + effectCost(eff), 0);
+    return sum * exports.PLATFORM_MAX_PLAYERS_PER_ROOM;
+}
+// How many times an event's rule can fire in one tick — the budget multiplier. Bounded by the player cap
+// (PLATFORM_MAX_PLAYERS_PER_ROOM); playerContact is pairwise × both directions (≈ cap²).
+function fireCount(event, timers) {
+    const p = exports.PLATFORM_MAX_PLAYERS_PER_ROOM;
+    switch (event.on) {
+        case 'tick':
+            return 1; // everyN doesn't lower the worst case (the tick it fires)
+        case 'varReached':
+            return event.scope === 'self' ? p : event.scope === 'entity' ? exports.MULTIPLAYER_CAPS.entitiesPerKind : 1; // entity scope evaluates once per live instance of the kind
+        case 'playerContact':
+            return p * p;
+        case 'stateEnter':
+        case 'stateExit':
+            return 1; // room-level, once per transition (cascade repetition is the ×depth term)
+        case 'timerElapsed': {
+            // P0.4: a keyed timer fires once PER INSTANCE in a tick — up to the player cap (keyed:'player') or the
+            // per-kind entity cap (keyed:'entity:<kind>'), not once. Charging it 1 lets an entity-keyed timer body
+            // pass publish then stall the sim. Room-scoped (undefined) is a single expiry.
+            const keyed = timers[event.timer]?.keyed;
+            if (keyed === 'player')
+                return p;
+            if (typeof keyed === 'string' && keyed.startsWith('entity:'))
+                return exports.MULTIPLAYER_CAPS.entitiesPerKind;
+            return 1;
+        }
+        default:
+            return p; // playerJoin / playerLeave / zoneEnter / zoneExit / zoneInside — up to once per player
+    }
+}
+// Worst-case node-evals to run a rule once: the `if` condition + every effect.
+function ruleCost(rule) {
+    return (rule.if !== undefined ? exprCost(rule.if) : 0) + rule.then.reduce((sum, eff) => sum + effectCost(eff), 0);
+}
+// Node-evals to evaluate an expression once. A reduction (aggregate / nearestPlayer) is an O(members) scan,
+// so it costs the player cap; everything else is 1 per node + its children.
+function exprCost(expr) {
+    if (typeof expr !== 'object' || expr === null)
+        return 1;
+    if ('vec3' in expr)
+        return 1;
+    if ('ref' in expr)
+        return 1 + refCost(expr.ref);
+    if ('var' in expr)
+        return 1;
+    const node = expr;
+    if (node.op === 'aggregate' || node.op === 'nearestPlayer')
+        return exports.PLATFORM_MAX_PLAYERS_PER_ROOM; // O(members) scan
+    if (node.op === 'playerCount' || node.op === 'random' || node.op === 'timeInState' || node.op === 'timerRemaining' || node.op === 'now')
+        return 1; // O(1) leaves
+    if (node.op === 'randomPoint')
+        return 1; // O(1) leaf → vec3
+    if (node.op === 'listLength' || node.op === 'count')
+        return 1; // §5 (4.5.13) O(1) collection reads
+    if (node.op === 'listAt')
+        return 1 + exprCost(node.index ?? 0); // O(1) + the index expr
+    if (node.op === 'listCount' || node.op === 'listIndexOf')
+        return budgetListCap * (1 + exprCost(node.where ?? true)); // §5 (P3 ext) O(maxLen) scan × the where
+    if (node.op === 'controlledBy') {
+        const cb = expr;
+        return 1 + refCost(cb.entity) + refCost(cb.by);
+    } // §9 (P3) O(1) + the two ref resolutions
+    if (node.op === 'sameRef') {
+        const sr = expr;
+        return 1 + refCost(sr.a) + refCost(sr.b);
+    } // §7.3 (P3-B2) O(1) identity + the two ref resolutions
+    if (node.op === 'hostLoad')
+        return exports.MULTIPLAYER_CAPS.entitiesPerKind; // §9 (P3) O(entities) scan of the owner map
+    if (node.op === 'and' || node.op === 'or')
+        return 1 + node.of.reduce((s, e) => s + exprCost(e), 0);
+    if (node.op === 'not')
+        return 1 + exprCost(node.of);
+    return 1 + exprCost(node.a) + exprCost(node.b); // distance / binary cmp / arith
+}
+// §5 (P3 Collections) a record-list element literal vs an Expr/Ref node, for the static cost/taint walks: a plain
+// object that is NOT a recognized expr/ref node (no op/var/vec3/ref key). A record field named op/var/vec3/ref is
+// disambiguated by the list's declared element type at validation/runtime — this heuristic is only the static walk.
+function isRecordLiteral(value) {
+    return (typeof value === 'object' && value !== null && !Array.isArray(value) && !('op' in value) && !('var' in value) && !('vec3' in value) && !('ref' in value));
+}
+// §5 (P3 Collections) cost of an append/setField value: a record literal sums its field expr costs; a scalar/ref
+// value costs as an expr (exprCost tolerates the ref forms structurally).
+function collectionValueCost(value) {
+    if (isRecordLiteral(value))
+        return 1 + Object.values(value).reduce((s, v) => s + exprCost(v), 0);
+    return exprCost(value);
+}
+// Node-evals to resolve a Ref once. A bound name / ref-var deref is O(1); a ref-returning op is an
+// O(members) scan (the player cap).
+function refCost(ref) {
+    if (typeof ref === 'string')
+        return 1;
+    if ('var' in ref)
+        return 1;
+    if (ref.op === 'nearestPlayer')
+        return exports.PLATFORM_MAX_PLAYERS_PER_ROOM + exprCost(ref.from);
+    if (ref.op === 'nearestEntity')
+        return exports.MULTIPLAYER_CAPS.entitiesPerKind + exprCost(ref.from); // O(entities of a kind)
+    if (ref.op === 'controllerOf')
+        return 1 + refCost(ref.entity); // §9 (P3) O(1) field read + the entity ref resolution
+    if (ref.op === 'leastLoadedPlayer')
+        return exports.PLATFORM_MAX_PLAYERS_PER_ROOM + (ref.where !== undefined ? exprCost(ref.where) : 0); // §9 (P3) O(players) scan
+    if (ref.op === 'listAt')
+        return 1 + exprCost(ref.index); // §5 (P3-B2) O(1) element read + the index expr
+    return exports.PLATFORM_MAX_PLAYERS_PER_ROOM; // aggregate argmax|argmin
+}
+function lvalueCost(lvalue) {
+    return typeof lvalue === 'string' ? 1 : 1 + refCost(lvalue.ref);
+}
+// Node-evals to apply an effect once. forEachPlayer is the player cap × its per-iteration body (where +
+// nested effects); reductions are forbidden inside it, so the body is O(1) per iteration.
+function effectCost(eff) {
+    switch (eff.do) {
+        case 'add':
+            return 1 + lvalueCost(eff.target) + exprCost(eff.by);
+        case 'set':
+            return 1 + lvalueCost(eff.target) + exprCost(eff.to);
+        case 'setRef':
+            return 1 + lvalueCost(eff.target) + (eff.to === null ? 0 : refCost(eff.to));
+        case 'teleport':
+        case 'respawn':
+            return 1 + refCost(eff.player) + exprCost(eff.to);
+        case 'forEachPlayer': {
+            const body = (eff.where !== undefined ? exprCost(eff.where) : 0) + eff.then.reduce((s, e) => s + effectCost(e), 0);
+            return exports.PLATFORM_MAX_PLAYERS_PER_ROOM * body;
+        }
+        case 'forEachEntity': {
+            // §9 (4.5) bounded by the per-kind entity cap (live entities of a kind can't exceed it — runtime-enforced),
+            // so the static budget stays the worst case (no runtime backstop needed — the original §11.2 rationale).
+            const body = (eff.where !== undefined ? exprCost(eff.where) : 0) + eff.then.reduce((s, e) => s + effectCost(e), 0);
+            return exports.MULTIPLAYER_CAPS.entitiesPerKind * body;
+        }
+        case 'forEachInList': {
+            // §5 (P3 ext) bounded by the list's maxLen ceiling (the worst-case element count); the body is O(1) per
+            // iteration (reductions forbidden inside, like the other loops).
+            const body = (eff.where !== undefined ? exprCost(eff.where) : 0) + eff.then.reduce((s, e) => s + effectCost(e), 0);
+            return lvalueCost(eff.list) + budgetListCap * body;
+        }
+        case 'transitionTo':
+            return 1; // O(1): set the phase + enqueue stateExit/stateEnter (the cascade itself is the ×depth budget term)
+        case 'startTimer':
+            return 1 + exprCost(eff.seconds); // O(1) set + the (possibly dynamic) duration expr
+        case 'cancelTimer':
+            return 1; // O(1): delete one deadline entry
+        case 'broadcast': {
+            const toCost = typeof eff.to === 'string' ? (eff.to === 'all' ? exports.PLATFORM_MAX_PLAYERS_PER_ROOM : 1) : 'team' in eff.to ? exports.PLATFORM_MAX_PLAYERS_PER_ROOM : refCost(eff.to);
+            const payload = Object.values(eff.payload ?? {}).reduce((s, v) => s + exprCost(v), 0);
+            return 1 + toCost + payload;
+        }
+        case 'spawnEntity':
+            // O(1): mint + insert one entity + write its seed vars (its entitySpawn is the ×depth cascade term).
+            return 1 + exprCost(eff.at) + Object.values(eff.vars ?? {}).reduce((s, v) => s + exprCost(v), 0);
+        case 'destroyEntity':
+            return 1 + refCost(eff.entity); // O(1): resolve the ref + delete (entityDestroy is the ×depth cascade term)
+        case 'requestOwnership':
+        case 'takeover':
+            // O(1): resolve the refs + set controller/epoch (the ownershipChanged it fires is the ×depth cascade term).
+            return 1 + refCost(eff.entity) + (eff.to === null ? 0 : refCost(eff.to));
+        case 'append':
+            return 1 + collectionValueCost(eff.value); // §5 (4.5.13 + P3) O(1) push (+ the value's expr / record-field costs)
+        case 'clear':
+            return 1; // §5 (4.5.13) O(1) — empty the list / reset keys
+        case 'addCount':
+            return 1 + exprCost(eff.by); // §5 (4.5.13) O(1) key bump (+ the by expr)
+        case 'removeAt':
+            return 1 + exprCost(eff.index); // §5 (P3) O(1) splice (+ the index expr) — amortized; the shift is bounded by maxLen
+        case 'removeWhere':
+            return lvalueCost(eff.target) + budgetListCap * (1 + exprCost(eff.where)); // §5 (P3 ext) O(maxLen) scan × the where
+        case 'setField':
+            return 1 + (eff.index !== undefined ? exprCost(eff.index) : 0) + collectionValueCost(eff.to); // §5 (P3) O(1) field write
+        case 'advanceTurn':
+            return exports.PLATFORM_MAX_PLAYERS_PER_ROOM + lvalueCost(eff.order) + lvalueCost(eff.index); // §7.4 (P3-B2) O(order) skip-scan, bounded by the player cap
+        case 'eliminate':
+        case 'revive':
+            return 1 + refCost(eff.player); // §7.4 (P3-B2) O(1) flag toggle + the player ref resolution
+    }
+}
+// §6 zones: count cap, unique ids, an extent sanity bound, and (4.5.8) the `tracks` target. The schema already
+// validated each zone's SHAPE (shape discriminant, vec3 center, positive extents) + that `tracks` is 'players'
+// or 'entity:<kind>'; here a 'entity:<kind>' must name a DECLARED entity kind (the zone tests those entities).
+function checkZones(zones, entityKinds) {
+    const errors = [];
+    const warnings = [];
+    if (zones.length > exports.MULTIPLAYER_CAPS.zones) {
+        errors.push(`manifest: multiplayer.zones declares ${zones.length} zones — the cap is ${exports.MULTIPLAYER_CAPS.zones}`);
+    }
+    const seen = new Set();
+    zones.forEach((z, i) => {
+        const path = `multiplayer.zones[${i}]`;
+        if (seen.has(z.id))
+            errors.push(`${path}: duplicate zone id "${z.id}"`);
+        seen.add(z.id);
+        const extents = z.shape === 'sphere' ? [z.radius] : z.size;
+        if (extents.some((v) => v > exports.MULTIPLAYER_CAPS.zoneMaxExtent)) {
+            errors.push(`${path} ("${z.id}"): an extent exceeds the zone-size cap of ${exports.MULTIPLAYER_CAPS.zoneMaxExtent}`);
+        }
+        const trackKind = entityTrackKind(z.tracks);
+        if (trackKind !== undefined && !entityKinds.has(trackKind)) {
+            errors.push(`${path} ("${z.id}"): tracks "${z.tracks}" references unknown entity kind "${trackKind}"${didYouMean(trackKind, [...entityKinds])} (declared entities: ${[...entityKinds].join(', ') || 'none — add multiplayer.entities'})`);
+        }
+    });
+    return { errors, warnings };
+}
+// §9 entities (Phase 4.1): cap the declared kind count + each kind's var count, and validate every entity var's
+// default against its own constraints (same as roomVars/playerVars). Kind names + var names are pattern-enforced by
+// the schema. entitiesPerKind is a RUNTIME cap (the live-count ceiling), not a declaration count, so it isn't here.
+function checkEntities(entities) {
+    const e = [];
+    const warnings = [];
+    const kinds = Object.keys(entities);
+    if (kinds.length > exports.MULTIPLAYER_CAPS.entityKinds) {
+        e.push(`manifest: multiplayer.entities declares ${kinds.length} kinds — the cap is ${exports.MULTIPLAYER_CAPS.entityKinds}`);
+    }
+    // networked-physics (Phase 0): bound the per-world dynamic-body kind count — physicsKinds × entitiesPerKind is the
+    // worst-case client physics-body simulation load, so a small cap keeps the casual-world path cheap.
+    const physicsKindCount = kinds.filter((k) => entities[k].physics).length;
+    if (physicsKindCount > exports.MULTIPLAYER_CAPS.physicsKinds) {
+        e.push(`manifest: multiplayer.entities declares ${physicsKindCount} physics kinds — the cap is ${exports.MULTIPLAYER_CAPS.physicsKinds}`);
+    }
+    // §5 (P3 Collections) entity collections ARE allowed (P3-A1) — they're realized into the entity-var union. The
+    // union is one merged schema, so a COLLECTION var name shared across kinds must agree on its exact shape (a
+    // differing element/keys would mis-realize the shared ArraySchema/MapSchema and crash the encoder). Track shapes.
+    const seenColl = new Map();
+    for (const kind of kinds) {
+        const vars = entities[kind].vars ?? {};
+        const names = Object.keys(vars);
+        if (names.length > exports.MULTIPLAYER_CAPS.entityVars) {
+            e.push(`multiplayer.entities.${kind}.vars declares ${names.length} vars — the cap is ${exports.MULTIPLAYER_CAPS.entityVars}`);
+        }
+        for (const name of names) {
+            // An entity var may not shadow a UNIVERSAL member built-in (position). connected/active are player-only, so an
+            // entity is free to declare those (e.g. a coin's `active` = is-collectible) — see playerBuiltin.
+            if (name in PLAYER_BUILTIN_TYPES && !PLAYER_ONLY_BUILTINS.has(name))
+                e.push(`multiplayer.entities.${kind}.vars.${name}: "${name}" is a reserved member built-in — rename the var`);
+            e.push(...checkVarDefault(`multiplayer.entities.${kind}.vars.${name}`, vars[name]));
+        }
+        for (const name of names) {
+            const vt = vars[name];
+            if (vt.type !== 'list' && vt.type !== 'counterMap')
+                continue;
+            const sig = JSON.stringify(vt);
+            const prior = seenColl.get(name);
+            if (prior === undefined)
+                seenColl.set(name, sig);
+            else if (prior !== sig)
+                e.push(`multiplayer.entities.${kind}.vars.${name}: a "${name}" collection is declared with a different shape on another entity kind — collection vars shared across kinds must be identical (the entity-var union is one merged schema)`);
+        }
+        // §9 (Phase 4.6a) seek motion: `target` must name one of THIS kind's own ref vars (the member to home toward),
+        // and `speed` must be positive. The server reads `vars[target]` → that member's position each tick.
+        const motion = entities[kind].motion;
+        if (motion?.type === 'seek') {
+            const refVars = names.filter((n) => vars[n].type === 'ref');
+            if (!refVars.includes(motion.target)) {
+                e.push(`multiplayer.entities.${kind}.motion.target: seek targets "${motion.target}", which is not a ref var on "${kind}"${didYouMean(motion.target, refVars)} (ref vars: ${refVars.join(', ') || 'none'})`);
+            }
+            if (!(motion.speed > 0))
+                e.push(`multiplayer.entities.${kind}.motion.speed: seek speed must be > 0, got ${motion.speed}`);
+        }
+        // §9 (4.5) waypoints: ≥2 points (schema-enforced) + a positive speed (the schema validated point vec3 shape).
+        if (motion?.type === 'waypoints') {
+            if (motion.points.length < 2)
+                e.push(`multiplayer.entities.${kind}.motion.points: waypoints needs at least 2 points, got ${motion.points.length}`);
+            if (!(motion.speed > 0))
+                e.push(`multiplayer.entities.${kind}.motion.speed: waypoints speed must be > 0, got ${motion.speed}`);
+        }
+        // §9 (Phase 4.6b) owner authority: a client-simulated `owner` kind MUST declare a positive `maxSpeed` (the
+        // relay's movement-plausibility ceiling). `maxSpeed` on a `server` kind is ignored (server motion isn't gated) → warn.
+        const authority = entities[kind].authority ?? 'server';
+        const maxSpeed = entities[kind].maxSpeed;
+        const physics = entities[kind].physics;
+        if (authority === 'owner') {
+            if (maxSpeed === undefined)
+                e.push(`multiplayer.entities.${kind}: authority:'owner' requires a declared maxSpeed (m/s — the movement-plausibility ceiling for its relayed transform)`);
+            else if (!(maxSpeed > 0))
+                e.push(`multiplayer.entities.${kind}.maxSpeed: must be > 0, got ${maxSpeed}`);
+            // An owner entity is client-simulated; server motion would fight its uploaded transform — UNLESS it also
+            // declares `physics` (the networked-physics HYBRID, Phase 3.5: the server runs `motion` while the body is
+            // unowned, a client takes over the dynamic physics on contact, then it rejoins the path). So a non-static
+            // motion is only an error when there is NO physics block to make it the hybrid.
+            if (entities[kind].motion && entities[kind].motion.type !== 'static' && !physics)
+                e.push(`multiplayer.entities.${kind}: authority:'owner' is client-simulated — it can't also declare server motion "${entities[kind].motion.type}" (drop motion, use authority:'server', or add a physics block for the server-behaved hybrid)`);
+        }
+        else if (maxSpeed !== undefined) {
+            warnings.push(`multiplayer.entities.${kind}.maxSpeed: ignored on a server-authoritative kind (server motion is deterministic, not gated) — set authority:'owner' or remove maxSpeed`);
+        }
+        // §9 (Phase 4.8) shared (game-owned, host-migrated) entities: shared requires authority:'owner' + the
+        // hostMigrate lifecycle (the server assigns + re-elects the host); hostMigrate is shared-only.
+        const lifecycle = entities[kind].ownerLifecycle;
+        if (entities[kind].shared) {
+            if (authority !== 'owner')
+                e.push(`multiplayer.entities.${kind}: shared:true requires authority:'owner' (a shared entity is hosted + simulated by a client)`);
+            if (lifecycle !== 'hostMigrate')
+                e.push(`multiplayer.entities.${kind}: shared:true requires ownerLifecycle:'hostMigrate' (got "${lifecycle ?? 'despawnWithOwner (default)'}")`);
+        }
+        else if (lifecycle === 'hostMigrate') {
+            e.push(`multiplayer.entities.${kind}: ownerLifecycle:'hostMigrate' is only for shared:true entities — a single-owner entity uses despawnWithOwner/persist/migrateToServer`);
+        }
+        const idleTimeout = entities[kind].idleTimeout;
+        if (idleTimeout !== undefined && !(idleTimeout > 0))
+            e.push(`multiplayer.entities.${kind}.idleTimeout: must be > 0 seconds, got ${idleTimeout}`);
+        // §9 (4.5.12) voluntary ownership transfer is only for client-simulated entities (they have a transferable controller).
+        const transferPolicy = entities[kind].transferPolicy ?? 'fixed';
+        if (transferPolicy !== 'fixed' && authority !== 'owner') {
+            e.push(`multiplayer.entities.${kind}: transferPolicy:'${transferPolicy}' requires authority:'owner' (only a client-simulated entity has a transferable controller)`);
+        }
+        // networked-physics (Phase 0/2): the dynamic-body opt-in + its per-capability cross-field coherence. The schema
+        // already bounds the block's SHAPE (bodyType/shape dims/mass/restitution); here are the rules it can't express —
+        // incoherent combos fail at PUBLISH, not runtime. (mass/restitution/shape bounds: enforced by the JSON schema.)
+        if (physics) {
+            if (authority !== 'owner')
+                e.push(`multiplayer.entities.${kind}.physics: requires authority:'owner' (only an owner kind simulates a dynamic body — a server kind stays kinematic)`);
+            // claim-on-contact fires the auto-takeover verb, so the kind must permit a takeover; dual-sim is the
+            // controlled×controlled path, which by definition never transfers (sticky), so it needs the 'fixed' policy.
+            if (physics.claimOnContact && transferPolicy !== 'takeover')
+                e.push(`multiplayer.entities.${kind}.physics.claimOnContact: requires transferPolicy:'takeover' (the verb the auto-handoff fires); got '${transferPolicy}'`);
+            if (physics.dualSimOnContact && transferPolicy !== 'fixed')
+                e.push(`multiplayer.entities.${kind}.physics.dualSimOnContact: requires transferPolicy:'fixed' (a controlled body never transfers); got '${transferPolicy}'`);
+            for (const other of physics.collidesWith ?? []) {
+                if (!kinds.includes(other))
+                    e.push(`multiplayer.entities.${kind}.physics.collidesWith: references unknown entity kind "${other}"${didYouMean(other, kinds)} (declared entities: ${kinds.join(', ') || 'none'})`);
+            }
+        }
+        // rejoinOnRelease only means anything for the server-behaved HYBRID (physics + a non-static motion).
+        if (entities[kind].rejoinOnRelease !== undefined && !(physics && entities[kind].motion && entities[kind].motion.type !== 'static')) {
+            warnings.push(`multiplayer.entities.${kind}.rejoinOnRelease: ignored — it only applies to a server-behaved hybrid (a kind with both physics and a non-static motion)`);
+        }
+        // §6 (4.5.8) attached-zone tracks: 'entity:<kind>' (entity-vs-entity overlap) must name a declared kind;
+        // the carrier never detects itself at runtime. 'players' (default) is unconstrained.
+        const zone = entities[kind].zone;
+        const zoneTrackKind = zone && entityTrackKind(zone.tracks);
+        if (zoneTrackKind && !kinds.includes(zoneTrackKind)) {
+            e.push(`multiplayer.entities.${kind}.zone: tracks "${zone.tracks}" references unknown entity kind "${zoneTrackKind}"${didYouMean(zoneTrackKind, kinds)} (declared entities: ${kinds.join(', ') || 'none'})`);
+        }
+    }
+    return { errors: e, warnings };
+}
+// ── §5.2 (Phase 4.9) the accept + loud-no-op PUBLISH half (Phase-3 §6 Deferred #1) ───────────────────────
+// The closed v0.3 grammar would HARD-REJECT any unrecognized event/effect node. Instead a CURATED future node
+// (a reserved seam for a named later phase) publishes with a WARNING (the room already H3-skips it at runtime —
+// shipped 3.1), while a real TYPO still hard-ERRORS with did-you-mean. The pre-launch gate (validateManifest
+// `{strict:true}`) flips the future-node warnings → errors before any real publish. The schema's ruleEvent/
+// ruleEffect permissive branch lets an unknown node through to here; these sets MUST stay in sync with the
+// HelixRuleEvent/HelixRuleEffect unions + those schema `not` enums.
+const KNOWN_EVENTS = new Set(['tick', 'playerJoin', 'playerLeave', 'playerDisconnect', 'playerReconnect', 'zoneEnter', 'zoneExit', 'zoneInside', 'playerContact', 'action', 'stateEnter', 'stateExit', 'timerElapsed', 'entitySpawn', 'entityDestroy', 'ownershipChanged', 'varReached']);
+const KNOWN_EFFECTS = new Set(['add', 'set', 'setRef', 'teleport', 'respawn', 'forEachPlayer', 'forEachEntity', 'forEachInList', 'broadcast', 'transitionTo', 'startTimer', 'cancelTimer', 'spawnEntity', 'destroyEntity', 'requestOwnership', 'takeover', 'append', 'clear', 'addCount', 'removeAt', 'removeWhere', 'setField', 'advanceTurn', 'eliminate', 'revive']);
+// Reserved nodes for a named LATER phase (provisional names — the grammar lands with that phase). A node here
+// publishes with a warning + is a runtime no-op; any other unknown node is a typo (hard error with did-you-mean).
+// (4.5.12 promoted the ownership-transfer trio to KNOWN; this set is empty until the next reserved seam lands.)
+const FUTURE_EVENTS = {};
+const FUTURE_EFFECTS = {};
+// Classify one unrecognized node name: a reserved future node → a warning (or, in strict pre-launch mode, an
+// error); anything else → a hard error with did-you-mean against the known + reserved names.
+function classifyUnknownNode(path, kind, name, known, future, strict, out) {
+    if (known.has(name))
+        return;
+    const reserved = future[name];
+    if (reserved !== undefined) {
+        const msg = `${path}: "${name}" is a reserved ${kind} for ${reserved} — not interpreted yet; published worlds skip it at runtime (no-op)`;
+        if (strict)
+            out.errors.push(`${msg} [rejected: pre-launch strict mode]`);
+        else
+            out.warnings.push(msg);
+        return;
+    }
+    out.errors.push(`${path}: unknown ${kind} "${name}"${didYouMean(name, [...known, ...Object.keys(future)])} (known ${kind}s: ${[...known].join(', ')})`);
+}
+// §5.2 (Phase 4.9) scan every rule's event + effect (recursively into forEach*.then + joinPolicy.onLateJoin)
+// for an unrecognized node, classifying each. Returns {errors, warnings}; runs alongside checkRules (which skips
+// an unknown-event rule + treats an unknown effect verb as a no-op, deferring the verdict to here).
+function checkFutureNodes(m, strict) {
+    const out = { errors: [], warnings: [] };
+    const walkEffects = (path, effects) => {
+        (effects ?? []).forEach((eff, j) => {
+            const p = `${path}[${j}]`;
+            classifyUnknownNode(p, 'effect', eff.do, KNOWN_EFFECTS, FUTURE_EFFECTS, strict, out);
+            // (P1.A3) recurse into BOTH loop bodies — a typo'd verb inside forEachEntity (incl. nested in onLateJoin)
+            // otherwise bypasses the classifier and silently no-ops at runtime.
+            if (eff.do === 'forEachPlayer' || eff.do === 'forEachEntity')
+                walkEffects(`${p}.then`, eff.then);
+        });
+    };
+    (m.multiplayer?.rules ?? []).forEach((rule, i) => {
+        classifyUnknownNode(`multiplayer.rules[${i}].when`, 'event', rule.when.on, KNOWN_EVENTS, FUTURE_EVENTS, strict, out);
+        walkEffects(`multiplayer.rules[${i}].then`, rule.then);
+    });
+    for (const [phase, policy] of Object.entries(m.multiplayer?.states?.joinPolicy ?? {})) {
+        walkEffects(`multiplayer.states.joinPolicy.${phase}.onLateJoin`, policy.onLateJoin);
+    }
+    return out;
+}
+// §7 rules: cross-field-resolve each effect's references against the declared state. Phase-2.1 subset =
+// the `tick` event + the `add` effect; an `add` target must be a declared NUMBER var (room.<v>/self.<v>).
+// Later slices extend this (more events/effects/conditions, zones, the symbol table for bound names).
+function checkRules(m) {
+    const e = [];
+    const rules = m.multiplayer?.rules;
+    if (!rules)
+        return e;
+    if (rules.length > exports.MULTIPLAYER_CAPS.rules) {
+        e.push(`manifest: multiplayer.rules declares ${rules.length} rules — the cap is ${exports.MULTIPLAYER_CAPS.rules}`);
+    }
+    const roomVars = m.multiplayer?.state?.roomVars ?? {};
+    const playerVars = m.multiplayer?.state?.playerVars ?? {};
+    const zoneIds = new Set((m.multiplayer?.zones ?? []).map((z) => z.id));
+    const events = m.multiplayer?.events ?? {};
+    const actionNames = new Set(Object.keys(m.multiplayer?.actions ?? {}));
+    const phases = new Set(m.multiplayer?.states?.phases ?? []);
+    const timersDecl = m.multiplayer?.timers ?? {};
+    const ec = buildEntityCtx(m);
+    const entityKinds = ec.kinds;
+    // §9 entity kinds that declare an attached zone — a zone event naming one binds `source` + resolves here.
+    const entityZoneKinds = new Set(Object.entries(m.multiplayer?.entities ?? {}).filter(([, e]) => e.zone).map(([k]) => k));
+    const zoneSelfKinds = buildZoneSelfKinds(m); // §6 (4.5.8) zones tracking 'entity:<kind>' bind self = that kind
+    rules.forEach((rule, i) => {
+        // §5.2 (4.9) an unrecognized event is classified in checkFutureNodes (reserved future → warn; typo → error);
+        // skip this rule's deep validation here — its binding semantics are unknown, and the room H3-skips it anyway.
+        if (!KNOWN_EVENTS.has(rule.when.on))
+            return;
+        const bound = boundNames(rule.when, timersDecl, entityZoneKinds);
+        // §11.5 (4.7): inside an {on:action} rule, the matched action's arg-schema is in scope for `action.args.<arg>`
+        // reads (a per-rule shallow copy of the shared ctx; non-action rules use ec as-is, actionArgs undefined).
+        // §9 (4.5) thread the event's binding kinds (self/source/other → player|entity:<kind>, mirroring the firewall)
+        // so ref/self reads resolve against the specific kind's vars (row 16) + a keyed timer's key must match (row 15).
+        const boundKinds = firewallBindings(rule.when, timersDecl, entityZoneKinds, zoneSelfKinds);
+        const ruleEc = rule.when.on === 'action'
+            ? { ...ec, boundKinds, actionArgs: m.multiplayer?.actions?.[rule.when.name]?.args ?? {} }
+            : { ...ec, boundKinds };
+        if (rule.when.on === 'varReached') {
+            e.push(...checkVarReached(`multiplayer.rules[${i}].when`, rule.when, roomVars, playerVars, bound, zoneIds, ruleEc));
+        }
+        if (rule.when.on === 'zoneEnter' || rule.when.on === 'zoneExit' || rule.when.on === 'zoneInside') {
+            const zone = rule.when.zone;
+            const isStatic = zoneIds.has(zone);
+            const isEntity = entityZoneKinds.has(zone); // §9 an entity kind with an attached zone
+            if (isStatic && isEntity) {
+                e.push(`multiplayer.rules[${i}].when: "${zone}" is ambiguous — it is both a declared zone id and an entity kind with an attached zone; rename one`);
+            }
+            else if (!isStatic && !isEntity) {
+                const declared = [...zoneIds, ...entityZoneKinds];
+                e.push(`multiplayer.rules[${i}].when: references unknown zone "${zone}"${didYouMean(zone, declared)} (declared zones/entity-zones: ${declared.join(', ') || 'none'})`);
+            }
+        }
+        if (rule.when.on === 'action') {
+            const name = rule.when.name;
+            if (!actionNames.has(name)) {
+                const declared = [...actionNames];
+                e.push(`multiplayer.rules[${i}].when: references unknown action "${name}"${didYouMean(name, declared)} (declared actions: ${declared.join(', ') || 'none'})`);
+            }
+        }
+        if (rule.when.on === 'stateEnter' || rule.when.on === 'stateExit') {
+            const phase = rule.when.phase;
+            if (!phases.has(phase)) {
+                const declared = [...phases];
+                e.push(`multiplayer.rules[${i}].when: "${rule.when.on}" references unknown phase "${phase}"${didYouMean(phase, declared)} (declared phases: ${declared.join(', ') || 'none — add multiplayer.states'})`);
+            }
+        }
+        if (rule.when.on === 'entitySpawn' || rule.when.on === 'entityDestroy' || rule.when.on === 'ownershipChanged') {
+            const kind = rule.when.kind;
+            if (!entityKinds.has(kind)) {
+                const declared = [...entityKinds];
+                e.push(`multiplayer.rules[${i}].when: "${rule.when.on}" references unknown entity kind "${kind}"${didYouMean(kind, declared)} (declared entities: ${declared.join(', ') || 'none — add multiplayer.entities'})`);
+            }
+            else if (rule.when.on === 'ownershipChanged' && (m.multiplayer?.entities?.[kind]?.transferPolicy ?? 'fixed') === 'fixed') {
+                // §9 (4.5.12) ownershipChanged fires only on a voluntary transfer — a 'fixed' kind's ownership never moves that way.
+                e.push(`multiplayer.rules[${i}].when: ownershipChanged on "${kind}" never fires — that kind declares no transferPolicy (set transferPolicy:'request' or 'takeover')`);
+            }
+        }
+        // §8 timer resolution: every timerElapsed/startTimer/cancelTimer/timerRemaining names a declared timer;
+        // keyed-ness agreement (a keyed timer needs a player `key`, a room-scoped one takes none) + the key ref
+        // resolves + the startTimer 1-tick floor.
+        e.push(...checkTimerRefs(`multiplayer.rules[${i}]`, rule, timersDecl, bound, roomVars, playerVars, zoneIds, ruleEc));
+        if (rule.if !== undefined) {
+            const r = validateExpr(`multiplayer.rules[${i}].if`, rule.if, bound, roomVars, playerVars, zoneIds, ruleEc, 1);
+            e.push(...r.errors);
+            if (r.nodes > exports.MULTIPLAYER_CAPS.exprNodes) {
+                e.push(`multiplayer.rules[${i}].if has ${r.nodes} expression nodes — the cap is ${exports.MULTIPLAYER_CAPS.exprNodes}`);
+            }
+        }
+        if (rule.then.length > exports.MULTIPLAYER_CAPS.ruleThen) {
+            e.push(`multiplayer.rules[${i}].then has ${rule.then.length} effects — the cap is ${exports.MULTIPLAYER_CAPS.ruleThen}`);
+        }
+        // `spawned` (bound by a spawnEntity) is in scope for the REST of the then-list — thread an evolving bound set.
+        let running = bound;
+        rule.then.forEach((eff, j) => {
+            e.push(...checkEffect(`multiplayer.rules[${i}].then[${j}]`, eff, running, roomVars, playerVars, zoneIds, events, phases, ruleEc));
+            if (eff.do === 'spawnEntity' && eff.bind === 'spawned')
+                running = new Set([...running, 'spawned']);
+        });
+    });
+    return e;
+}
+// The reserved names an event binds + their static member type/kind (for the firewall's dataflow). Mirrors the
+// runtime binding (HelixRoom): zone-on-an-entity-kind binds `source`=that entity; entity events + entity-keyed
+// timers bind `self`=that entity; everything else player-bound. `spawned`/`as` are threaded in the then-walk.
+function firewallBindings(when, timers, entityZoneKinds, zoneSelfKinds) {
+    switch (when.on) {
+        case 'playerContact':
+            return { self: { type: 'player' }, other: { type: 'player' } };
+        case 'zoneEnter':
+        case 'zoneExit':
+        case 'zoneInside': {
+            // §6 (4.5.8) a zone tracking 'entity:<kind>' makes `self` that entity kind (else a player); this closes
+            // the firewall edge — `self`'s ref vars on an owner kind are now correctly tainted. An entity-ATTACHED
+            // zone (the name is an entity kind with a declared zone) also binds `source` = the carrying entity.
+            const selfKind = zoneSelfKinds.get(when.zone);
+            const b = { self: selfKind ? { type: 'entity', kind: selfKind } : { type: 'player' } };
+            if (entityZoneKinds.has(when.zone))
+                b.source = { type: 'entity', kind: when.zone };
+            return b;
+        }
+        case 'entitySpawn':
+        case 'entityDestroy':
+            return { self: { type: 'entity', kind: when.kind } };
+        case 'ownershipChanged':
+            // §9 (4.5.12) self = the new owner (a server-chosen player), source = the entity — both server-resolved, untainted.
+            return { self: { type: 'player' }, source: { type: 'entity', kind: when.kind } };
+        case 'timerElapsed': {
+            const keyed = timers[when.timer]?.keyed;
+            if (keyed === 'player')
+                return { self: { type: 'player' } };
+            if (typeof keyed === 'string' && keyed.startsWith('entity:'))
+                return { self: { type: 'entity', kind: keyed.slice('entity:'.length) } };
+            return {};
+        }
+        case 'varReached':
+            // §7.5 (P3-B5) room scope binds nothing; self binds the player; entity binds the watched kind's instance.
+            return when.scope === 'entity' ? { self: { type: 'entity', kind: when.kind ?? '' } } : when.scope === 'self' ? { self: { type: 'player' } } : {};
+        case 'tick':
+        case 'stateEnter':
+        case 'stateExit':
+            return {};
+        default: // playerJoin/Leave/Disconnect/Reconnect, action — all self=player (self-scoped)
+            return { self: { type: 'player' } };
+    }
+}
+// Walk every effect of every rule, threading the binding scope (forEachPlayer adds its `as`=player for its body;
+// a spawnEntity bind:'spawned' adds that entity for the rest of its then-list). visit gets (effect, bindings, path).
+function walkRuleEffects(rules, timers, entityZoneKinds, zoneSelfKinds, visit) {
+    const walk = (path, effects, bindings) => {
+        let b = bindings;
+        effects.forEach((eff, j) => {
+            const p = `${path}.then[${j}]`;
+            visit(eff, b, p);
+            if (eff.do === 'forEachPlayer')
+                walk(p, eff.then, { ...b, [eff.as]: { type: 'player' } });
+            if (eff.do === 'forEachEntity')
+                walk(p, eff.then, { ...b, [eff.as]: { type: 'entity', kind: eff.kind } });
+            if (eff.do === 'forEachInList')
+                walk(p, eff.then, { ...b, [eff.as]: { type: 'listElem' } }); // §5 (P3 ext) element type unresolved here → coarse (untainted) binding
+            if (eff.do === 'spawnEntity' && eff.bind === 'spawned')
+                b = { ...b, spawned: { type: 'entity', kind: eff.kind } };
+        });
+    };
+    rules.forEach((rule, i) => walk(`multiplayer.rules[${i}]`, rule.then, firewallBindings(rule.when, timers, entityZoneKinds, zoneSelfKinds)));
+}
+// Is this Ref's VALUE owner-tainted? A bound name (string) or a ref-op resolves to a server-chosen identity →
+// clean. A `{var:'scope.name'}` is a ref var used as a reference → tainted iff that var is in the taint set:
+// an owner entity's ref var (seeded), or a var transitively setRef'd from a tainted ref.
+function refTainted(ref, bindings, taint) {
+    if (ref === null || typeof ref !== 'object')
+        return false;
+    // §9 (P3) the controller of a tainted (client-uploaded) entity is itself tainted — propagate through controllerOf so
+    // it's caught in a {ref,var} read or a target sink. Other ref ops (nearestPlayer/leastLoadedPlayer/aggregate) are
+    // server reductions over server state → never client-tainted.
+    if ('op' in ref)
+        return ref.op === 'controllerOf' && refTainted(ref.entity, bindings, taint);
+    const path = ref.var;
+    const dot = path.indexOf('.');
+    if (dot < 0)
+        return false;
+    const scope = path.slice(0, dot);
+    const name = path.slice(dot + 1);
+    if (scope === 'room')
+        return taint.room.has(name);
+    const b = bindings[scope];
+    if (!b)
+        return false;
+    if (b.type !== 'player' && b.type !== 'entity')
+        return false; // §5 (P3 ext) a list-element binding — server-written, never client-tainted
+    return b.type === 'player' ? taint.player.has(name) : taint.entity.has(`${b.kind}.${name}`);
+}
+// Mark the var an lvalue writes as tainted (used when setRef stores a tainted ref into it). A {ref,var} lvalue
+// whose ref's member-kind is statically unclear over-taints (safe — the whitelist errs toward rejecting).
+function taintLvalue(target, bindings, taint, allKinds) {
+    const broad = (name) => { taint.player.add(name); for (const k of allKinds)
+        taint.entity.add(`${k}.${name}`); };
+    if (typeof target === 'string') {
+        const dot = target.indexOf('.');
+        const scope = target.slice(0, dot);
+        const name = target.slice(dot + 1);
+        if (scope === 'room') {
+            taint.room.add(name);
+            return;
+        }
+        const b = bindings[scope];
+        if (!b)
+            return;
+        if (b.type === 'player')
+            taint.player.add(name);
+        else if (b.type === 'entity')
+            taint.entity.add(`${b.kind}.${name}`); // a list-element binding is never a string-lvalue scope (self is player/entity)
+        return;
+    }
+    const r = target.ref;
+    if (typeof r === 'string') {
+        const b = bindings[r];
+        if (b?.type === 'player')
+            taint.player.add(target.var);
+        else if (b?.type === 'entity')
+            taint.entity.add(`${b.kind}.${target.var}`);
+        else
+            broad(target.var);
+    }
+    else {
+        broad(target.var);
+    }
+}
+// §9 (4.5, rows 12/13) visit every `{ref,var}` READ in an expression tree (conditions, effect values, broadcast
+// payloads). Dereferencing a client-uploaded (owner-tainted) ref to READ a member's var leaks cross-player state
+// (a payload read to "all" is the row-12 broadcast leak; a read into your own var is the row-13 leak). Recurses op
+// children (a/b/of/from); a bare `{var}` (no ref) is a same-member read, not a cross-member deref.
+function forEachRefRead(expr, visit) {
+    if (typeof expr !== 'object' || expr === null)
+        return;
+    if ('vec3' in expr)
+        return;
+    if ('ref' in expr) {
+        visit(expr.ref, expr.var);
+        return;
+    }
+    if ('var' in expr)
+        return;
+    const n = expr;
+    forEachRefRead(n.a, visit);
+    forEachRefRead(n.b, visit);
+    forEachRefRead(n.from, visit);
+    if (Array.isArray(n.of))
+        n.of.forEach((s) => forEachRefRead(s, visit));
+    else
+        forEachRefRead(n.of, visit);
+}
+function checkFirewall(m) {
+    const entities = m.multiplayer?.entities ?? {};
+    const ownerKinds = Object.keys(entities).filter((k) => (entities[k].authority ?? 'server') === 'owner');
+    if (ownerKinds.length === 0)
+        return []; // no client-authoritative surface → the firewall is inert
+    const rules = m.multiplayer?.rules ?? [];
+    if (rules.length === 0)
+        return [];
+    const timers = m.multiplayer?.timers ?? {};
+    const allKinds = Object.keys(entities);
+    const entityZoneKinds = new Set(Object.entries(entities).filter(([, e]) => e.zone).map(([k]) => k));
+    const zoneSelfKinds = buildZoneSelfKinds(m); // §6 (4.5.8) an entity-tracking zone binds self = an entity kind
+    // Seed: every ref var on an owner kind is directly client-uploaded → tainted. Then fixed-point through setRef.
+    const taint = { room: new Set(), player: new Set(), entity: new Set() };
+    for (const k of ownerKinds)
+        for (const [n, vt] of Object.entries(entities[k].vars ?? {}))
+            if (vt.type === 'ref')
+                taint.entity.add(`${k}.${n}`);
+    let size = -1;
+    while (taint.room.size + taint.player.size + taint.entity.size !== size) {
+        size = taint.room.size + taint.player.size + taint.entity.size;
+        walkRuleEffects(rules, timers, entityZoneKinds, zoneSelfKinds, (eff, b) => {
+            if (eff.do === 'setRef' && eff.to !== null && refTainted(eff.to, b, taint))
+                taintLvalue(eff.target, b, taint, allKinds);
+        });
+    }
+    // Sink pass: a tainted ref reaching any target-selecting WRITE/aim sink — or being DEREFERENCED to READ a
+    // member's var (rows 12/13) — fails publish.
+    const errors = [];
+    const why = "a client-uploaded owner-entity id can't aim a cross-player effect — route cross-player consequences through a server-validated 'action'";
+    const readWhy = "reading another member's var through a client-uploaded owner-entity ref leaks cross-player state — route cross-player reads through a server-validated 'action'";
+    const flagReads = (expr, b, path, where) => {
+        forEachRefRead(expr, (ref) => {
+            if (refTainted(ref, b, taint))
+                errors.push(`${path}: cross-player firewall — the ${where} dereferences owner-tainted "${ref.var}" to read a member's var; ${readWhy}`);
+        });
+    };
+    walkRuleEffects(rules, timers, entityZoneKinds, zoneSelfKinds, (eff, b, path) => {
+        const flag = (ref, sink) => {
+            if (refTainted(ref, b, taint))
+                errors.push(`${path}: cross-player firewall — the ${sink} dereferences owner-tainted "${ref.var}"; ${why}`);
+        };
+        switch (eff.do) {
+            case 'teleport':
+            case 'respawn':
+                flag(eff.player, `${eff.do} target`);
+                flagReads(eff.to, b, path, `${eff.do} position`); // row 13: a tainted-ref read in the target vec3
+                break;
+            case 'destroyEntity':
+                flag(eff.entity, 'destroyEntity target');
+                break;
+            case 'requestOwnership':
+            case 'takeover':
+                // §9 (4.5.12) both refs aim a cross-player consequence (who gets the entity) — a client-uploaded id can't.
+                flag(eff.entity, `${eff.do} entity`);
+                if (eff.to !== null)
+                    flag(eff.to, `${eff.do} to`);
+                break;
+            case 'append':
+                // §5 (P3) a ref-addressed target is a cross-member write — taint-flag it like add/set; the value's reads too.
+                if (typeof eff.target !== 'string')
+                    flag(eff.target.ref, 'append write-through-ref');
+                if (isRecordLiteral(eff.value))
+                    for (const v of Object.values(eff.value))
+                        flagReads(v, b, path, 'append value');
+                else
+                    flagReads(eff.value, b, path, 'append value');
+                break;
+            case 'clear':
+                if (typeof eff.target !== 'string')
+                    flag(eff.target.ref, 'clear write-through-ref'); // §5 (P3) cross-member write
+                break;
+            case 'addCount':
+                if (typeof eff.target !== 'string')
+                    flag(eff.target.ref, 'addCount write-through-ref'); // §5 (P3) cross-member write
+                flagReads(eff.by, b, path, 'addCount value'); // §5 (4.5.13) row-13 read-leak in the count delta
+                break;
+            case 'removeAt':
+                if (typeof eff.target !== 'string')
+                    flag(eff.target.ref, 'removeAt write-through-ref'); // §5 (P3) cross-member write
+                flagReads(eff.index, b, path, 'removeAt index');
+                break;
+            case 'setField':
+                if (eff.target !== undefined && typeof eff.target !== 'string')
+                    flag(eff.target.ref, 'setField write-through-ref'); // §5 (P3) cross-member write (index-form; the as-form has no target)
+                if (eff.index !== undefined)
+                    flagReads(eff.index, b, path, 'setField index');
+                flagReads(eff.to, b, path, 'setField value');
+                break;
+            case 'removeWhere':
+                if (typeof eff.target !== 'string')
+                    flag(eff.target.ref, 'removeWhere write-through-ref'); // §5 (P3 ext) cross-member write
+                flagReads(eff.where, { ...b, [eff.as]: { type: 'listElem' } }, path, 'removeWhere where'); // the element binding shadows an outer name + is untainted
+                break;
+            case 'startTimer':
+            case 'cancelTimer':
+                if (eff.key !== undefined)
+                    flag(eff.key, `${eff.do} key`);
+                break;
+            case 'add':
+                if (typeof eff.target !== 'string')
+                    flag(eff.target.ref, 'add write-through-ref');
+                flagReads(eff.by, b, path, 'add value'); // row 13
+                break;
+            case 'set':
+                if (typeof eff.target !== 'string')
+                    flag(eff.target.ref, 'set write-through-ref');
+                flagReads(eff.to, b, path, 'set value'); // row 13
+                break;
+            case 'setRef':
+                if (typeof eff.target !== 'string')
+                    flag(eff.target.ref, 'setRef write-through-ref');
+                break;
+            case 'forEachPlayer':
+                flagReads(eff.where, b, path, 'forEachPlayer where'); // row 13
+                break;
+            case 'forEachInList':
+                flagReads(eff.where, { ...b, [eff.as]: { type: 'listElem' } }, path, 'forEachInList where'); // row 13 (the element binding is untainted; the body is walked separately)
+                break;
+            case 'broadcast':
+                // Forward-defense: the schema's broadcast `to` accepts only a bound name / server reduction (refOp) /
+                // team filter — never a {var} ref-var deref — so a client-uploaded id can't reach the TARGET today. This
+                // clause stays correct if `to` ever widens. Row 12: a tainted-ref READ in a PAYLOAD field would leak
+                // cross-player state to the recipients — flagged below. (A server-provable `owner` binding to legitimately
+                // target the owner stays a usability follow-up; its absence is not a leak.)
+                if (eff.to !== 'all' && !(typeof eff.to === 'object' && 'team' in eff.to))
+                    flag(eff.to, 'broadcast `to`');
+                for (const [f, v] of Object.entries(eff.payload ?? {}))
+                    flagReads(v, b, `${path}.payload.${f}`, 'broadcast payload'); // row 12/13
+                break;
+        }
+    });
+    // Row 13: tainted-ref reads in a rule's `if` condition (evaluated at rule scope — no forEach `as`/spawned yet).
+    rules.forEach((rule, i) => {
+        if (rule.if !== undefined)
+            flagReads(rule.if, firewallBindings(rule.when, timers, entityZoneKinds, zoneSelfKinds), `multiplayer.rules[${i}].if`, 'condition');
+    });
+    return errors;
+}
+// Validate a varReached event (§7.5): the watched var must be a declared scalar in its scope (vec3/ref/collection
+// aren't comparable), ordering cmps need a number var, and the threshold (a literal, or a {var}/{ref,var} read —
+// P3-B5) must match the watched var's type. Entity scope (P3-B5) watches a declared `kind`'s var (binds self=entity).
+function checkVarReached(path, w, roomVars, playerVars, bound, zoneIds, ec) {
+    let vt;
+    let scopeLabel;
+    if (w.scope === 'entity') {
+        if (w.kind === undefined)
+            return [`${path}: varReached scope:"entity" requires "kind" (the entity kind to watch)`];
+        if (!ec.kinds.has(w.kind))
+            return [`${path}: varReached watches unknown entity kind "${w.kind}"${didYouMean(w.kind, [...ec.kinds])} (declared entities: ${[...ec.kinds].join(', ') || 'none'})`];
+        const kv = ec.kindVars[w.kind] ?? {};
+        vt = kv[w.var];
+        scopeLabel = `entity:${w.kind}`;
+        if (!vt)
+            return [`${path}: varReached watches unknown var "${w.var}" for entity kind "${w.kind}"${didYouMean(w.var, Object.keys(kv))} (declared: ${Object.keys(kv).join(', ') || 'none'})`];
+    }
+    else {
+        if (w.kind !== undefined)
+            return [`${path}: varReached "kind" is only valid with scope:"entity"`];
+        const decls = w.scope === 'room' ? roomVars : playerVars;
+        vt = decls[w.var];
+        scopeLabel = w.scope;
+        if (!vt) {
+            const declared = Object.keys(decls);
+            return [`${path}: varReached watches unknown ${w.scope} var "${w.var}"${didYouMean(w.var, declared)} (declared ${w.scope} vars: ${declared.join(', ') || 'none'})`];
+        }
+    }
+    if (vt.type === 'vec3' || vt.type === 'ref' || vt.type === 'list' || vt.type === 'counterMap') {
+        return [`${path}: varReached can't compare a "${vt.type}" var (${scopeLabel}.${w.var}) — use a number/string/boolean var`];
+    }
+    const e = [];
+    const ordering = w.cmp === '<' || w.cmp === '<=' || w.cmp === '>' || w.cmp === '>=';
+    if (ordering && vt.type !== 'number')
+        e.push(`${path}: cmp "${w.cmp}" needs a number var, but ${scopeLabel}.${w.var} is "${vt.type}"`);
+    if (typeof w.value === 'object' && w.value !== null) {
+        // P3-B5 a dynamic threshold ({var}/{ref,var}) — validate as an expr; its type must match the watched var.
+        const r = validateExpr(`${path}.value`, w.value, bound, roomVars, playerVars, zoneIds, ec, 1);
+        e.push(...r.errors);
+        if (r.type !== undefined && r.type !== vt.type)
+            e.push(`${path}: threshold value is "${r.type}" but ${scopeLabel}.${w.var} is "${vt.type}"`);
+    }
+    else if (typeof w.value !== vt.type) {
+        e.push(`${path}: value (${JSON.stringify(w.value)}) does not match ${scopeLabel}.${w.var} ("${vt.type}")`);
+    }
+    return e;
+}
+// Reserved binding/scope names a `forEachPlayer as:` (or future bind) may not shadow (§7.1).
+const RESERVED_REF_NAMES = new Set(['self', 'other', 'source', 'spawned', 'room']);
+// Validate one effect (§7.4) against the declared state + the event's bound names. forEachPlayer + teleport/
+// respawn have no target lvalue, so branch first; add/set need a writable scalar var (set requires a
+// type-compatible value); setRef needs a ref var + a Ref/null `to`. A target may be string or `{ref,var}`.
+function checkEffect(path, eff, bound, roomVars, playerVars, zoneIds, events, phases, ec) {
+    // §5.2 (4.9) an unrecognized verb is classified in checkFutureNodes (reserved future → warn; typo → error) —
+    // don't double-report or crash on its absent fields here; treat it as a no-op for the structural pass.
+    if (!KNOWN_EFFECTS.has(eff.do))
+        return [];
+    if (eff.do === 'forEachPlayer')
+        return checkForEach(path, eff, bound, roomVars, playerVars, zoneIds, events, phases, ec);
+    if (eff.do === 'forEachEntity')
+        return checkForEachEntity(path, eff, bound, roomVars, playerVars, zoneIds, events, phases, ec);
+    if (eff.do === 'forEachInList')
+        return checkForEachInList(path, eff, bound, roomVars, playerVars, zoneIds, events, phases, ec);
+    if (eff.do === 'broadcast')
+        return checkBroadcast(path, eff, bound, roomVars, playerVars, zoneIds, events, ec);
+    if (eff.do === 'spawnEntity') {
+        const e = [];
+        if (!ec.kinds.has(eff.kind)) {
+            const declared = [...ec.kinds];
+            e.push(`${path}: spawnEntity references unknown entity kind "${eff.kind}"${didYouMean(eff.kind, declared)} (declared entities: ${declared.join(', ') || 'none — add multiplayer.entities'})`);
+        }
+        const r = validateExpr(`${path}.at`, eff.at, bound, roomVars, playerVars, zoneIds, ec, 1);
+        e.push(...r.errors);
+        if (r.type !== undefined && r.type !== 'vec3')
+            e.push(`${path}.at: spawnEntity needs a vec3 position, got "${r.type}"`);
+        // §9 (4.6a) `vars` seeds the SPAWNED kind's declared vars — each value type-matches its var (a ref var
+        // takes a Ref, else an Expr of the var's type); an unknown var name is an error; omitted vars use defaults.
+        if (eff.vars !== undefined) {
+            const decls = ec.kindVars[eff.kind] ?? {};
+            for (const [name, val] of Object.entries(eff.vars)) {
+                const vt = decls[name];
+                if (!vt) {
+                    e.push(`${path}.vars: unknown var "${name}" for entity kind "${eff.kind}"${didYouMean(name, Object.keys(decls))} (declared vars: ${Object.keys(decls).join(', ') || 'none'})`);
+                    continue;
+                }
+                // §5 (P3 Collections) a collection entity var can't be seeded at spawn (it has no scalar literal — it starts
+                // empty/zeroed). Populate it with append/addCount in an entitySpawn rule (self = the new entity) instead.
+                if (vt.type === 'list' || vt.type === 'counterMap') {
+                    e.push(`${path}.vars.${name}: a "${vt.type}" collection can't be seeded at spawn — it starts empty; populate it via append/addCount in an {on:'entitySpawn'} rule`);
+                    continue;
+                }
+                if (vt.type === 'ref') {
+                    e.push(...resolveRefSlot(`${path}.vars.${name}`, val, bound, roomVars, playerVars, zoneIds, ec).errors);
+                }
+                else {
+                    const vr = validateExpr(`${path}.vars.${name}`, val, bound, roomVars, playerVars, zoneIds, ec, 1);
+                    e.push(...vr.errors);
+                    if (vr.type !== undefined && vr.type !== vt.type)
+                        e.push(`${path}.vars.${name}: a "${vr.type}" value doesn't match the declared "${vt.type}"`);
+                }
+            }
+        }
+        return e;
+    }
+    if (eff.do === 'destroyEntity')
+        return resolveRefSlot(`${path}.entity`, eff.entity, bound, roomVars, playerVars, zoneIds, ec).errors;
+    if (eff.do === 'requestOwnership' || eff.do === 'takeover') {
+        // §9 (4.5.12) entity Ref + a `to` player Ref (or null = release). Both are target sinks (firewall-checked).
+        const ent = resolveRefSlot(`${path}.entity`, eff.entity, bound, roomVars, playerVars, zoneIds, ec);
+        const e = [...ent.errors];
+        if (eff.to !== null)
+            e.push(...resolveRefSlot(`${path}.to`, eff.to, bound, roomVars, playerVars, zoneIds, ec).errors);
+        // When the target entity's kind is statically known, flag a verb its declared transferPolicy can never honor.
+        if (ent.kind?.type === 'entity' && ent.kind.kind) {
+            const policy = ec.kindPolicy[ent.kind.kind] ?? 'fixed';
+            const ok = eff.do === 'takeover' ? policy === 'takeover' : policy !== 'fixed';
+            if (!ok)
+                e.push(`${path}: "${eff.do}" can't transfer "${ent.kind.kind}" — its transferPolicy is "${policy}" (${eff.do === 'takeover' ? "needs 'takeover'" : "needs 'request' or 'takeover'"})`);
+        }
+        return e;
+    }
+    if (eff.do === 'transitionTo') {
+        if (phases.has(eff.phase))
+            return [];
+        const declared = [...phases];
+        return [`${path}: transitionTo references unknown phase "${eff.phase}"${didYouMean(eff.phase, declared)} (declared phases: ${declared.join(', ') || 'none — add multiplayer.states'})`];
+    }
+    if (eff.do === 'cancelTimer')
+        return []; // §8 timer effect — name validated in checkTimerRefs (no duration)
+    if (eff.do === 'startTimer') {
+        // §8 timer name + literal-floor live in checkTimerRefs; here we type-check the (possibly dynamic) `seconds`
+        // duration expr to number + cap its node count, exactly like add.by / set.to.
+        const r = validateExpr(`${path}.seconds`, eff.seconds, bound, roomVars, playerVars, zoneIds, ec, 1);
+        const e = [...r.errors];
+        if (r.type !== undefined && r.type !== 'number')
+            e.push(`${path}.seconds: startTimer needs a number duration, got "${r.type}"`);
+        if (r.nodes > exports.MULTIPLAYER_CAPS.exprNodes)
+            e.push(`${path}.seconds has ${r.nodes} expression nodes — the cap is ${exports.MULTIPLAYER_CAPS.exprNodes}`);
+        return e;
+    }
+    if (eff.do === 'teleport' || eff.do === 'respawn') {
+        const e = resolveRefSlot(`${path}.player`, eff.player, bound, roomVars, playerVars, zoneIds, ec).errors;
+        const r = validateExpr(`${path}.to`, eff.to, bound, roomVars, playerVars, zoneIds, ec, 1);
+        e.push(...r.errors);
+        if (r.type !== undefined && r.type !== 'vec3')
+            e.push(`${path}.to: "${eff.do}" needs a vec3 position, got "${r.type}"`);
+        return e;
+    }
+    if (eff.do === 'append') {
+        // §5 (4.5.13 + P3 Collections) append a value to a list var (string or {ref,var} target); the value must match
+        // the list's ELEMENT type (a scalar Expr, a ref, or a record literal).
+        const c = resolveCollectionLvalue(`${path}.target`, eff.target, bound, roomVars, playerVars, zoneIds, ec);
+        if (c.errors.length)
+            return c.errors;
+        if (c.vt.type !== 'list')
+            return [`${path}: "append" needs a list var, but ${lvalueLabel(eff.target)} is "${c.vt.type}"`];
+        return validateListElementValue(`${path}.value`, eff.value, c.vt.of, bound, roomVars, playerVars, zoneIds, ec);
+    }
+    if (eff.do === 'clear') {
+        // §5 (4.5.13) empty a list OR reset every counterMap key to 0.
+        const c = resolveCollectionLvalue(`${path}.target`, eff.target, bound, roomVars, playerVars, zoneIds, ec);
+        if (c.errors.length)
+            return c.errors;
+        if (c.vt.type !== 'list' && c.vt.type !== 'counterMap')
+            return [`${path}: "clear" needs a list or counterMap var, but ${lvalueLabel(eff.target)} is "${c.vt.type}"`];
+        return [];
+    }
+    if (eff.do === 'addCount') {
+        // §5 (4.5.13) add a number `by` to a counterMap's declared `key`.
+        const c = resolveCollectionLvalue(`${path}.target`, eff.target, bound, roomVars, playerVars, zoneIds, ec);
+        if (c.errors.length)
+            return c.errors;
+        const e = [];
+        if (c.vt.type !== 'counterMap')
+            e.push(`${path}: "addCount" needs a counterMap var, but ${lvalueLabel(eff.target)} is "${c.vt.type}"`);
+        else if (!c.vt.keys.includes(eff.key))
+            e.push(`${path}.key: "${eff.key}" is not a declared key of ${lvalueLabel(eff.target)}${didYouMean(eff.key, c.vt.keys)} (keys: ${c.vt.keys.join(', ')})`);
+        const r = validateExpr(`${path}.by`, eff.by, bound, roomVars, playerVars, zoneIds, ec, 1);
+        e.push(...r.errors);
+        if (r.type !== undefined && r.type !== 'number')
+            e.push(`${path}.by: "addCount" needs a number, got "${r.type}"`);
+        return e;
+    }
+    if (eff.do === 'removeAt') {
+        // §5 (P3) remove the element at `index` from a list (shift). The index is a number expr; out-of-range = no-op.
+        const c = resolveCollectionLvalue(`${path}.target`, eff.target, bound, roomVars, playerVars, zoneIds, ec);
+        if (c.errors.length)
+            return c.errors;
+        if (c.vt.type !== 'list')
+            return [`${path}: "removeAt" needs a list var, but ${lvalueLabel(eff.target)} is "${c.vt.type}"`];
+        const r = validateExpr(`${path}.index`, eff.index, bound, roomVars, playerVars, zoneIds, ec, 1);
+        const e = [...r.errors];
+        if (r.type !== undefined && r.type !== 'number')
+            e.push(`${path}.index: "removeAt" needs a number index, got "${r.type}"`);
+        return e;
+    }
+    if (eff.do === 'removeWhere')
+        return checkRemoveWhere(path, eff, bound, roomVars, playerVars, zoneIds, ec);
+    if (eff.do === 'setField') {
+        // §5 (P3) write a record element's `field`. AS-form: address a record element `as` bound by an enclosing
+        // forEachInList (no target/index). INDEX-form: address element `index` of the list `target`. A helper validates
+        // the `to` value matches the resolved record field `ft`.
+        const checkTo = (ft) => {
+            if (ft.type === 'ref')
+                return resolveRefSlot(`${path}.to`, eff.to, bound, roomVars, playerVars, zoneIds, ec).errors;
+            const vr = validateExpr(`${path}.to`, eff.to, bound, roomVars, playerVars, zoneIds, ec, 1);
+            const e = [...vr.errors];
+            if (vr.type !== undefined && vr.type !== ft.type)
+                e.push(`${path}.to: a "${vr.type}" doesn't match the record field "${eff.field}" ("${ft.type}")`);
+            return e;
+        };
+        if (eff.as !== undefined) {
+            const e = [];
+            if (eff.index !== undefined)
+                e.push(`${path}: "setField" can't take both "as" and "index" — "as" addresses the element forEachInList bound`);
+            const k = ec.boundKinds?.[eff.as];
+            if (!bound.has(eff.as) || k?.type !== 'listRecord')
+                return [...e, `${path}.as: "${eff.as}" is not a record element bound by an enclosing forEachInList`];
+            const ft = k.fields[eff.field];
+            if (!ft)
+                return [...e, `${path}.field: unknown record field "${eff.field}"${didYouMean(eff.field, Object.keys(k.fields))} (fields: ${Object.keys(k.fields).join(', ')})`];
+            return [...e, ...checkTo(ft)];
+        }
+        if (eff.target === undefined)
+            return [`${path}: "setField" needs a "target" (with an "index"), or an "as" bound by an enclosing forEachInList`];
+        const c = resolveCollectionLvalue(`${path}.target`, eff.target, bound, roomVars, playerVars, zoneIds, ec);
+        if (c.errors.length)
+            return c.errors;
+        if (c.vt.type !== 'list' || typeof c.vt.of !== 'object' || c.vt.of.type !== 'record') {
+            return [`${path}: "setField" needs a list of records, but ${lvalueLabel(eff.target)} is "${c.vt.type === 'list' ? `list of ${typeof c.vt.of === 'string' ? c.vt.of : c.vt.of.type}` : c.vt.type}"`];
+        }
+        if (eff.index === undefined)
+            return [`${path}: "setField" needs an "index" (or an "as" bound by forEachInList)`];
+        const e = [];
+        const r = validateExpr(`${path}.index`, eff.index, bound, roomVars, playerVars, zoneIds, ec, 1);
+        e.push(...r.errors);
+        if (r.type !== undefined && r.type !== 'number')
+            e.push(`${path}.index: "setField" needs a number index, got "${r.type}"`);
+        const ft = c.vt.of.fields[eff.field];
+        if (!ft)
+            e.push(`${path}.field: unknown record field "${eff.field}"${didYouMean(eff.field, Object.keys(c.vt.of.fields))} (fields: ${Object.keys(c.vt.of.fields).join(', ')})`);
+        else
+            e.push(...checkTo(ft));
+        return e;
+    }
+    if (eff.do === 'advanceTurn') {
+        // §7.4 (P3-B2) `order` must be a `list of ref:player`; `index` a writable number var.
+        const c = resolveCollectionLvalue(`${path}.order`, eff.order, bound, roomVars, playerVars, zoneIds, ec);
+        if (c.errors.length)
+            return c.errors;
+        const ofElem = c.vt.type === 'list' ? c.vt.of : undefined;
+        if (c.vt.type !== 'list' || typeof ofElem !== 'object' || ofElem.type !== 'ref' || ofElem.of !== 'player') {
+            return [`${path}.order: "advanceTurn" needs a list of player refs (got ${lvalueLabel(eff.order)})`];
+        }
+        const idx = resolveLvalue(`${path}.index`, eff.index, bound, roomVars, playerVars, zoneIds, ec);
+        const e = [...idx.errors];
+        if (idx.type !== undefined && idx.type !== 'number')
+            e.push(`${path}.index: "advanceTurn" needs a number var, but ${lvalueLabel(eff.index)} is "${idx.type}"`);
+        return e;
+    }
+    if (eff.do === 'eliminate' || eff.do === 'revive') {
+        // §7.4 (P3-B2) `player` is a Ref (firewall-checked); the room toggles its reserved `active` flag.
+        return resolveRefSlot(`${path}.player`, eff.player, bound, roomVars, playerVars, zoneIds, ec).errors;
+    }
+    // add | set | setRef — all have a target lvalue. (TS can't reliably narrow this recursive union past the
+    // early returns above, so assert the remaining subtype; `ve.do` still discriminates `to` within it.)
+    const ve = eff;
+    const target = resolveLvalue(`${path}.target`, ve.target, bound, roomVars, playerVars, zoneIds, ec);
+    const e = [...target.errors];
+    if (target.type === undefined)
+        return e; // target unresolved — don't pile on
+    const label = lvalueLabel(ve.target);
+    if (ve.do === 'add') {
+        if (target.type !== 'number')
+            e.push(`${path}: "do":"add" needs a number var, but ${label} is "${target.type}"`);
+        const r = validateExpr(`${path}.by`, ve.by, bound, roomVars, playerVars, zoneIds, ec, 1); // §7.4 `by` is a number expr (4.5)
+        e.push(...r.errors);
+        if (r.nodes > exports.MULTIPLAYER_CAPS.exprNodes)
+            e.push(`${path}.by has ${r.nodes} expression nodes — the cap is ${exports.MULTIPLAYER_CAPS.exprNodes}`);
+        if (r.type !== undefined && r.type !== 'number')
+            e.push(`${path}.by: "do":"add" needs a number, got "${r.type}"`);
+    }
+    else if (ve.do === 'set') {
+        if (target.type === 'ref')
+            e.push(`${path}: "do":"set" can't write a ref var — use "setRef" for ${label}`);
+        const r = validateExpr(`${path}.to`, ve.to, bound, roomVars, playerVars, zoneIds, ec, 1);
+        e.push(...r.errors);
+        if (r.nodes > exports.MULTIPLAYER_CAPS.exprNodes)
+            e.push(`${path}.to has ${r.nodes} expression nodes — the cap is ${exports.MULTIPLAYER_CAPS.exprNodes}`);
+        if (target.type !== 'ref' && r.type !== undefined && r.type !== target.type) {
+            e.push(`${path}.to: a "${r.type}" value can't be set into ${label} ("${target.type}")`);
+        }
+    }
+    else {
+        if (target.type !== 'ref')
+            e.push(`${path}: "do":"setRef" needs a ref var, but ${label} is "${target.type}"`);
+        if (ve.to !== null)
+            e.push(...resolveRefSlot(`${path}.to`, ve.to, bound, roomVars, playerVars, zoneIds, ec).errors);
+    }
+    return e;
+}
+// A human-readable label for an lvalue in an error message — "self.x" or `{ref:…,var:"team"}`.
+function lvalueLabel(lvalue) {
+    if (typeof lvalue === 'string')
+        return lvalue;
+    return `{ref:${typeof lvalue.ref === 'string' ? `"${lvalue.ref}"` : '…'},var:"${lvalue.var}"}`;
+}
+// Validate forEachPlayer (§7.4) — the one bounded loop: single level (no nested forEach), binds `as` (which
+// can't shadow a reserved name), an optional `where` filter, and nested effects. The `as` ref is in scope for
+// where + then. `aggregate`/`nearest*` are FORBIDDEN inside (an O(n²) scan-in-a-loop) — a publish error.
+function checkForEach(path, eff, bound, roomVars, playerVars, zoneIds, events, phases, ec) {
+    const e = [];
+    if (RESERVED_REF_NAMES.has(eff.as))
+        e.push(`${path}.as: "${eff.as}" is a reserved name`);
+    const inner = new Set([...bound, eff.as]);
+    if (eff.where !== undefined) {
+        e.push(...validateExpr(`${path}.where`, eff.where, inner, roomVars, playerVars, zoneIds, ec, 1).errors);
+        if (exprHasReduction(eff.where))
+            e.push(`${path}.where: aggregate/nearest* are forbidden inside forEachPlayer`);
+    }
+    if (eff.then.length > exports.MULTIPLAYER_CAPS.ruleThen)
+        e.push(`${path}.then has ${eff.then.length} effects — the cap is ${exports.MULTIPLAYER_CAPS.ruleThen}`);
+    let running = inner;
+    eff.then.forEach((sub, j) => {
+        if (sub.do === 'forEachPlayer' || sub.do === 'forEachEntity' || sub.do === 'forEachInList') {
+            e.push(`${path}.then[${j}]: ${sub.do} can't nest inside forEachPlayer (single level only)`);
+            return;
+        }
+        e.push(...checkEffect(`${path}.then[${j}]`, sub, running, roomVars, playerVars, zoneIds, events, phases, ec));
+        if (effectHasReduction(sub))
+            e.push(`${path}.then[${j}]: aggregate/nearest* are forbidden inside forEachPlayer`);
+        if (sub.do === 'spawnEntity' && sub.bind === 'spawned')
+            running = new Set([...running, 'spawned']);
+    });
+    return e;
+}
+// §7.4/§9 (4.5/4.3b) validate forEachEntity — the entity loop. Like forEachPlayer (single level, optional `where`,
+// reductions forbidden inside) but iterates a declared `kind` and binds `as` = an entity of that kind, threading
+// its kind into boundKinds so `{ref:as,var}` reads resolve per-kind (4.5.1). Bounded by the per-kind entity cap.
+function checkForEachEntity(path, eff, bound, roomVars, playerVars, zoneIds, events, phases, ec) {
+    const e = [];
+    if (!ec.kinds.has(eff.kind)) {
+        e.push(`${path}: forEachEntity references unknown entity kind "${eff.kind}"${didYouMean(eff.kind, [...ec.kinds])} (declared entities: ${[...ec.kinds].join(', ') || 'none — add multiplayer.entities'})`);
+    }
+    if (RESERVED_REF_NAMES.has(eff.as))
+        e.push(`${path}.as: "${eff.as}" is a reserved name`);
+    const inner = new Set([...bound, eff.as]);
+    const innerEc = { ...ec, boundKinds: { ...ec.boundKinds, [eff.as]: { type: 'entity', kind: eff.kind } } };
+    if (eff.where !== undefined) {
+        e.push(...validateExpr(`${path}.where`, eff.where, inner, roomVars, playerVars, zoneIds, innerEc, 1).errors);
+        if (exprHasReduction(eff.where))
+            e.push(`${path}.where: aggregate/nearest* are forbidden inside forEachEntity`);
+    }
+    if (eff.then.length > exports.MULTIPLAYER_CAPS.ruleThen)
+        e.push(`${path}.then has ${eff.then.length} effects — the cap is ${exports.MULTIPLAYER_CAPS.ruleThen}`);
+    let running = inner;
+    let runningEc = innerEc;
+    eff.then.forEach((sub, j) => {
+        if (sub.do === 'forEachPlayer' || sub.do === 'forEachEntity' || sub.do === 'forEachInList') {
+            e.push(`${path}.then[${j}]: ${sub.do} can't nest inside forEachEntity (single level only)`);
+            return;
+        }
+        e.push(...checkEffect(`${path}.then[${j}]`, sub, running, roomVars, playerVars, zoneIds, events, phases, runningEc));
+        if (effectHasReduction(sub))
+            e.push(`${path}.then[${j}]: aggregate/nearest* are forbidden inside forEachEntity`);
+        if (sub.do === 'spawnEntity' && sub.bind === 'spawned') {
+            running = new Set([...running, 'spawned']);
+            runningEc = { ...runningEc, boundKinds: { ...runningEc.boundKinds, spawned: { type: 'entity', kind: sub.kind } } };
+        }
+    });
+    return e;
+}
+// §5 (P3 ext) the static binding kind for a list element of type `elem` (the name a forEachInList / listCount /
+// listIndexOf scan binds). A ref element flows like the member it points at (player/entity); a record element
+// exposes its fields ({ref:as,var:field}); a scalar element is a bound value ({var:as}). undefined elem (the list
+// didn't resolve) → the coarse listElem so downstream errors are about the list, not a spurious binding mismatch.
+function elemBinding(elem) {
+    if (elem === undefined)
+        return { type: 'listElem' };
+    if (typeof elem === 'string')
+        return { type: 'listScalar', scalar: elem };
+    if (elem.type === 'ref')
+        return ofToKind(elem.of) ?? { type: 'listElem' };
+    return { type: 'listRecord', fields: elem.fields };
+}
+// §5 (P3 ext) two lvalues address the same collection (structural equality — a dotted path or a {ref,var}). Used to
+// forbid structurally mutating the very list a forEachInList iterates (the indices/elements would shift mid-scan).
+function sameLvalue(a, b) {
+    if (typeof a === 'string' || typeof b === 'string')
+        return a === b;
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+// §5 (P3 ext) does `sub` STRUCTURALLY mutate the list `list` (append/clear/removeAt/removeWhere on the same lvalue)?
+// A setField (record-field write, no length change) is allowed on the iterated list — it's the point of the loop.
+function mutatesIteratedList(sub, list) {
+    if (sub.do === 'append' || sub.do === 'clear' || sub.do === 'removeAt' || sub.do === 'removeWhere')
+        return sameLvalue(sub.target, list);
+    return false;
+}
+// §5 (P3 Collections ext) validate forEachInList — the bounded loop over a list's ELEMENTS (the §13 sublanguage
+// completion). Like forEachEntity (single level, optional `where`, reductions forbidden inside) but iterates a
+// collection lvalue and binds `as` to the element (its kind from elemBinding — scalar value / member Ref / record).
+// Can't structurally mutate the list it iterates (use removeWhere); the per-tick budget charges maxLen × body.
+function checkForEachInList(path, eff, bound, roomVars, playerVars, zoneIds, events, phases, ec) {
+    const e = [];
+    const c = resolveCollectionLvalue(`${path}.list`, eff.list, bound, roomVars, playerVars, zoneIds, ec);
+    if (c.errors.length)
+        e.push(...c.errors);
+    else if (c.vt.type !== 'list')
+        e.push(`${path}.list: forEachInList needs a list var, but ${lvalueLabel(eff.list)} is "${c.vt.type}"`);
+    if (RESERVED_REF_NAMES.has(eff.as))
+        e.push(`${path}.as: "${eff.as}" is a reserved name`);
+    const elem = c.vt?.type === 'list' ? c.vt.of : undefined;
+    const inner = new Set([...bound, eff.as]);
+    const innerEc = { ...ec, boundKinds: { ...ec.boundKinds, [eff.as]: elemBinding(elem) } };
+    if (eff.where !== undefined) {
+        e.push(...validateExpr(`${path}.where`, eff.where, inner, roomVars, playerVars, zoneIds, innerEc, 1).errors);
+        if (exprHasReduction(eff.where))
+            e.push(`${path}.where: aggregate/nearest* are forbidden inside forEachInList`);
+    }
+    if (eff.then.length > exports.MULTIPLAYER_CAPS.ruleThen)
+        e.push(`${path}.then has ${eff.then.length} effects — the cap is ${exports.MULTIPLAYER_CAPS.ruleThen}`);
+    let running = inner;
+    let runningEc = innerEc;
+    eff.then.forEach((sub, j) => {
+        if (sub.do === 'forEachPlayer' || sub.do === 'forEachEntity' || sub.do === 'forEachInList') {
+            e.push(`${path}.then[${j}]: ${sub.do} can't nest inside forEachInList (single level only)`);
+            return;
+        }
+        if (mutatesIteratedList(sub, eff.list))
+            e.push(`${path}.then[${j}]: "${sub.do}" can't mutate the list forEachInList is iterating — use removeWhere to scan-and-remove, or setField to edit an element in place`);
+        e.push(...checkEffect(`${path}.then[${j}]`, sub, running, roomVars, playerVars, zoneIds, events, phases, runningEc));
+        if (effectHasReduction(sub))
+            e.push(`${path}.then[${j}]: aggregate/nearest* are forbidden inside forEachInList`);
+        if (sub.do === 'spawnEntity' && sub.bind === 'spawned') {
+            running = new Set([...running, 'spawned']);
+            runningEc = { ...runningEc, boundKinds: { ...runningEc.boundKinds, spawned: { type: 'entity', kind: sub.kind } } };
+        }
+    });
+    return e;
+}
+// §5 (P3 Collections ext) validate removeWhere — drop ALL elements of a list matching `where` (a bounded scan that
+// binds `as` to the element, exactly like forEachInList's binding). No nested effects; the `where` is read-only and
+// can't contain a reduction (O(maxLen) scan already). Used to scan-and-remove (cull broken/dead elements).
+function checkRemoveWhere(path, eff, bound, roomVars, playerVars, zoneIds, ec) {
+    const e = [];
+    const c = resolveCollectionLvalue(`${path}.target`, eff.target, bound, roomVars, playerVars, zoneIds, ec);
+    if (c.errors.length)
+        e.push(...c.errors);
+    else if (c.vt.type !== 'list')
+        e.push(`${path}.target: "removeWhere" needs a list var, but ${lvalueLabel(eff.target)} is "${c.vt.type}"`);
+    if (RESERVED_REF_NAMES.has(eff.as))
+        e.push(`${path}.as: "${eff.as}" is a reserved name`);
+    const elem = c.vt?.type === 'list' ? c.vt.of : undefined;
+    const inner = new Set([...bound, eff.as]);
+    const innerEc = { ...ec, boundKinds: { ...ec.boundKinds, [eff.as]: elemBinding(elem) } };
+    e.push(...validateExpr(`${path}.where`, eff.where, inner, roomVars, playerVars, zoneIds, innerEc, 1).errors);
+    if (exprHasReduction(eff.where))
+        e.push(`${path}.where: aggregate/nearest* are forbidden inside removeWhere`);
+    return e;
+}
+// Does an expression contain an aggregate / a ref-returning op (nearestPlayer / aggregate argmax|argmin)? The
+// reductions, which are O(members) scans and so forbidden inside forEachPlayer (would be O(members²)).
+function exprHasReduction(expr) {
+    if (typeof expr !== 'object' || expr === null || 'vec3' in expr)
+        return false;
+    if ('ref' in expr)
+        return refHasReduction(expr.ref);
+    if ('var' in expr)
+        return false;
+    const node = expr;
+    if (node.op === 'aggregate' || node.op === 'nearestPlayer')
+        return true;
+    if (node.op === 'and' || node.op === 'or')
+        return node.of.some(exprHasReduction);
+    if (node.op === 'not')
+        return exprHasReduction(node.of);
+    if (node.op === 'controlledBy') {
+        const cb = node;
+        return refHasReduction(cb.entity) || refHasReduction(cb.by);
+    } // §9 (P3) O(1) itself — only its refs can reduce
+    if (node.op === 'sameRef') {
+        const sr = node;
+        return refHasReduction(sr.a) || refHasReduction(sr.b);
+    } // §7.3 (P3-B2) O(1) itself — only its refs can reduce
+    if (node.op === 'hostLoad')
+        return true; // §9 (P3) O(entities) scan — a reduction, forbidden inside forEach
+    if (node.a !== undefined)
+        return exprHasReduction(node.a) || exprHasReduction(node.b);
+    return false;
+}
+function refHasReduction(ref) {
+    if (typeof ref === 'string' || !('op' in ref))
+        return false; // a bound name / {var} deref — O(1)
+    if (ref.op === 'controllerOf')
+        return refHasReduction(ref.entity); // §9 (P3) O(1) field read — only a reducing inner entity ref counts
+    if (ref.op === 'listAt')
+        return exprHasReduction(ref.index); // §5 (P3-B2) O(1) element read — only a reducing index expr counts
+    return true; // nearestPlayer / nearestEntity / aggregate argmax|argmin / leastLoadedPlayer — O(members) scans
+}
+// Validate a `broadcast` effect (§7.4/§10.3): the event must be declared; `to` must be a valid target; the
+// payload must exactly match the event's declared fields (no unknown, none missing), each value a Ref for a
+// ref field or a type-matching Expr otherwise.
+function checkBroadcast(path, eff, bound, roomVars, playerVars, zoneIds, events, ec) {
+    const decl = events[eff.event];
+    if (!decl) {
+        const names = Object.keys(events);
+        return [`${path}.event: unknown event "${eff.event}"${didYouMean(eff.event, names)} (declared events: ${names.join(', ') || 'none'})`];
+    }
+    const e = checkBroadcastTarget(`${path}.to`, eff.to, bound, roomVars, playerVars, zoneIds, ec);
+    const fields = decl.payload ?? {};
+    const provided = eff.payload ?? {};
+    for (const k of Object.keys(provided)) {
+        if (!(k in fields))
+            e.push(`${path}.payload: unknown field "${k}" (event "${eff.event}" declares: ${Object.keys(fields).join(', ') || 'none'})`);
+    }
+    for (const [field, ft] of Object.entries(fields)) {
+        if (!(field in provided)) {
+            e.push(`${path}.payload: missing field "${field}" (declared "${ft.type}")`);
+            continue;
+        }
+        const val = provided[field];
+        if (ft.type === 'ref') {
+            e.push(...resolveRefSlot(`${path}.payload.${field}`, val, bound, roomVars, playerVars, zoneIds, ec).errors);
+        }
+        else if (ft.type === 'list' || ft.type === 'counterMap') {
+            // §10.3 (P3-B6) a collection-snapshot field: the value must reference a collection var of the matching shape.
+            e.push(...checkCollectionPayload(`${path}.payload.${field}`, ft, val, bound, roomVars, playerVars, ec));
+        }
+        else {
+            const r = validateExpr(`${path}.payload.${field}`, val, bound, roomVars, playerVars, zoneIds, ec, 1);
+            e.push(...r.errors);
+            if (r.type !== undefined && r.type !== ft.type)
+                e.push(`${path}.payload.${field}: a "${r.type}" value doesn't match the declared "${ft.type}"`);
+        }
+    }
+    return e;
+}
+// §10.3 (P3-B6) validate a collection-snapshot payload field's value: a `{var:"room/self.<coll>"}` reference to a
+// declared collection var whose type + shape (element / keys) equals the field's. The room serializes that live
+// collection into the broadcast. (A literal collection value isn't expressible — a snapshot is always of a var.)
+function checkCollectionPayload(path, ft, val, bound, roomVars, playerVars, ec) {
+    if (typeof val !== 'object' || val === null || !('var' in val) || typeof val.var !== 'string') {
+        return [`${path}: a "${ft.type}" payload field must reference a collection var ({ "var": "room.<v>" | "self.<v>" }) to snapshot`];
+    }
+    const c = resolveCollectionVar(path, val.var, bound, roomVars, playerVars, ec);
+    if (c.errors.length)
+        return c.errors;
+    if (c.vt.type !== ft.type)
+        return [`${path}: field is a "${ft.type}" but "${val.var}" is a "${c.vt.type}"`];
+    if (ft.type === 'list' && c.vt.type === 'list' && JSON.stringify(c.vt.of) !== JSON.stringify(ft.of)) {
+        return [`${path}: the referenced list's element type doesn't match the declared payload field element`];
+    }
+    if (ft.type === 'counterMap' && c.vt.type === 'counterMap' && JSON.stringify([...c.vt.keys].sort()) !== JSON.stringify([...ft.keys].sort())) {
+        return [`${path}: the referenced counterMap's keys don't match the declared payload field keys`];
+    }
+    return [];
+}
+// Validate a broadcast `to` target: "all", a Ref (bound name / ref-var / ref-op), or {team:"<playerVar>=<val>"}.
+function checkBroadcastTarget(path, to, bound, roomVars, playerVars, zoneIds, ec) {
+    if (to === 'all')
+        return [];
+    if (typeof to === 'string' || 'var' in to || 'op' in to)
+        return resolveRefSlot(path, to, bound, roomVars, playerVars, zoneIds, ec).errors;
+    // { team: "<playerVar>=<value>" }
+    const eq = to.team.indexOf('=');
+    if (eq < 1)
+        return [`${path}.team: must be "<playerVar>=<value>", got "${to.team}"`];
+    const v = to.team.slice(0, eq);
+    if (!playerVars[v])
+        return [`${path}.team: unknown player var "${v}"${didYouMean(v, Object.keys(playerVars))} (declared player vars: ${Object.keys(playerVars).join(', ') || 'none'})`];
+    return [];
+}
+function effectHasReduction(eff) {
+    switch (eff.do) {
+        case 'add':
+            return (typeof eff.target !== 'string' && refHasReduction(eff.target.ref)) || exprHasReduction(eff.by);
+        case 'set':
+            return (typeof eff.target !== 'string' && refHasReduction(eff.target.ref)) || exprHasReduction(eff.to);
+        case 'setRef':
+            return (typeof eff.target !== 'string' && refHasReduction(eff.target.ref)) || (eff.to !== null && refHasReduction(eff.to));
+        case 'teleport':
+        case 'respawn':
+            return refHasReduction(eff.player) || exprHasReduction(eff.to);
+        case 'broadcast':
+            return (typeof eff.to !== 'string' && 'op' in eff.to && refHasReduction(eff.to)) || Object.values(eff.payload ?? {}).some((v) => exprHasReduction(v));
+        case 'spawnEntity':
+            return exprHasReduction(eff.at) || Object.values(eff.vars ?? {}).some((v) => exprHasReduction(v));
+        case 'destroyEntity':
+            return refHasReduction(eff.entity);
+        case 'eliminate':
+        case 'revive':
+            return refHasReduction(eff.player); // §7.4 (P3-B2) only a reducing player ref counts
+        default:
+            return false;
+    }
+}
+// The reserved names an event binds, resolvable as `self`/refs in the rule (spec §7.1). Phase-2.2: `tick` is
+// room-level and binds nothing; player-bound events (playerJoin/…) add `self` in a later slice. `room`/
+// `room.*` are always readable (built-ins, not bindings).
+function boundNames(event, timers, entityZoneKinds) {
+    switch (event.on) {
+        case 'playerJoin':
+        case 'playerLeave':
+        case 'playerDisconnect':
+        case 'playerReconnect':
+            return new Set(['self']); // the joining/leaving/dropping/resuming player
+        case 'zoneEnter':
+        case 'zoneExit':
+        case 'zoneInside':
+            // §6 the entering member is `self`; §9 an entity-ATTACHED zone (the name is an entity kind, not a static
+            // zone id) ALSO binds `source` = the carrying entity.
+            return entityZoneKinds.has(event.zone) ? new Set(['self', 'source']) : new Set(['self']);
+        case 'playerContact':
+            return new Set(['self', 'other']); // the two players in contact (tag/infection)
+        case 'action':
+            return new Set(['self']); // the player who sent the action
+        case 'varReached':
+            return event.scope === 'room' ? new Set() : new Set(['self']); // self/entity scope binds the watched instance (player/entity); room binds nothing
+        case 'stateEnter':
+        case 'stateExit':
+            return new Set(); // §8 room-scoped phase machine — no member bound
+        case 'timerElapsed':
+            return timers[event.timer]?.keyed ? new Set(['self']) : new Set(); // §8/§9 a keyed timer binds the instance (player or entity); room-scoped binds nothing
+        case 'entitySpawn':
+        case 'entityDestroy':
+            return new Set(['self']); // §9 the spawned/destroyed entity is `self`
+        case 'ownershipChanged':
+            return new Set(['self', 'source']); // §9 (4.5.12) self = the new owner (player), source = the entity
+        case 'tick':
+        default:
+            return new Set(); // room-level — no member bound
+    }
+}
+// Player built-in reads (§7.1) addressable as `self.<name>` or `{ref,var}` — NOT declared vars, can't be
+// shadowed. Phase-2.4a exposes `position` (vec3); Phase-3 presence adds `connected` (boolean, read-only).
+const PLAYER_BUILTIN_TYPES = { position: 'vec3', connected: 'boolean', active: 'boolean' };
+// `connected`/`active` are PLAYER-only presence/participation built-ins — an ENTITY member's same-named DECLARED var
+// wins (entities have no connection/participation). `position` is universal (players + entities both have a transform).
+const PLAYER_ONLY_BUILTINS = new Set(['connected', 'active']);
+const playerBuiltin = (name, isEntity) => name in PLAYER_BUILTIN_TYPES && !(isEntity && PLAYER_ONLY_BUILTINS.has(name));
+// Room built-in reads addressable as `room.<name>` — NOT declared roomVars. Phase-3 (§8) exposes `phase` (the
+// current state-machine phase, a string); it is read-only here (change it via transitionTo, not `set`).
+const ROOM_BUILTIN_TYPES = { phase: 'string' };
+const EMPTY_ENTITY_CTX = { kinds: new Set(), varTypes: {}, kindVars: {}, kindPolicy: {}, zoneSelfKinds: new Map() };
+function buildEntityCtx(m) {
+    const entities = m.multiplayer?.entities ?? {};
+    const varTypes = {};
+    const kindVars = {};
+    const kindPolicy = {};
+    for (const [kind, ent] of Object.entries(entities)) {
+        kindVars[kind] = ent.vars ?? {};
+        kindPolicy[kind] = ent.transferPolicy ?? 'fixed';
+        for (const [name, vt] of Object.entries(ent.vars ?? {}))
+            varTypes[name] = vt.type;
+    }
+    return { kinds: new Set(Object.keys(entities)), varTypes, kindVars, kindPolicy, zoneSelfKinds: buildZoneSelfKinds(m) };
+}
+// The member kind an aggregate scope reduces over: `entities:<kind>` → that kind; a `zone:<id>` tracking
+// 'entity:<kind>' (4.5.8) → that kind; `players` or a player-tracking zone → player.
+function aggregateMemberKind(scope, ec) {
+    if (scope.startsWith('entities:'))
+        return { type: 'entity', kind: scope.slice('entities:'.length) };
+    if (scope.startsWith('zone:')) {
+        const tracked = ec.zoneSelfKinds.get(scope.slice('zone:'.length));
+        if (tracked)
+            return { type: 'entity', kind: tracked };
+    }
+    return { type: 'player' };
+}
+// Recursively validate a condition/value expression (§7.3): depth cap + var/ref resolution + value-type
+// inference; returns errors + node count (the caller checks the total against exprNodes) + the inferred type.
+// `bound` = the reserved refs the event provides (§7.1), needed to resolve `self.*` and `{ref,var}` reads.
+function validateExpr(path, expr, bound, roomVars, playerVars, zoneIds, ec, depth) {
+    if (depth > exports.MULTIPLAYER_CAPS.exprDepth) {
+        return { errors: [`${path}: expression nesting exceeds the depth cap of ${exports.MULTIPLAYER_CAPS.exprDepth}`], nodes: 1 };
+    }
+    if (typeof expr === 'number')
+        return { errors: [], nodes: 1, type: 'number' };
+    if (typeof expr === 'string')
+        return { errors: [], nodes: 1, type: 'string' };
+    if (typeof expr === 'boolean')
+        return { errors: [], nodes: 1, type: 'boolean' };
+    if ('vec3' in expr)
+        return { errors: [], nodes: 1, type: 'vec3' };
+    if ('ref' in expr)
+        return { ...resolveRefRead(path, expr.ref, expr.var, bound, roomVars, playerVars, zoneIds, ec), nodes: 1 };
+    if ('var' in expr)
+        return { ...resolveVarRead(path, expr.var, bound, roomVars, playerVars, ec), nodes: 1 };
+    // op node — the schema already validated its shape, so read children via a generic view (TS can't reliably
+    // narrow this recursive union past the `op` discriminant). Gather labelled child sub-expressions:
+    const node = expr;
+    if (node.op === 'playerCount' || node.op === 'random' || node.op === 'timeInState' || node.op === 'timerRemaining' || node.op === 'now')
+        return { errors: [], nodes: 1, type: 'number' }; // leaf ops (timer-name refs resolved in checkTimerRefs)
+    if (node.op === 'randomPoint')
+        return { errors: [], nodes: 1, type: 'vec3' }; // leaf → a random vec3 in the [min,max] box (shape schema-validated)
+    if (node.op === 'aggregate')
+        return { errors: validateAggregate(path, node, bound, roomVars, playerVars, zoneIds, ec), nodes: 1, type: 'number' };
+    if (node.op === 'listLength' || node.op === 'listAt' || node.op === 'count' || node.op === 'listCount' || node.op === 'listIndexOf')
+        return validateCollectionOp(path, expr, bound, roomVars, playerVars, zoneIds, ec, depth); // §5 (4.5.13 + P3 ext) collection reads
+    if (node.op === 'controlledBy') {
+        // §9 (P3 Ownership/A3) boolean: is `entity` controlled by the player `by` resolves to? Both are ref slots.
+        const cb = expr;
+        const e = [
+            ...resolveRefSlot(`${path}.entity`, cb.entity, bound, roomVars, playerVars, zoneIds, ec).errors,
+            ...resolveRefSlot(`${path}.by`, cb.by, bound, roomVars, playerVars, zoneIds, ec).errors,
+        ];
+        return { errors: e, nodes: 1, type: 'boolean' };
+    }
+    if (node.op === 'sameRef') {
+        // §7.3 (P3-B2) boolean: do two Refs resolve to the same live member? Both are ref slots (O(1) identity test).
+        const sr = expr;
+        const e = [
+            ...resolveRefSlot(`${path}.a`, sr.a, bound, roomVars, playerVars, zoneIds, ec).errors,
+            ...resolveRefSlot(`${path}.b`, sr.b, bound, roomVars, playerVars, zoneIds, ec).errors,
+        ];
+        return { errors: e, nodes: 1, type: 'boolean' };
+    }
+    if (node.op === 'hostLoad') {
+        // §9 (P3 Ownership/B8) the count of live entities the player `of` controls → number. O(entities) scan.
+        const hl = expr;
+        return { errors: resolveRefSlot(`${path}.of`, hl.of, bound, roomVars, playerVars, zoneIds, ec).errors, nodes: 1, type: 'number' };
+    }
+    let children;
+    if (node.op === 'not')
+        children = [[`${path}.of`, node.of]];
+    else if (node.op === 'and' || node.op === 'or')
+        children = node.of.map((s, i) => [`${path}.of[${i}]`, s]);
+    else
+        children = [[`${path}.a`, node.a], [`${path}.b`, node.b]]; // distance / binary cmp / arith
+    const e = [];
+    let nodes = 1;
+    const childTypes = [];
+    for (const [childPath, sub] of children) {
+        const r = validateExpr(childPath, sub, bound, roomVars, playerVars, zoneIds, ec, depth + 1);
+        e.push(...r.errors);
+        nodes += r.nodes;
+        childTypes.push(r.type);
+    }
+    // distance: both operands must be vec3 → number. cmp/logic → boolean. arithmetic → number.
+    if (node.op === 'distance') {
+        childTypes.forEach((t, idx) => {
+            if (t !== undefined && t !== 'vec3')
+                e.push(`${path}.${idx === 0 ? 'a' : 'b'}: "distance" needs a vec3 operand, got "${t}"`);
+        });
+        return { errors: e, nodes, type: 'number' };
+    }
+    // (P1.A2) operand-type checks the runtime can't recover from. Ordering/arithmetic coerce via Number(), so a
+    // non-number operand (vec3 / string / boolean / ref) is NaN → always-false / NaN-poisoned. Equality is strict
+    // (===), so a vec3 compares by reference (always false) and a type mismatch is always false. Refs ARE comparable
+    // (they hold a member-key string). Only flag statically-known types — undefined = a dynamic read, left to runtime.
+    const ordering = node.op === '<' || node.op === '<=' || node.op === '>' || node.op === '>=';
+    const arithmetic = node.op === '+' || node.op === '-' || node.op === '*' || node.op === '/';
+    if (ordering || arithmetic) {
+        childTypes.forEach((t, idx) => {
+            if (t !== undefined && t !== 'number')
+                e.push(`${path}.${idx === 0 ? 'a' : 'b'}: "${node.op}" needs a number operand, got "${t}"`);
+        });
+    }
+    else if (node.op === '==' || node.op === '!=') {
+        const [ta, tb] = childTypes;
+        if (ta === 'vec3' || tb === 'vec3')
+            e.push(`${path}: "${node.op}" can't compare vec3 operands (use "distance" for proximity)`);
+        else if (ta !== undefined && tb !== undefined && ta !== tb)
+            e.push(`${path}: "${node.op}" compares mismatched types "${ta}" and "${tb}" — always ${node.op === '==' ? 'false' : 'true'}`);
+    }
+    const logical = node.op === 'and' || node.op === 'or' || node.op === 'not';
+    const comparison = node.op === '==' || node.op === '!=' || ordering;
+    return { errors: e, nodes, type: logical || comparison ? 'boolean' : 'number' };
+}
+// Validate an `aggregate` reduction (§7.3, Phase-2.4b): a scalar (count/sum/min/max/avg → number) over
+// `players` or a declared zone's members. count takes no field; the other aggs need a number `field` (the
+// iterated player's var). scope is shape-checked by the schema; here we resolve the zone id + the field.
+function validateAggregate(path, node, bound, roomVars, playerVars, zoneIds, ec) {
+    const e = [];
+    const scope = node.scope ?? '';
+    const entityScope = scope.startsWith('entities:'); // §9 reduce over entities of a kind (Phase 4.3)
+    const memberKind = aggregateMemberKind(scope, ec); // (4.5.8) a zone tracking 'entity:<kind>' reduces over entities, not players
+    const entityDomain = memberKind.type === 'entity';
+    if (scope.startsWith('zone:')) {
+        const id = scope.slice('zone:'.length);
+        if (!zoneIds.has(id)) {
+            const declared = [...zoneIds];
+            e.push(`${path}: aggregate scope references unknown zone "${id}"${didYouMean(id, declared)} (declared zones: ${declared.join(', ') || 'none'})`);
+        }
+    }
+    else if (entityScope) {
+        const kind = scope.slice('entities:'.length);
+        if (!ec.kinds.has(kind)) {
+            const declared = [...ec.kinds];
+            e.push(`${path}: aggregate scope references unknown entity kind "${kind}"${didYouMean(kind, declared)} (declared entities: ${declared.join(', ') || 'none'})`);
+        }
+    }
+    // §7.3 (4.5) optional `where` filter — needs `as` (a name for each candidate member); validate `where` with `as`
+    // bound to the scope's member kind (players/zone → player; entities:<kind> → that entity). Applies to every agg
+    // (count included). A reduction inside would be O(members²) — forbidden, like a forEach body.
+    if (node.where !== undefined || node.as !== undefined) {
+        if (node.as === undefined)
+            e.push(`${path}: aggregate "where" requires "as" (a name for each candidate member)`);
+        else if (RESERVED_REF_NAMES.has(node.as))
+            e.push(`${path}.as: "${node.as}" is a reserved name`);
+        else if (node.where === undefined)
+            e.push(`${path}: aggregate "as" requires a "where" filter`);
+        else {
+            const inner = new Set([...bound, node.as]);
+            const innerEc = { ...ec, boundKinds: { ...ec.boundKinds, [node.as]: memberKind } };
+            e.push(...validateExpr(`${path}.where`, node.where, inner, roomVars, playerVars, zoneIds, innerEc, 1).errors);
+            if (exprHasReduction(node.where))
+                e.push(`${path}.where: aggregate/nearest* are forbidden inside an aggregate "where"`);
+        }
+    }
+    if (node.agg === 'count') {
+        if (node.field !== undefined)
+            e.push(`${path}: aggregate "count" takes no field`);
+        return e;
+    }
+    if (node.field === undefined) {
+        e.push(`${path}: aggregate "${node.agg}" needs a "field" (a number ${entityDomain ? 'entity' : 'player'} var)`);
+        return e;
+    }
+    // The field is a number var of the reduced collection. (P3-B4) For an entity domain (entities:<kind> or a zone
+    // tracking 'entity:<kind>') resolve `field` against the SPECIFIC tracked kind's vars, not the entity-var union — a
+    // field absent on that kind is a publish error, not a silent runtime 0. Player domain → player vars.
+    const kindVars = entityDomain && memberKind.kind !== undefined ? (ec.kindVars[memberKind.kind] ?? {}) : undefined;
+    const fieldType = entityDomain ? (kindVars ? kindVars[node.field]?.type : ec.varTypes[node.field]) : playerVars[node.field]?.type;
+    if (fieldType === undefined) {
+        const declared = entityDomain ? Object.keys(kindVars ?? ec.varTypes) : Object.keys(playerVars);
+        const domainLabel = entityDomain ? (memberKind.kind !== undefined ? `entity kind "${memberKind.kind}"` : 'entity') : 'player';
+        e.push(`${path}: aggregate field — unknown ${domainLabel} var "${node.field}"${didYouMean(node.field, declared)} (declared: ${declared.join(', ') || 'none'})`);
+    }
+    else if (fieldType !== 'number') {
+        e.push(`${path}: aggregate "${node.agg}" needs a number field, but "${node.field}" is "${fieldType}"`);
+    }
+    return e;
+}
+// Resolve a `{var:"scope.name"}` read to a declared var or a `self.<built-in>`, returning its inferred type.
+// `self` requires the event to bind a player; did-you-mean on an unknown var.
+function resolveVarRead(path, dotted, bound, roomVars, playerVars, ec) {
+    const dot = dotted.indexOf('.');
+    const scope = dot >= 0 ? dotted.slice(0, dot) : '';
+    const name = dot >= 0 ? dotted.slice(dot + 1) : '';
+    // §5 (P3 ext) a bare bound name (no scope) → a list element bound by forEachInList / listCount / listIndexOf. A
+    // SCALAR element reads as its value; a record/ref element points the author at its proper read form.
+    if (dot < 0 && bound.has(dotted)) {
+        const k = ec.boundKinds?.[dotted];
+        if (k?.type === 'listScalar')
+            return { errors: [], type: k.scalar };
+        if (k?.type === 'listRecord')
+            return { errors: [`${path}: "${dotted}" is a record list element — read a field via {ref:"${dotted}",var:"<field>"}, not {var}`] };
+        if (k?.type === 'player' || k?.type === 'entity')
+            return { errors: [`${path}: "${dotted}" is a ref element — use it as a ref ({ref:"${dotted}",var:…}), not {var}`] };
+    }
+    if (scope === 'action') {
+        // §11.5 (4.7) action.args.<arg> — readable only inside an {on:action} rule (ec.actionArgs set). The type is
+        // the matched action's declared arg type; a ref arg returns 'ref' (resolveRefSlot then accepts it as a Ref).
+        if (!name.startsWith('args.'))
+            return { errors: [`${path}: "${dotted}" — only "action.args.<arg>" is readable from the action scope`] };
+        const arg = name.slice('args.'.length);
+        if (!ec.actionArgs)
+            return { errors: [`${path}: "action.args.${arg}" is only readable in an {on:"action"} rule`] };
+        const at = ec.actionArgs[arg];
+        if (!at)
+            return { errors: [`${path}: unknown action arg "${arg}"${didYouMean(arg, Object.keys(ec.actionArgs))} (declared args: ${Object.keys(ec.actionArgs).join(', ') || 'none'})`] };
+        return { errors: [], type: at.type };
+    }
+    if (scope !== 'room' && scope !== 'self')
+        return { errors: [`${path}: var "${dotted}" must be "room.<var>", "self.<var>", or "action.args.<arg>"`] };
+    if (scope === 'self' && !bound.has('self'))
+        return { errors: [`${path}: "self.${name}" — this rule's event binds no member (no "self" here)`] };
+    if (scope === 'self' && playerBuiltin(name, ec.boundKinds?.self?.type === 'entity'))
+        return { errors: [], type: PLAYER_BUILTIN_TYPES[name] };
+    if (scope === 'room' && name in ROOM_BUILTIN_TYPES)
+        return { errors: [], type: ROOM_BUILTIN_TYPES[name] };
+    const decls = scope === 'room' ? roomVars : playerVars;
+    const builtins = scope === 'room' ? ROOM_BUILTIN_TYPES : PLAYER_BUILTIN_TYPES;
+    const vt = decls[name];
+    if (!vt) {
+        // §9 entity self: when self is an entity, `self.<var>` reads an entity var. Phase 4.5 (row 16): if self's kind
+        // is statically known, resolve against THAT kind's decls (a wrong-kind var now errors); else fall back to the union.
+        if (scope === 'self') {
+            const sk = ec.boundKinds?.self;
+            if (sk?.type === 'entity') {
+                const kv = ec.kindVars[sk.kind]?.[name];
+                if (kv)
+                    return { errors: [], type: kv.type };
+                const d2 = Object.keys(ec.kindVars[sk.kind] ?? {});
+                return { errors: [`${path}: unknown var "${name}" for entity kind "${sk.kind}"${didYouMean(name, d2)} (declared: ${d2.join(', ') || 'none'})`] };
+            }
+            if (name in ec.varTypes)
+                return { errors: [], type: ec.varTypes[name] };
+        }
+        const declared = [...Object.keys(decls), ...Object.keys(builtins)];
+        return { errors: [`${path}: unknown ${scope} var "${name}"${didYouMean(name, declared)} (declared ${scope} vars: ${declared.join(', ') || 'none'})`] };
+    }
+    if (vt.type === 'list' || vt.type === 'counterMap')
+        return { errors: [collectionReadError(path, dotted, vt.type)] }; // §5 (4.5.13) not a scalar value
+    return { errors: [], type: vt.type };
+}
+// §5 (4.5.13) the error when a collection var is read/written as a scalar — direct the author to the right node.
+function collectionReadError(path, dotted, t) {
+    const how = t === 'list' ? 'read it via listLength/listAt, mutate via append/clear' : 'read it via count, mutate via addCount/clear';
+    return `${path}: "${dotted}" is a ${t} collection — it can't be used as a scalar value (${how})`;
+}
+// §5 (4.5.13 + P3) resolve a "room.<var>"/"self.<var>" path to its declared COLLECTION var (list/counterMap).
+// `self` resolves against playerVars, OR — when the event binds self to an entity (P3 entity collections) — against
+// that entity kind's vars. Returns the declared HelixVarType (caller checks list vs counterMap) or an error.
+function resolveCollectionVar(path, dotted, bound, roomVars, playerVars, ec) {
+    const dot = dotted.indexOf('.');
+    const scope = dot >= 0 ? dotted.slice(0, dot) : '';
+    const name = dot >= 0 ? dotted.slice(dot + 1) : '';
+    if (scope !== 'room' && scope !== 'self')
+        return { errors: [`${path}: "${dotted}" must be a "room.<var>" or "self.<var>" collection`] };
+    if (scope === 'self' && !bound.has('self'))
+        return { errors: [`${path}: "self.${name}" — this rule's event binds no member (no "self" here)`] };
+    if (scope === 'self' && ec.boundKinds?.self?.type === 'entity') {
+        const kind = ec.boundKinds.self.kind;
+        const vt = ec.kindVars[kind]?.[name];
+        if (!vt)
+            return { errors: [`${path}: unknown var "${name}" for entity kind "${kind}"${didYouMean(name, Object.keys(ec.kindVars[kind] ?? {}))} (declared: ${Object.keys(ec.kindVars[kind] ?? {}).join(', ') || 'none'})`] };
+        return { errors: [], vt };
+    }
+    const decls = scope === 'room' ? roomVars : playerVars;
+    const vt = decls[name];
+    if (!vt)
+        return { errors: [`${path}: unknown ${scope} collection var "${name}"${didYouMean(name, Object.keys(decls))} (declared ${scope} vars: ${Object.keys(decls).join(', ') || 'none'})`] };
+    return { errors: [], vt };
+}
+// §5 (P3) resolve a collection LVALUE — a "room/self.<var>" path OR a ref-addressed {ref,var} (push onto an
+// iterated/other member's or an entity's collection). The {ref,var} ref resolves to a player (→ playerVars) or a
+// known entity kind (→ that kind's vars). Returns the declared collection VarType, or an error.
+function resolveCollectionLvalue(path, target, bound, roomVars, playerVars, zoneIds, ec) {
+    if (typeof target === 'string')
+        return resolveCollectionVar(path, target, bound, roomVars, playerVars, ec);
+    const r = resolveRefSlot(`${path}.ref`, target.ref, bound, roomVars, playerVars, zoneIds, ec);
+    if (r.errors.length)
+        return { errors: r.errors };
+    const name = target.var;
+    if (r.kind?.type === 'entity') {
+        const vt = ec.kindVars[r.kind.kind]?.[name];
+        if (!vt)
+            return { errors: [`${path}.var: unknown var "${name}" for entity kind "${r.kind.kind}"${didYouMean(name, Object.keys(ec.kindVars[r.kind.kind] ?? {}))} (declared: ${Object.keys(ec.kindVars[r.kind.kind] ?? {}).join(', ') || 'none'})`] };
+        return { errors: [], vt };
+    }
+    const vt = playerVars[name]; // a player ref (or an untracked-kind ref) addresses a player collection
+    if (!vt)
+        return { errors: [`${path}.var: unknown player collection var "${name}"${didYouMean(name, Object.keys(playerVars))} (declared player vars: ${Object.keys(playerVars).join(', ') || 'none'})`] };
+    return { errors: [], vt };
+}
+// §5 (4.5.13) validate a collection-read op (listLength/listAt/count): resolve its var, check the var's kind
+// matches the op, and (listAt) validate the index expr. Returns the op's value type (number, or the list's
+// element type for listAt). Mirrors validateExpr's contract (errors + node count + inferred type).
+function validateCollectionOp(path, expr, bound, roomVars, playerVars, zoneIds, ec, depth) {
+    const n = expr;
+    // §5 (P3 ext) listCount / listIndexOf — a bounded element scan that binds `as` to the element + counts / finds the
+    // first index matching `where` (→ number). The list is any collection lvalue; the where reads the bound element
+    // (scalar via {var:as}, record field via {ref:as,var:field}, ref element as a Ref) and can't itself reduce.
+    if (n.op === 'listCount' || n.op === 'listIndexOf') {
+        const sc = expr;
+        const c = resolveCollectionLvalue(`${path}.list`, sc.list, bound, roomVars, playerVars, zoneIds, ec);
+        if (c.errors.length)
+            return { errors: c.errors, nodes: 1 };
+        if (c.vt.type !== 'list')
+            return { errors: [`${path}: "${n.op}" needs a list var, but ${lvalueLabel(sc.list)} is "${c.vt.type}"`], nodes: 1 };
+        const e = [];
+        if (RESERVED_REF_NAMES.has(sc.as))
+            e.push(`${path}.as: "${sc.as}" is a reserved name`);
+        const inner = new Set([...bound, sc.as]);
+        const innerEc = { ...ec, boundKinds: { ...ec.boundKinds, [sc.as]: elemBinding(c.vt.of) } };
+        const w = validateExpr(`${path}.where`, sc.where, inner, roomVars, playerVars, zoneIds, innerEc, depth + 1);
+        e.push(...w.errors);
+        if (exprHasReduction(sc.where))
+            e.push(`${path}.where: aggregate/nearest* are forbidden inside ${n.op}`);
+        return { errors: e, nodes: 1 + w.nodes, type: 'number' };
+    }
+    if (n.op === 'count') {
+        // §5 (P3 ext) `map` is any counterMap lvalue (room/self path OR a {ref,var} addressing another member's / an entity's counterMap).
+        const c = resolveCollectionLvalue(`${path}.map`, n.map ?? '', bound, roomVars, playerVars, zoneIds, ec);
+        if (c.errors.length)
+            return { errors: c.errors, nodes: 1 };
+        if (c.vt.type !== 'counterMap')
+            return { errors: [`${path}: "count" needs a counterMap var, but ${lvalueLabel(n.map ?? '')} is "${c.vt.type}"`], nodes: 1 };
+        if (!c.vt.keys.includes(n.key ?? ''))
+            return { errors: [`${path}.key: "${n.key}" is not a declared key of ${lvalueLabel(n.map ?? '')}${didYouMean(n.key ?? '', c.vt.keys)} (keys: ${c.vt.keys.join(', ')})`], nodes: 1 };
+        return { errors: [], nodes: 1, type: 'number' };
+    }
+    // §5 (P3 ext) listLength / listAt — `list` is any list lvalue (room/self path OR {ref,var}).
+    const c = resolveCollectionLvalue(`${path}.list`, n.list ?? '', bound, roomVars, playerVars, zoneIds, ec);
+    if (c.errors.length)
+        return { errors: c.errors, nodes: 1 };
+    if (c.vt.type !== 'list')
+        return { errors: [`${path}: "${n.op}" needs a list var, but ${lvalueLabel(n.list ?? '')} is "${c.vt.type}"`], nodes: 1 };
+    if (n.op === 'listLength')
+        return { errors: [], nodes: 1, type: 'number' };
+    // listAt — the index is a number expr. A SCALAR list → the element type (no `field`); a RECORD list → the named
+    // `field`'s scalar type (`field` required). A ref-list element-as-Ref is a deferred follow-up.
+    const r = validateExpr(`${path}.index`, n.index, bound, roomVars, playerVars, zoneIds, ec, depth + 1);
+    const e = [...r.errors];
+    if (r.type !== undefined && r.type !== 'number')
+        e.push(`${path}.index: "listAt" needs a number index, got "${r.type}"`);
+    const of = c.vt.of;
+    if (typeof of === 'string') {
+        if (n.field !== undefined)
+            e.push(`${path}: "listAt" on a scalar list takes no "field"`);
+        return { errors: e, nodes: 1 + r.nodes, type: of };
+    }
+    if (of.type === 'record') {
+        if (n.field === undefined) {
+            e.push(`${path}: "listAt" on a record list needs a "field" to read (fields: ${Object.keys(of.fields).join(', ')})`);
+            return { errors: e, nodes: 1 + r.nodes };
+        }
+        const ft = of.fields[n.field];
+        if (!ft) {
+            e.push(`${path}.field: unknown record field "${n.field}"${didYouMean(n.field, Object.keys(of.fields))} (fields: ${Object.keys(of.fields).join(', ')})`);
+            return { errors: e, nodes: 1 + r.nodes };
+        }
+        return { errors: e, nodes: 1 + r.nodes, type: ft.type };
+    }
+    e.push(`${path}: "listAt" can't read a ref list element as a scalar`);
+    return { errors: e, nodes: 1 + r.nodes };
+}
+// Resolve a ref-addressed read `{ref:<Ref>, var:"<name>"}` (§7.1) — read a member's var. The ref is any Ref
+// (a bound name, a ref-var deref, or a ref-returning op — validated by resolveRefSlot); the referenced member
+// is a player, so `var` resolves against playerVars or a player built-in (e.g. `position`).
+function resolveRefRead(path, ref, name, bound, roomVars, playerVars, zoneIds, ec) {
+    // §5 (P3 ext) a {ref,var} whose ref is a bound RECORD element reads the record's FIELD (not a cross-member deref);
+    // a scalar element has no fields (read it via {var:as}). A ref element falls through to the member-ref path below.
+    if (typeof ref === 'string' && bound.has(ref)) {
+        const k = ec.boundKinds?.[ref];
+        if (k?.type === 'listRecord') {
+            const ft = k.fields[name];
+            if (!ft)
+                return { errors: [`${path}.var: unknown record field "${name}"${didYouMean(name, Object.keys(k.fields))} (fields: ${Object.keys(k.fields).join(', ')})`] };
+            return { errors: [], type: ft.type };
+        }
+        if (k?.type === 'listScalar')
+            return { errors: [`${path}: "${ref}" is a scalar list element — read it via {var:"${ref}"}, not {ref,var}`] };
+    }
+    const r = resolveRefSlot(`${path}.ref`, ref, bound, roomVars, playerVars, zoneIds, ec);
+    if (r.errors.length)
+        return { errors: r.errors };
+    if (playerBuiltin(name, r.kind?.type === 'entity'))
+        return { errors: [], type: PLAYER_BUILTIN_TYPES[name] }; // position (universal) + connected/active (player-only — an entity's declared var wins)
+    // §9 (4.5, row 16) if the ref resolves to a known ENTITY kind, resolve `var` against THAT kind's decls (a
+    // wrong-kind var now errors); a player ref / untracked kind falls back to player vars then the entity-var union.
+    if (r.kind?.type === 'entity') {
+        const kv = ec.kindVars[r.kind.kind]?.[name];
+        if (kv)
+            return { errors: [], type: kv.type };
+        const d2 = Object.keys(ec.kindVars[r.kind.kind] ?? {});
+        return { errors: [`${path}.var: unknown var "${name}" for entity kind "${r.kind.kind}"${didYouMean(name, d2)} (declared: ${d2.join(', ') || 'none'})`] };
+    }
+    const vt = playerVars[name];
+    if (vt) {
+        if (vt.type === 'list' || vt.type === 'counterMap')
+            return { errors: [collectionReadError(`${path}.var`, name, vt.type)] }; // §5 (4.5.13)
+        return { errors: [], type: vt.type };
+    }
+    if (name in ec.varTypes)
+        return { errors: [], type: ec.varTypes[name] };
+    const declared = [...Object.keys(playerVars), ...Object.keys(ec.varTypes), ...Object.keys(PLAYER_BUILTIN_TYPES)];
+    return { errors: [`${path}.var: unknown member var "${name}"${didYouMean(name, declared)} (declared player/entity vars: ${declared.join(', ') || 'none'})`] };
+}
+// Validate a ref slot (§7.1 N2/N14 disambiguation): in a ref position a bare string is a BOUND NAME, and the
+// object forms are a ref-typed var read {var} (deref), nearestPlayer (from a vec3), or aggregate argmax|argmin
+// (a number field). Returns errors (empty = a well-formed ref). Resolution to a member happens at runtime.
+// §9 (4.5) map a declared ref var's `of` ('player' | 'entity:<kind>') to a member kind. undefined = not a ref var.
+function ofToKind(of) {
+    if (of === 'player')
+        return { type: 'player' };
+    if (typeof of === 'string' && of.startsWith('entity:'))
+        return { type: 'entity', kind: of.slice('entity:'.length) };
+    return undefined;
+}
+// The entity sub-kind of a binding, or undefined (a player / a non-member list-element binding). Narrows the
+// widened FwBinding union at the sites that read `.kind` (only the entity variant carries one).
+function bindingKind(b) {
+    return b.type === 'entity' ? b.kind : undefined;
+}
+// §9 (4.5) the static member kind a `{var:"scope.name"}` ref-var deref resolves to — the declared ref var's `of`,
+// looked up against the right scope (room vars; self vars per self's kind; an action ref arg). undefined = untracked.
+function refVarKind(dotted, roomVars, playerVars, ec) {
+    const dot = dotted.indexOf('.');
+    const scope = dot >= 0 ? dotted.slice(0, dot) : '';
+    const name = dot >= 0 ? dotted.slice(dot + 1) : '';
+    if (scope === 'action' && name.startsWith('args.')) {
+        const at = ec.actionArgs?.[name.slice('args.'.length)];
+        return at?.type === 'ref' ? ofToKind(at.of) : undefined;
+    }
+    let decl;
+    if (scope === 'room')
+        decl = roomVars[name];
+    else if (scope === 'self') {
+        const sk = ec.boundKinds?.self;
+        decl = sk?.type === 'entity' ? ec.kindVars[sk.kind]?.[name] : playerVars[name];
+    }
+    return decl?.type === 'ref' ? ofToKind(decl.of) : undefined;
+}
+function resolveRefSlot(path, value, bound, roomVars, playerVars, zoneIds, ec) {
+    if (typeof value === 'string') {
+        if (!bound.has(value))
+            return { errors: [`${path}: "${value}" is not a bound ref (${[...bound].join(', ') || 'none bound here'})`] };
+        const k = ec.boundKinds?.[value]; // the bound name's static member kind (if the event/loop tracks it)
+        // §5 (P3 ext) a SCALAR / RECORD list element is NOT a member ref. A record field read ({ref:as,var:field}) is
+        // resolved in resolveRefRead before reaching here, so anything landing here is a misuse in a plain ref slot.
+        if (k?.type === 'listScalar')
+            return { errors: [`${path}: "${value}" is a scalar list element, not a member ref — read its value via {var:"${value}"}`] };
+        if (k?.type === 'listRecord')
+            return { errors: [`${path}: "${value}" is a record list element, not a member ref — read a field via {ref:"${value}",var:"<field>"} or write via {do:"setField",as:"${value}",…}`] };
+        return { errors: [], kind: k }; // a ref element resolves to its member kind (player/entity) — flows like any bound ref
+    }
+    if (typeof value !== 'object' || value === null) {
+        return { errors: [`${path}: expected a ref (a bound name, a ref var, or a ref-returning op), got ${value === null ? 'null' : typeof value}`] };
+    }
+    if ('var' in value) {
+        const r = resolveVarRead(path, value.var, bound, roomVars, playerVars, ec);
+        if (r.errors.length)
+            return { errors: r.errors };
+        if (r.type !== 'ref')
+            return { errors: [`${path}: "${value.var}" is "${r.type}", not a ref`] };
+        return { errors: [], kind: refVarKind(value.var, roomVars, playerVars, ec) };
+    }
+    if (value.op === 'nearestPlayer') {
+        const r = validateExpr(`${path}.from`, value.from, bound, roomVars, playerVars, zoneIds, ec, 1);
+        const e = [...r.errors];
+        if (r.type !== undefined && r.type !== 'vec3')
+            e.push(`${path}.from: "nearestPlayer" needs a vec3, got "${r.type}"`);
+        return { errors: e, kind: { type: 'player' } };
+    }
+    if (value.op === 'nearestEntity') {
+        const r = validateExpr(`${path}.from`, value.from, bound, roomVars, playerVars, zoneIds, ec, 1);
+        const e = [...r.errors];
+        if (r.type !== undefined && r.type !== 'vec3')
+            e.push(`${path}.from: "nearestEntity" needs a vec3, got "${r.type}"`);
+        if (value.kind !== undefined && !ec.kinds.has(value.kind)) {
+            e.push(`${path}.kind: unknown entity kind "${value.kind}"${didYouMean(value.kind, [...ec.kinds])} (declared entities: ${[...ec.kinds].join(', ') || 'none'})`);
+        }
+        // A kinded nearestEntity resolves to that kind (per-kind reads); kindless = any entity (kind untracked).
+        return { errors: e, kind: value.kind !== undefined ? { type: 'entity', kind: value.kind } : undefined };
+    }
+    if (value.op === 'controllerOf') {
+        // §9 (P3 Ownership/A3) the player controlling `entity` — a player ref ('' = server/unowned). O(1) field read.
+        const r = resolveRefSlot(`${path}.entity`, value.entity, bound, roomVars, playerVars, zoneIds, ec);
+        return { errors: r.errors, kind: { type: 'player' } };
+    }
+    if (value.op === 'leastLoadedPlayer') {
+        // §9 (P3 Ownership/B8) the least-busy connected player (optional where/as filter, validated like aggregate's
+        // over the player domain). A reduction (O(players)) → forbidden inside forEach by refHasReduction.
+        const e = [];
+        if (value.where !== undefined || value.as !== undefined) {
+            if (value.as === undefined)
+                e.push(`${path}: leastLoadedPlayer "where" requires "as" (a name for each candidate player)`);
+            else if (RESERVED_REF_NAMES.has(value.as))
+                e.push(`${path}.as: "${value.as}" is a reserved name`);
+            else if (value.where === undefined)
+                e.push(`${path}: leastLoadedPlayer "as" requires a "where" filter`);
+            else {
+                const inner = new Set([...bound, value.as]);
+                const innerEc = { ...ec, boundKinds: { ...ec.boundKinds, [value.as]: { type: 'player' } } };
+                e.push(...validateExpr(`${path}.where`, value.where, inner, roomVars, playerVars, zoneIds, innerEc, 1).errors);
+                if (exprHasReduction(value.where))
+                    e.push(`${path}.where: aggregate/nearest* are forbidden inside a leastLoadedPlayer "where"`);
+            }
+        }
+        return { errors: e, kind: { type: 'player' } };
+    }
+    if (value.op === 'listAt') {
+        // §5 (P3-B2 + P3 ext) a `list of ref` element AS a Ref (the turn-order current actor). The list is any list
+        // lvalue (room/self path OR {ref,var}); its element must be a ref; the index a number. The resolved member kind is
+        // the ref element's `of`. O(1) — not a reduction.
+        const c = resolveCollectionLvalue(`${path}.list`, value.list, bound, roomVars, playerVars, zoneIds, ec);
+        if (c.errors.length)
+            return { errors: c.errors };
+        const vt = c.vt;
+        const elem = vt.type === 'list' ? vt.of : undefined;
+        if (vt.type !== 'list' || typeof elem !== 'object' || elem.type !== 'ref') {
+            const what = vt.type === 'list' ? `a list of ${typeof elem === 'string' ? elem : elem.type}` : `a "${vt.type}"`;
+            return { errors: [`${path}: listAt is a Ref only over a list of refs (${lvalueLabel(value.list)} is ${what})`] };
+        }
+        const r = validateExpr(`${path}.index`, value.index, bound, roomVars, playerVars, zoneIds, ec, 1);
+        const errs = [...r.errors];
+        if (r.type !== undefined && r.type !== 'number')
+            errs.push(`${path}.index: listAt needs a number index, got "${r.type}"`);
+        return { errors: errs, kind: ofToKind(elem.of) };
+    }
+    // aggregate argmax|argmin — the reduced scope's member kind (players → player; entities:<kind> or a zone
+    // tracking 'entity:<kind>' → that entity).
+    const e = validateAggregate(path, value, bound, roomVars, playerVars, zoneIds, ec);
+    const scope = value.scope ?? '';
+    const kind = aggregateMemberKind(scope, ec);
+    return { errors: e, kind };
+}
+// Resolve an lvalue (effect target) to its writable var's type. A string scope-path "room.<var>"/"self.<var>"
+// or the ref-addressed `{ref,var}` write-through-ref. `self`/ref require a bound player; a built-in (position)
+// is read-only here (write it via teleport/respawn); did-you-mean on an unknown var.
+function resolveLvalue(path, lvalue, bound, roomVars, playerVars, zoneIds, ec) {
+    if (typeof lvalue !== 'string') {
+        const { ref, var: name } = lvalue;
+        const r = resolveRefSlot(`${path}.ref`, ref, bound, roomVars, playerVars, zoneIds, ec);
+        if (r.errors.length)
+            return { errors: r.errors };
+        if (playerBuiltin(name, r.kind?.type === 'entity'))
+            return { errors: [`${path}: can't write the built-in "${name}" — use teleport/respawn`] };
+        // §9 (4.5, row 16) write-through to an ENTITY var resolves against the ref's specific kind when known.
+        if (r.kind?.type === 'entity') {
+            const kv = ec.kindVars[r.kind.kind]?.[name];
+            if (kv)
+                return { errors: [], type: kv.type };
+            const d2 = Object.keys(ec.kindVars[r.kind.kind] ?? {});
+            return { errors: [`${path}: unknown var "${name}" for entity kind "${r.kind.kind}"${didYouMean(name, d2)} (declared: ${d2.join(', ') || 'none'})`] };
+        }
+        const vt = playerVars[name];
+        if (vt) {
+            if (vt.type === 'list' || vt.type === 'counterMap')
+                return { errors: [collectionReadError(path, name, vt.type)] }; // §5 (4.5.13) not a scalar write
+            return { errors: [], type: vt.type };
+        }
+        if (name in ec.varTypes)
+            return { errors: [], type: ec.varTypes[name] };
+        const declared = [...Object.keys(playerVars), ...Object.keys(ec.varTypes)];
+        return { errors: [`${path}: unknown member var "${name}"${didYouMean(name, declared)} (declared player/entity vars: ${declared.join(', ') || 'none'})`] };
+    }
+    const dot = lvalue.indexOf('.');
+    const scope = dot >= 0 ? lvalue.slice(0, dot) : '';
+    const name = dot >= 0 ? lvalue.slice(dot + 1) : '';
+    if (scope !== 'room' && scope !== 'self')
+        return { errors: [`${path}: "${lvalue}" must be "room.<var>" or "self.<var>"`] };
+    if (scope === 'self' && !bound.has('self'))
+        return { errors: [`${path}: "self.${name}" — this rule's event binds no member (no "self" here)`] };
+    if (scope === 'self' && playerBuiltin(name, ec.boundKinds?.self?.type === 'entity'))
+        return { errors: [`${path}: can't write the built-in "self.${name}" — use teleport/respawn`] };
+    if (scope === 'room' && name in ROOM_BUILTIN_TYPES)
+        return { errors: [`${path}: can't write the built-in "room.${name}" — use transitionTo`] };
+    const decls = scope === 'room' ? roomVars : playerVars;
+    const vt = decls[name];
+    if (!vt) {
+        if (scope === 'self' && name in ec.varTypes)
+            return { errors: [], type: ec.varTypes[name] }; // §9 entity self write
+        const declared = Object.keys(decls);
+        return { errors: [`${path}: unknown ${scope} var "${name}"${didYouMean(name, declared)} (declared ${scope} vars: ${declared.join(', ') || 'none'})`] };
+    }
+    if (vt.type === 'list' || vt.type === 'counterMap')
+        return { errors: [collectionReadError(path, lvalue, vt.type)] }; // §5 (4.5.13) not a scalar write
+    return { errors: [], type: vt.type };
+}
+// §11.1 closed cap table enforcement: count caps per scope + per-string-var ceilings, with a precise
+// "over the cap" message. The dimensions are exactly MULTIPLAYER_CAPS (Phase-1 declarable set).
+function checkStateCaps(state) {
+    const e = [];
+    const scopes = [
+        ['roomVars', state.roomVars, exports.MULTIPLAYER_CAPS.roomVars],
+        ['playerVars', state.playerVars, exports.MULTIPLAYER_CAPS.playerVars],
+    ];
+    for (const [scope, decls, cap] of scopes) {
+        if (!decls)
+            continue;
+        const names = Object.keys(decls);
+        if (names.length > cap)
+            e.push(`manifest: multiplayer.state.${scope} declares ${names.length} vars — the cap is ${cap}`);
+        for (const name of names) {
+            const vt = decls[name];
+            if (vt.type !== 'string')
+                continue;
+            if (vt.maxLen !== undefined && vt.maxLen > exports.MULTIPLAYER_CAPS.stringMaxLen) {
+                e.push(`multiplayer.state.${scope}.${name}: maxLen ${vt.maxLen} exceeds the ceiling of ${exports.MULTIPLAYER_CAPS.stringMaxLen}`);
+            }
+            if (vt.enum && vt.enum.length > exports.MULTIPLAYER_CAPS.enumValues) {
+                e.push(`multiplayer.state.${scope}.${name}: enum has ${vt.enum.length} values — the cap is ${exports.MULTIPLAYER_CAPS.enumValues}`);
+            }
+        }
+    }
+    return e;
+}
+// Cross-field check a declared var's default against its own constraints — the part JSON Schema can't
+// express (default-vs-bounds, integer-ness, enum membership). The schema already validated vt's shape +
+// discriminant, so we branch on vt.type.
+function checkVarDefault(path, vt) {
+    const e = [];
+    if (vt.type === 'number') {
+        if (vt.min !== undefined && vt.max !== undefined && vt.min > vt.max)
+            e.push(`${path}: min ${vt.min} exceeds max ${vt.max}`);
+        if (vt.integer && !Number.isInteger(vt.default))
+            e.push(`${path}: default ${vt.default} must be an integer`);
+        if (vt.min !== undefined && vt.default < vt.min)
+            e.push(`${path}: default ${vt.default} is below min ${vt.min}`);
+        if (vt.max !== undefined && vt.default > vt.max)
+            e.push(`${path}: default ${vt.default} is above max ${vt.max}`);
+    }
+    else if (vt.type === 'string') {
+        if (vt.maxLen !== undefined && vt.default.length > vt.maxLen)
+            e.push(`${path}: default "${vt.default}" exceeds maxLen ${vt.maxLen}`);
+        if (vt.enum && !vt.enum.includes(vt.default))
+            e.push(`${path}: default "${vt.default}" is not one of the declared enum values [${vt.enum.join(', ')}]`);
+    }
+    else if (vt.type === 'list') {
+        // §5 (4.5.13) a list starts empty (no author default); maxLen must be a positive integer within the cap.
+        if (!Number.isInteger(vt.maxLen) || vt.maxLen < 1)
+            e.push(`${path}: list maxLen must be a positive integer, got ${vt.maxLen}`);
+        else if (vt.maxLen > exports.MULTIPLAYER_CAPS.listMaxLen)
+            e.push(`${path}: list maxLen ${vt.maxLen} exceeds the ceiling of ${exports.MULTIPLAYER_CAPS.listMaxLen}`);
+        // §5 (P3 Collections) a record element: cap its field count + validate each flat scalar field (no nesting).
+        if (typeof vt.of === 'object' && vt.of.type === 'record') {
+            const names = Object.keys(vt.of.fields);
+            if (names.length > exports.MULTIPLAYER_CAPS.recordFields)
+                e.push(`${path}: a record element declares ${names.length} fields — the cap is ${exports.MULTIPLAYER_CAPS.recordFields}`);
+            for (const fn of names)
+                e.push(...checkRecordField(`${path}.of.fields.${fn}`, vt.of.fields[fn]));
+        }
+    }
+    else if (vt.type === 'counterMap') {
+        // §5 (4.5.13) a counterMap starts with every declared key at 0; keys must be non-empty, unique, within the cap.
+        if (vt.keys.length === 0)
+            e.push(`${path}: counterMap needs at least one key`);
+        else if (vt.keys.length > exports.MULTIPLAYER_CAPS.counterKeys)
+            e.push(`${path}: counterMap has ${vt.keys.length} keys — the cap is ${exports.MULTIPLAYER_CAPS.counterKeys}`);
+        if (new Set(vt.keys).size !== vt.keys.length)
+            e.push(`${path}: counterMap keys must be unique`);
+    }
+    return e;
+}
+// §5 (P3 Collections) cross-field check a record element's flat scalar field (the part JSON Schema can't express:
+// default-vs-bounds, integer-ness, enum membership, the shared maxLen/enum ceilings). Mirrors checkVarDefault but
+// the field default is OPTIONAL — only validate it when present.
+function checkRecordField(path, f) {
+    const e = [];
+    if (f.type === 'number') {
+        if (f.min !== undefined && f.max !== undefined && f.min > f.max)
+            e.push(`${path}: min ${f.min} exceeds max ${f.max}`);
+        if (f.default !== undefined) {
+            if (f.integer && !Number.isInteger(f.default))
+                e.push(`${path}: default ${f.default} must be an integer`);
+            if (f.min !== undefined && f.default < f.min)
+                e.push(`${path}: default ${f.default} is below min ${f.min}`);
+            if (f.max !== undefined && f.default > f.max)
+                e.push(`${path}: default ${f.default} is above max ${f.max}`);
+        }
+    }
+    else if (f.type === 'string') {
+        if (f.maxLen !== undefined && f.maxLen > exports.MULTIPLAYER_CAPS.stringMaxLen)
+            e.push(`${path}: maxLen ${f.maxLen} exceeds the ceiling of ${exports.MULTIPLAYER_CAPS.stringMaxLen}`);
+        if (f.enum && f.enum.length > exports.MULTIPLAYER_CAPS.enumValues)
+            e.push(`${path}: enum has ${f.enum.length} values — the cap is ${exports.MULTIPLAYER_CAPS.enumValues}`);
+        if (f.default !== undefined) {
+            if (f.maxLen !== undefined && f.default.length > f.maxLen)
+                e.push(`${path}: default "${f.default}" exceeds maxLen ${f.maxLen}`);
+            if (f.enum && !f.enum.includes(f.default))
+                e.push(`${path}: default "${f.default}" is not one of the declared enum values [${f.enum.join(', ')}]`);
+        }
+    }
+    return e;
+}
+// §5 (P3 Collections) validate a value written into a list whose element type is `elem`: a scalar Expr of the
+// matching type, a ref (a Ref of the matching kind), or a record literal { field: Expr|Ref } (each provided field
+// type-matches its declared field; an unknown field errors; an omitted field takes its default/zero at runtime).
+// Reused by append (C1) and the record-element mutators (C3/C4).
+function validateListElementValue(path, value, elem, bound, roomVars, playerVars, zoneIds, ec) {
+    if (typeof elem === 'string') {
+        const r = validateExpr(path, value, bound, roomVars, playerVars, zoneIds, ec, 1);
+        const e = [...r.errors];
+        if (r.type !== undefined && r.type !== elem)
+            e.push(`${path}: a "${r.type}" can't go into a list of "${elem}"`);
+        return e;
+    }
+    if (elem.type === 'ref') {
+        const r = resolveRefSlot(path, value, bound, roomVars, playerVars, zoneIds, ec);
+        const e = [...r.errors];
+        const want = ofToKind(elem.of);
+        if (r.kind && want && (r.kind.type !== want.type || bindingKind(r.kind) !== bindingKind(want))) {
+            const lbl = (k) => (k.type === 'player' ? 'player' : `entity:${bindingKind(k)}`);
+            e.push(`${path}: a "${lbl(r.kind)}" ref can't go into a list of "${lbl(want)}" refs`);
+        }
+        return e;
+    }
+    // record element — the value is a record literal (a plain object of field → Expr|Ref).
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return [`${path}: a record list needs a record literal { field: value, ... }`];
+    }
+    const e = [];
+    for (const [fn, fv] of Object.entries(value)) {
+        const ft = elem.fields[fn];
+        if (!ft) {
+            e.push(`${path}.${fn}: unknown record field "${fn}"${didYouMean(fn, Object.keys(elem.fields))} (fields: ${Object.keys(elem.fields).join(', ')})`);
+            continue;
+        }
+        if (ft.type === 'ref') {
+            e.push(...resolveRefSlot(`${path}.${fn}`, fv, bound, roomVars, playerVars, zoneIds, ec).errors);
+        }
+        else {
+            const r = validateExpr(`${path}.${fn}`, fv, bound, roomVars, playerVars, zoneIds, ec, 1);
+            e.push(...r.errors);
+            if (r.type !== undefined && r.type !== ft.type)
+                e.push(`${path}.${fn}: a "${r.type}" value doesn't match the declared "${ft.type}"`);
+        }
+    }
+    return e;
+}
+// The valid declared-var type discriminants — the single source for the did-you-mean below + the authoring
+// vocabulary the schema's varDecls oneOf enumerates. (Bounds/enum/of live on each variant; this is the tag.)
+exports.VAR_TYPES = ['number', 'string', 'boolean', 'vec3', 'ref', 'list', 'counterMap'];
+function levenshtein(a, b) {
+    const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+    for (let j = 0; j <= b.length; j++)
+        d[0][j] = j;
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+        }
+    }
+    return d[a.length][b.length];
+}
+// "" when nothing is close enough (edit distance > 2), so an unrelated typo doesn't get a misleading guess.
+function didYouMean(input, candidates) {
+    let best = '';
+    let bestD = Infinity;
+    for (const c of candidates) {
+        const dist = levenshtein(input, c);
+        if (dist < bestD)
+            [bestD, best] = [dist, c];
+    }
+    return bestD <= 2 ? ` — did you mean "${best}"?` : '';
+}
+// §11.9 validation/error UX: an invalid VarType discriminant makes the schema's varDecls oneOf fail with an
+// unreadable per-branch cascade, so when v0.3 validation fails we scan declared state for a bad `type` and
+// surface the actionable root cause (path + did-you-mean + the valid set) instead. Empty => no bad
+// discriminant (the raw Ajv errors stand). NOTE: the fuller symbol table (cross-reference resolution +
+// warn-on-unreferenced) lands in Phase 2, when rules/zones/events introduce the references it checks.
+function declaredTypeErrors(candidate) {
+    const errs = [];
+    const state = candidate.multiplayer?.state;
+    if (!state || typeof state !== 'object')
+        return errs;
+    for (const scope of ['roomVars', 'playerVars']) {
+        const decls = state[scope];
+        if (!decls || typeof decls !== 'object')
+            continue;
+        for (const [name, vt] of Object.entries(decls)) {
+            const t = vt?.type;
+            if (typeof t === 'string' && !exports.VAR_TYPES.includes(t)) {
+                errs.push(`multiplayer.state.${scope}.${name}: unknown var type "${t}"${didYouMean(t, exports.VAR_TYPES)} (valid: ${exports.VAR_TYPES.join(', ')})`);
+            }
+        }
+    }
+    return errs;
+}
 function formatError(err, label = 'manifest') {
     const path = err.instancePath ? err.instancePath.replace(/^\//, '').replace(/\//g, '.') : label;
     if (err.keyword === 'additionalProperties') {
@@ -112,7 +2997,10 @@ function formatError(err, label = 'manifest') {
 }
 // Validates and normalizes a parsed helix.json. Same code runs in the CLI
 // (pre-upload) and the backend (finalize) so the two can never disagree.
-function validateManifest(data) {
+// `strict` (Phase 4.9 pre-launch gate): flip the accept+loud-no-op future-node WARNINGS into hard ERRORS, so a
+// real publish/launch can't ship a world that leans on a not-yet-interpreted reserved node. Default off (author-
+// time tooling warns; the launch pipeline passes { strict: true }).
+function validateManifest(data, opts) {
     if (typeof data !== 'object' || data === null || Array.isArray(data)) {
         return { valid: false, errors: ['manifest: must be a JSON object'] };
     }
@@ -127,13 +3015,19 @@ function validateManifest(data) {
     // Route to the schema for the declared version (omitted → v0.1, which requires helixVersion).
     const validate = candidate.helixVersion === '0.3' ? validateV03 : candidate.helixVersion === '0.2' ? validateV02 : validateV01;
     if (!validate(candidate)) {
+        // A bad VarType discriminant detonates the varDecls oneOf into noise — surface the clean root cause.
+        if (candidate.helixVersion === '0.3') {
+            const typeErrs = declaredTypeErrors(candidate);
+            if (typeErrs.length)
+                return { valid: false, errors: typeErrs };
+        }
         const errors = (validate.errors ?? []).map((e) => formatError(e));
         return { valid: false, errors: [...new Set(errors)] };
     }
     const manifest = candidate;
     let warnings = [];
     if (manifest.helixVersion === '0.3') {
-        const cross = applyV03CrossFieldRules(manifest);
+        const cross = applyV03CrossFieldRules(manifest, opts?.strict ?? false);
         if (cross.errors.length)
             return { valid: false, errors: cross.errors };
         warnings = cross.warnings;