@helixdev/helix-manifest 0.3.0-staging.13 → 0.3.0-staging.14

package/dist/schema/manifest-v0.3.schema.json

@@ -58,6 +58,12 @@
                     "minimum": 1,
                     "description": "Minimum players the world needs to be playable (default 1 = single-player-safe). When 1, the single-player gate warns (strict = error) if a phase transition is gated on playerCount >= 2. Set >= 2 to declare a multiplayer-only world."
                 },
+                "uploadHz": {
+                    "type": "integer",
+                    "enum": [10, 20],
+                    "default": 10,
+                    "description": "Client->server state upload rate: 10 (default) or 20 Hz, raising both the player-seat and hosted-entity channels. 20 Hz requires maxPlayers <= 12 (enforced by the validator). The platform still owns the sim/patch rate."
+                },
                 "authoritative": {
                     "type": "boolean",
                     "default": true,
@@ -185,10 +191,35 @@
                 { "type": "object", "additionalProperties": false, "required": ["type", "default"], "properties": { "type": { "const": "boolean" }, "default": { "type": "boolean" } } },
                 { "type": "object", "additionalProperties": false, "required": ["type", "default"], "properties": { "type": { "const": "vec3" }, "default": { "type": "array", "items": { "type": "number" }, "minItems": 3, "maxItems": 3 } } },
                 { "type": "object", "additionalProperties": false, "required": ["type", "of"], "properties": { "type": { "const": "ref" }, "of": { "type": "string", "pattern": "^(player|entity:[a-z0-9][a-z0-9-]*)$" }, "default": { "type": "null" } } },
-                { "type": "object", "additionalProperties": false, "required": ["type", "of", "maxLen"], "properties": { "type": { "const": "list" }, "of": { "enum": ["number", "string", "boolean"] }, "maxLen": { "type": "integer", "minimum": 1 } }, "description": "Tier 2 Phase 4.5.13: a bounded ordered array of one scalar element type (roomVars/playerVars only). Starts empty; append/clear mutate, listLength/listAt read." },
-                { "type": "object", "additionalProperties": false, "required": ["type", "keys"], "properties": { "type": { "const": "counterMap" }, "keys": { "type": "array", "items": { "type": "string" }, "minItems": 1, "uniqueItems": true } }, "description": "Tier 2 Phase 4.5.13: a closed-enum-keyed number map (each key 0 at start; roomVars/playerVars only). addCount/clear mutate, count reads." }
+                { "type": "object", "additionalProperties": false, "required": ["type", "of", "maxLen"], "properties": { "type": { "const": "list" }, "of": { "$ref": "#/$defs/listElem" }, "maxLen": { "type": "integer", "minimum": 1 } }, "description": "Tier 2 (4.5.13 + P3 Collections): a bounded ordered array whose element is a scalar, a ref, or a flat record. Starts empty; append/removeAt/removeWhere/setField/clear mutate, listLength/listAt/listCount/listIndexOf read." },
+                { "type": "object", "additionalProperties": false, "required": ["type", "keys"], "properties": { "type": { "const": "counterMap" }, "keys": { "type": "array", "items": { "type": "string" }, "minItems": 1, "uniqueItems": true } }, "description": "Tier 2 Phase 4.5.13: a closed-enum-keyed number map (each key 0 at start). addCount/clear mutate, count reads." }
+            ]
+        },
+        "listElem": {
+            "description": "A list's element type (P3 Collections): a scalar shorthand (number/string/boolean), a ref element, or a flat record of scalar fields (no nested collections/records — spec §13 ceiling).",
+            "oneOf": [
+                { "enum": ["number", "string", "boolean"] },
+                { "type": "object", "additionalProperties": false, "required": ["type", "of"], "properties": { "type": { "const": "ref" }, "of": { "type": "string", "pattern": "^(player|entity:[a-z0-9][a-z0-9-]*)$" } } },
+                { "type": "object", "additionalProperties": false, "required": ["type", "fields"], "properties": { "type": { "const": "record" }, "fields": { "type": "object", "minProperties": 1, "propertyNames": { "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "additionalProperties": { "$ref": "#/$defs/recordField" } } } }
+            ]
+        },
+        "recordField": {
+            "description": "A flat scalar field of a record-list element (P3 Collections): the §5 scalar vocabulary with an OPTIONAL default; a ref field declares `of`. No nested collection/record.",
+            "oneOf": [
+                { "type": "object", "additionalProperties": false, "required": ["type"], "properties": { "type": { "const": "number" }, "default": { "type": "number" }, "min": { "type": "number" }, "max": { "type": "number" }, "integer": { "type": "boolean" } } },
+                { "type": "object", "additionalProperties": false, "required": ["type"], "properties": { "type": { "const": "string" }, "default": { "type": "string" }, "maxLen": { "type": "integer", "minimum": 1 }, "enum": { "type": "array", "items": { "type": "string" }, "minItems": 1, "uniqueItems": true } } },
+                { "type": "object", "additionalProperties": false, "required": ["type"], "properties": { "type": { "const": "boolean" }, "default": { "type": "boolean" } } },
+                { "type": "object", "additionalProperties": false, "required": ["type"], "properties": { "type": { "const": "vec3" }, "default": { "type": "array", "items": { "type": "number" }, "minItems": 3, "maxItems": 3 } } },
+                { "type": "object", "additionalProperties": false, "required": ["type", "of"], "properties": { "type": { "const": "ref" }, "of": { "type": "string", "pattern": "^(player|entity:[a-z0-9][a-z0-9-]*)$" } } }
             ]
         },
+        "recordLiteral": {
+            "description": "A record-list element literal (P3 Collections): field name -> a value Expr or a Ref. Validated against the list's declared record fields by the publish validator.",
+            "type": "object",
+            "minProperties": 1,
+            "propertyNames": { "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" },
+            "additionalProperties": { "$ref": "#/$defs/payloadValue" }
+        },
         "timerDecl": {
             "description": "A declared timer (spec §8). Room-scoped by default ({}); `keyed:'player'` makes it per-player — startTimer/cancelTimer/timerRemaining then require a `key` (a player ref) and timerElapsed binds `self`. Keyed-ness is a static property of the declared name (every use must agree).",
             "type": "object",
@@ -208,7 +239,9 @@
                 "shared": { "type": "boolean", "description": "spec §9 (Phase 4.8): the entity belongs to the game, not a player — one client is its simulation host. Requires authority:'owner' + ownerLifecycle:'hostMigrate'; the server assigns the least-loaded client at spawn and re-elects on the host's leave (involuntary host migration)." },
                 "idleTimeout": { "type": "number", "exclusiveMinimum": 0, "description": "spec §9 (Phase 4.8, optional): seconds a shared entity may stay hostless (frozen, no eligible host) before despawning." },
                 "ownerLifecycle": { "enum": ["despawnWithOwner", "persist", "migrateToServer", "hostMigrate"], "description": "spec §9. Single-owner: despawnWithOwner (default) destroys on the owner's leave; persist leaves it frozen; migrateToServer freezes during a transient grace absence + the same owner resumes. Shared: hostMigrate (requires shared:true) — re-elect the least-loaded client on the host's leave." },
-                "transferPolicy": { "enum": ["fixed", "request", "takeover"], "description": "spec §9 (Phase 4.5.12): voluntary ownership transfer policy the requestOwnership/takeover verbs honor. 'fixed' (default) = the verbs no-op. 'request' = grant only when unowned (polite pickup). 'takeover' = also steal from a live owner. Requires authority:'owner'. A transfer bumps the entity's authorityEpoch + fires ownershipChanged." }
+                "transferPolicy": { "enum": ["fixed", "request", "takeover"], "description": "spec §9 (Phase 4.5.12): voluntary ownership transfer policy the requestOwnership/takeover verbs honor. 'fixed' (default) = the verbs no-op. 'request' = grant only when unowned (polite pickup). 'takeover' = also steal from a live owner. Requires authority:'owner'. A transfer bumps the entity's authorityEpoch + fires ownershipChanged." },
+                "physics": { "$ref": "#/$defs/entityPhysics" },
+                "rejoinOnRelease": { "enum": ["nearestPoint", "timeIndex", "seekBack"], "description": "networked-physics (Phase 3.5): how a HYBRID kind (physics + server motion) re-anchors its declared path when a client RELEASES it back to the server. 'nearestPoint' (default) re-bases the path to the closest point so it doesn't snap; 'timeIndex' resumes the original time origin; 'seekBack' eases toward the path. Only meaningful with both physics and a non-static motion." }
             }
         },
         "attachedZone": {
@@ -229,6 +262,33 @@
                 { "type": "object", "additionalProperties": false, "required": ["type", "points", "speed"], "properties": { "type": { "const": "waypoints" }, "points": { "type": "array", "minItems": 2, "items": { "type": "array", "items": { "type": "number" }, "minItems": 3, "maxItems": 3 } }, "speed": { "type": "number", "exclusiveMinimum": 0 }, "loop": { "type": "boolean" } } }
             ]
         },
+        "entityPhysics": {
+            "description": "networked-physics (Phase 0/2): opt-in CLIENT-simulated dynamic rigid body. Present only on authority:'owner' kinds; absent ⇒ today's kinematic/position-only path (no Rapier body, no velocity/orientation on the wire, near-zero cost). The owner simulates it locally and uploads position+velocity+orientation; remotes reproduce it (snap-into-sim + decaying render offset). Every sub-capability defaults OFF and composes per kind.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["bodyType", "shape"],
+            "properties": {
+                "bodyType": { "const": "dynamic", "description": "Only 'dynamic' — kinematic/static bodies stay expressed by `motion`/none. 'dynamic' is the new networked-physics path." },
+                "shape": {
+                    "description": "The collider shape (and dimensions, meters) the body simulates with. Mirror the visual on the client.",
+                    "oneOf": [
+                        { "type": "object", "additionalProperties": false, "required": ["type", "radius"], "properties": { "type": { "const": "sphere" }, "radius": { "type": "number", "exclusiveMinimum": 0 } } },
+                        { "type": "object", "additionalProperties": false, "required": ["type", "halfExtents"], "properties": { "type": { "const": "box" }, "halfExtents": { "type": "array", "items": { "type": "number", "exclusiveMinimum": 0 }, "minItems": 3, "maxItems": 3 } } },
+                        { "type": "object", "additionalProperties": false, "required": ["type", "halfHeight", "radius"], "properties": { "type": { "const": "capsule" }, "halfHeight": { "type": "number", "exclusiveMinimum": 0 }, "radius": { "type": "number", "exclusiveMinimum": 0 } } }
+                    ]
+                },
+                "mass": { "type": "number", "exclusiveMinimum": 0, "description": "kg, default 1." },
+                "restitution": { "type": "number", "minimum": 0, "maximum": 1, "description": "0..1 bounciness, default 0.2." },
+                "friction": { "type": "number", "minimum": 0, "description": "default 0.5." },
+                "linearDamping": { "type": "number", "minimum": 0, "description": "default 0." },
+                "angularDamping": { "type": "number", "minimum": 0, "description": "default 0.05." },
+                "maxAngularSpeed": { "type": "number", "exclusiveMinimum": 0, "description": "rad/s gate ceiling for angular velocity; default derived from maxSpeed." },
+                "collidesWith": { "type": "array", "items": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]{0,31}$" }, "description": "entity kinds this body collides with; default ⇒ all physics bodies + world geometry. Each entry must be a declared kind." },
+                "claimOnContact": { "type": "boolean", "description": "Phase 3.2: the server auto-hands this (simulated) body's authority to a contacting owner. Requires transferPolicy:'takeover'. Default false." },
+                "revertOnRest": { "type": "boolean", "description": "Phase 3.4: auto-release to the server (controller='') when the body comes to rest. Default off for 'fixed', on for 'shared' custody." },
+                "dualSimOnContact": { "type": "boolean", "description": "Phase 4: controlled×controlled — each client locally sims BOTH bodies + reconciles. Requires transferPolicy:'fixed'. Default false." }
+            }
+        },
         "zone": {
             "description": "A declared static spatial volume (spec §6), discriminated on `shape`. center is [x,y,z] in meters; a box uses full `size` [x,y,z], a sphere uses `radius`. tracks defaults to 'players'; 'entity:<kind>' tests entities of that kind, binding self = the entering entity (4.5.8). requireDwell/debounce (seconds) harden against teleport-touch and are enforced from Phase 2.4.",
             "type": "object",
@@ -262,25 +322,32 @@
                 { "type": "string" },
                 { "type": "boolean" },
                 { "type": "object", "additionalProperties": false, "required": ["vec3"], "properties": { "vec3": { "type": "array", "items": { "type": "number" }, "minItems": 3, "maxItems": 3 } } },
-                { "type": "object", "additionalProperties": false, "required": ["var"], "properties": { "var": { "type": "string", "pattern": "^((room|self)\\.[A-Za-z][A-Za-z0-9_]{0,31}|action\\.args\\.[A-Za-z][A-Za-z0-9_]{0,31})$" } } },
+                { "type": "object", "additionalProperties": false, "required": ["var"], "properties": { "var": { "type": "string", "pattern": "^((room|self)\\.[A-Za-z][A-Za-z0-9_]{0,31}|action\\.args\\.[A-Za-z][A-Za-z0-9_]{0,31}|[A-Za-z][A-Za-z0-9_]{0,31})$" } }, "description": "A var value read: \"room.<v>\" / \"self.<v>\" / \"action.args.<a>\", or a bare name = a SCALAR list element bound by forEachInList / listCount / listIndexOf (§5 P3 ext). The bare form resolves only against a list-element binding; an unbound bare name is rejected by the validator." },
                 { "$ref": "#/$defs/refLvalue" },
                 { "type": "object", "additionalProperties": false, "required": ["op", "a", "b"], "properties": { "op": { "enum": ["distance", "==", "!=", "<", "<=", ">", ">=", "+", "-", "*", "/"] }, "a": { "$ref": "#/$defs/expr" }, "b": { "$ref": "#/$defs/expr" } } },
                 { "type": "object", "additionalProperties": false, "required": ["op", "of"], "properties": { "op": { "enum": ["and", "or"] }, "of": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/expr" } } } },
                 { "type": "object", "additionalProperties": false, "required": ["op", "of"], "properties": { "op": { "const": "not" }, "of": { "$ref": "#/$defs/expr" } } },
                 { "type": "object", "additionalProperties": false, "required": ["op", "scope", "agg"], "properties": { "op": { "const": "aggregate" }, "scope": { "type": "string", "pattern": "^(players|zone:[A-Za-z][A-Za-z0-9_]{0,31}|entities:[a-z0-9][a-z0-9-]{0,31})$" }, "agg": { "enum": ["count", "sum", "min", "max", "avg"] }, "field": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "where": { "$ref": "#/$defs/expr" }, "as": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" } } },
-                { "type": "object", "additionalProperties": false, "required": ["op"], "properties": { "op": { "enum": ["playerCount", "random", "timeInState"] } } },
+                { "type": "object", "additionalProperties": false, "required": ["op"], "properties": { "op": { "enum": ["playerCount", "random", "timeInState", "now"] } } },
                 { "type": "object", "additionalProperties": false, "required": ["op", "timer"], "properties": { "op": { "const": "timerRemaining" }, "timer": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "key": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] } } },
-                { "type": "object", "additionalProperties": false, "required": ["op", "list"], "properties": { "op": { "const": "listLength" }, "list": { "type": "string", "pattern": "^(room|self)\\.[A-Za-z][A-Za-z0-9_]{0,31}$" } } },
-                { "type": "object", "additionalProperties": false, "required": ["op", "list", "index"], "properties": { "op": { "const": "listAt" }, "list": { "type": "string", "pattern": "^(room|self)\\.[A-Za-z][A-Za-z0-9_]{0,31}$" }, "index": { "$ref": "#/$defs/expr" } } },
-                { "type": "object", "additionalProperties": false, "required": ["op", "map", "key"], "properties": { "op": { "const": "count" }, "map": { "type": "string", "pattern": "^(room|self)\\.[A-Za-z][A-Za-z0-9_]{0,31}$" }, "key": { "type": "string", "minLength": 1 } } },
-                { "type": "object", "additionalProperties": false, "required": ["op", "min", "max"], "properties": { "op": { "const": "randomPoint" }, "min": { "type": "array", "items": { "type": "number" }, "minItems": 3, "maxItems": 3 }, "max": { "type": "array", "items": { "type": "number" }, "minItems": 3, "maxItems": 3 } }, "description": "Tier 2: a uniformly-random vec3 inside the [min,max] box (each component independent). Server-evaluated each call; vec3-typed. Use for random spawns: respawn to {op:randomPoint,min,max}." }
+                { "type": "object", "additionalProperties": false, "required": ["op", "list"], "properties": { "op": { "const": "listLength" }, "list": { "$ref": "#/$defs/lvalue" } } },
+                { "type": "object", "additionalProperties": false, "required": ["op", "list", "index"], "properties": { "op": { "const": "listAt" }, "list": { "$ref": "#/$defs/lvalue" }, "index": { "$ref": "#/$defs/expr" }, "field": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" } } },
+                { "type": "object", "additionalProperties": false, "required": ["op", "map", "key"], "properties": { "op": { "const": "count" }, "map": { "$ref": "#/$defs/lvalue" }, "key": { "type": "string", "minLength": 1 } } },
+                { "type": "object", "additionalProperties": false, "required": ["op", "list", "as", "where"], "properties": { "op": { "enum": ["listCount", "listIndexOf"] }, "list": { "$ref": "#/$defs/lvalue" }, "as": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "where": { "$ref": "#/$defs/expr" } }, "description": "§5 (P3 Collections ext): a bounded element scan binding `as` to the element. listCount → how many match `where`; listIndexOf → the first matching index, or -1. The `where` reads the bound element (scalar {var:as}, record field {ref:as,var:field}, ref element as a Ref) and can't itself reduce." },
+                { "type": "object", "additionalProperties": false, "required": ["op", "min", "max"], "properties": { "op": { "const": "randomPoint" }, "min": { "type": "array", "items": { "type": "number" }, "minItems": 3, "maxItems": 3 }, "max": { "type": "array", "items": { "type": "number" }, "minItems": 3, "maxItems": 3 } }, "description": "Tier 2: a uniformly-random vec3 inside the [min,max] box (each component independent). Server-evaluated each call; vec3-typed. Use for random spawns: respawn to {op:randomPoint,min,max}." },
+                { "type": "object", "additionalProperties": false, "required": ["op", "entity", "by"], "properties": { "op": { "const": "controlledBy" }, "entity": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] }, "by": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] } }, "description": "§9 (P3 Ownership/A3): true iff `entity`'s controller is the player `by` resolves to — boolean. O(1) field read." },
+                { "type": "object", "additionalProperties": false, "required": ["op", "of"], "properties": { "op": { "const": "hostLoad" }, "of": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] } }, "description": "§9 (P3 Ownership/B8): the count of live entities the player `of` controls (its sim/host load) — number. O(entities)." },
+                { "type": "object", "additionalProperties": false, "required": ["op", "a", "b"], "properties": { "op": { "const": "sameRef" }, "a": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] }, "b": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] } }, "description": "§7.3 (P3-B2): true iff two Refs resolve to the same live member (ref identity); false if either is unset. e.g. self is the turn-order current actor." }
             ]
         },
         "refOp": {
-            "description": "A ref-RETURNING op (spec §7.3): nearestPlayer (nearest to a point) / aggregate argmax|argmin (the member with the max/min field). Its argmax|argmin agg is disjoint from expr's scalar aggs, so it composes into oneOfs without overlap.",
+            "description": "A ref-RETURNING op (spec §7.3/§9): nearestPlayer (nearest to a point) / nearestEntity / aggregate argmax|argmin (the member with the max/min field) / controllerOf (P3: the player controlling an entity). Each has a distinct `op` const, so it composes into oneOfs without overlap (argmax|argmin is also disjoint from expr's scalar aggs).",
             "oneOf": [
                 { "type": "object", "additionalProperties": false, "required": ["op", "from"], "properties": { "op": { "const": "nearestPlayer" }, "from": { "$ref": "#/$defs/expr" } } },
                 { "type": "object", "additionalProperties": false, "required": ["op", "from"], "properties": { "op": { "const": "nearestEntity" }, "from": { "$ref": "#/$defs/expr" }, "kind": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]{0,31}$" } } },
+                { "type": "object", "additionalProperties": false, "required": ["op", "entity"], "properties": { "op": { "const": "controllerOf" }, "entity": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] } } },
+                { "type": "object", "additionalProperties": false, "required": ["op"], "properties": { "op": { "const": "leastLoadedPlayer" }, "where": { "$ref": "#/$defs/expr" }, "as": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" } }, "description": "§9 (P3 Ownership/B8): the connected player controlling the fewest entities (optional where/as filter) — a player ref. O(players)." },
+                { "type": "object", "additionalProperties": false, "required": ["op", "list", "index"], "properties": { "op": { "const": "listAt" }, "list": { "$ref": "#/$defs/lvalue" }, "index": { "$ref": "#/$defs/expr" } }, "description": "§5 (P3-B2 + P3 ext): a `list of ref` element at `index` AS a Ref (list is a room/self path OR {ref,var}) — the turn-order current actor. '' (null) out-of-range. O(1)." },
                 { "type": "object", "additionalProperties": false, "required": ["op", "scope", "agg", "field"], "properties": { "op": { "const": "aggregate" }, "scope": { "type": "string", "pattern": "^(players|zone:[A-Za-z][A-Za-z0-9_]{0,31}|entities:[a-z0-9][a-z0-9-]{0,31})$" }, "agg": { "enum": ["argmax", "argmin"] }, "field": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "where": { "$ref": "#/$defs/expr" }, "as": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" } } }
             ]
         },
@@ -292,15 +359,17 @@
             ]
         },
         "payloadValue": {
-            "description": "A broadcast payload field value (spec §10.3): a value Expr, or a ref-returning op (a Ref serializes to its playerKey on the wire). The two sides don't overlap — refOp's argmax|argmin agg is disjoint from expr's scalar aggs, and nearestPlayer isn't an expr.",
-            "oneOf": [{ "$ref": "#/$defs/expr" }, { "$ref": "#/$defs/refOp" }]
+            "description": "A broadcast payload field value (spec §10.3): a value Expr, or a ref-returning op (a Ref serializes to its playerKey on the wire). anyOf (not oneOf): a field-less `listAt` is structurally valid as BOTH an expr (scalar-list read) and a refOp (ref-list read) — they're disambiguated by the list's declared element type in checkBroadcast/validateExpr, not structurally.",
+            "anyOf": [{ "$ref": "#/$defs/expr" }, { "$ref": "#/$defs/refOp" }]
         },
         "fieldType": {
-            "description": "A field type in an events payload (spec §10.3): the §5 type vocabulary with NO default (the value is rule-computed + sent, never stored). A ref field declares `of`.",
-            "type": "object",
-            "additionalProperties": false,
-            "required": ["type"],
-            "properties": { "type": { "enum": ["number", "string", "boolean", "vec3", "ref"] }, "of": { "type": "string", "pattern": "^(player|entity:[a-z0-9][a-z0-9-]*)$" } }
+            "description": "A field type in an events payload (spec §10.3): the §5 type vocabulary with NO default (the value is rule-computed + sent, never stored). A ref field declares `of`. P3 (B6): a `list`/`counterMap` collection-snapshot field whose value references a matching collection var.",
+            "oneOf": [
+                { "type": "object", "additionalProperties": false, "required": ["type"], "properties": { "type": { "enum": ["number", "string", "boolean", "vec3"] } } },
+                { "type": "object", "additionalProperties": false, "required": ["type"], "properties": { "type": { "const": "ref" }, "of": { "type": "string", "pattern": "^(player|entity:[a-z0-9][a-z0-9-]*)$" } } },
+                { "type": "object", "additionalProperties": false, "required": ["type", "of"], "properties": { "type": { "const": "list" }, "of": { "$ref": "#/$defs/listElem" } } },
+                { "type": "object", "additionalProperties": false, "required": ["type", "keys"], "properties": { "type": { "const": "counterMap" }, "keys": { "type": "array", "items": { "type": "string" }, "minItems": 1, "uniqueItems": true } } }
+            ]
         },
         "eventDecl": {
             "description": "A declared server→client broadcast event (spec §10.3): an optional typed payload (field name -> fieldType).",
@@ -351,7 +420,7 @@
                         { "type": "object", "additionalProperties": false, "required": ["on", "phase"], "properties": { "on": { "enum": ["stateEnter", "stateExit"] }, "phase": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" } } },
                         { "type": "object", "additionalProperties": false, "required": ["on", "timer"], "properties": { "on": { "const": "timerElapsed" }, "timer": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" } } },
                         { "type": "object", "additionalProperties": false, "required": ["on", "kind"], "properties": { "on": { "enum": ["entitySpawn", "entityDestroy", "ownershipChanged"] }, "kind": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]{0,31}$" } } },
-                        { "type": "object", "additionalProperties": false, "required": ["on", "scope", "var", "cmp", "value"], "properties": { "on": { "const": "varReached" }, "scope": { "enum": ["room", "self"] }, "var": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "cmp": { "enum": ["==", "!=", "<", "<=", ">", ">="] }, "value": { "type": ["number", "string", "boolean"] } } }
+                        { "type": "object", "additionalProperties": false, "required": ["on", "scope", "var", "cmp", "value"], "properties": { "on": { "const": "varReached" }, "scope": { "enum": ["room", "self", "entity"] }, "kind": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]{0,31}$" }, "var": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "cmp": { "enum": ["==", "!=", "<", "<=", ">", ">="] }, "value": { "oneOf": [{ "type": ["number", "string", "boolean"] }, { "type": "object", "additionalProperties": false, "required": ["var"], "properties": { "var": { "type": "string", "pattern": "^((room|self)\\.[A-Za-z][A-Za-z0-9_]{0,31}|action\\.args\\.[A-Za-z][A-Za-z0-9_]{0,31})$" } } }, { "$ref": "#/$defs/refLvalue" }] } } }
                     ] },
                 { "type": "object", "required": ["on"], "properties": { "on": { "type": "string", "not": { "enum": ["tick", "playerJoin", "playerLeave", "playerDisconnect", "playerReconnect", "zoneEnter", "zoneExit", "zoneInside", "playerContact", "action", "stateEnter", "stateExit", "timerElapsed", "entitySpawn", "entityDestroy", "ownershipChanged", "varReached"] } } } }
             ]
@@ -366,20 +435,26 @@
                         { "type": "object", "additionalProperties": false, "required": ["do", "target", "to"], "properties": { "do": { "const": "set" }, "target": { "$ref": "#/$defs/lvalue" }, "to": { "$ref": "#/$defs/expr" } } },
                         { "type": "object", "additionalProperties": false, "required": ["do", "target", "to"], "properties": { "do": { "const": "setRef" }, "target": { "$ref": "#/$defs/lvalue" }, "to": { "oneOf": [{ "type": "string" }, { "type": "null" }, { "$ref": "#/$defs/refExpr" }] } } },
                         { "type": "object", "additionalProperties": false, "required": ["do", "player", "to"], "properties": { "do": { "enum": ["teleport", "respawn"] }, "player": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] }, "to": { "$ref": "#/$defs/expr" } } },
-                        { "type": "object", "additionalProperties": false, "required": ["do", "as", "then"], "properties": { "do": { "const": "forEachPlayer" }, "as": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "where": { "$ref": "#/$defs/expr" }, "then": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/ruleEffect" } } } },
+                        { "type": "object", "additionalProperties": false, "required": ["do", "as", "then"], "properties": { "do": { "const": "forEachPlayer" }, "as": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "where": { "$ref": "#/$defs/expr" }, "includeEliminated": { "type": "boolean", "description": "§7.4 (P3-B2): when true, also iterate eliminated (active:false) connected players — for a round reset / announcement. Default false (the active set only)." }, "then": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/ruleEffect" } } } },
                         { "type": "object", "additionalProperties": false, "required": ["do", "kind", "as", "then"], "properties": { "do": { "const": "forEachEntity" }, "kind": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]{0,31}$" }, "as": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "where": { "$ref": "#/$defs/expr" }, "then": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/ruleEffect" } } } },
+                        { "type": "object", "additionalProperties": false, "required": ["do", "list", "as", "then"], "properties": { "do": { "const": "forEachInList" }, "list": { "$ref": "#/$defs/lvalue" }, "as": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "where": { "$ref": "#/$defs/expr" }, "then": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/ruleEffect" } } }, "description": "§5 (P3 Collections ext): the bounded single-level loop over a list's elements — `as` binds the element (a scalar value via {var:as}; a Ref for a ref list; a record element whose fields read via {ref:as,var:field} / write via setField `as`). Can't nest a loop or structurally mutate the list it iterates." },
                         { "type": "object", "additionalProperties": false, "required": ["do", "phase"], "properties": { "do": { "const": "transitionTo" }, "phase": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" } } },
-                        { "type": "object", "additionalProperties": false, "required": ["do", "timer", "seconds"], "properties": { "do": { "const": "startTimer" }, "timer": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "seconds": { "type": "number", "exclusiveMinimum": 0 }, "key": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] } } },
+                        { "type": "object", "additionalProperties": false, "required": ["do", "timer", "seconds"], "properties": { "do": { "const": "startTimer" }, "timer": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "seconds": { "$ref": "#/$defs/expr", "description": "Timer duration in SECONDS — a number Expr (a literal is the degenerate case). A literal below the one-tick floor fails publish; a sub-floor/NaN/∞/negative EXPRESSION result is clamped/skipped at runtime (spec §3.2)." }, "key": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] } } },
                         { "type": "object", "additionalProperties": false, "required": ["do", "timer"], "properties": { "do": { "const": "cancelTimer" }, "timer": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "key": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] } } },
                         { "type": "object", "additionalProperties": false, "required": ["do", "event", "to"], "properties": { "do": { "const": "broadcast" }, "event": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "to": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refOp" }, { "type": "object", "additionalProperties": false, "required": ["team"], "properties": { "team": { "type": "string", "minLength": 3 } } }] }, "payload": { "type": "object", "propertyNames": { "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "additionalProperties": { "$ref": "#/$defs/payloadValue" } } } },
                         { "type": "object", "additionalProperties": false, "required": ["do", "kind", "at"], "properties": { "do": { "const": "spawnEntity" }, "kind": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]{0,31}$" }, "at": { "$ref": "#/$defs/expr" }, "vars": { "type": "object", "propertyNames": { "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "additionalProperties": { "$ref": "#/$defs/payloadValue" } }, "bind": { "const": "spawned" } } },
                         { "type": "object", "additionalProperties": false, "required": ["do", "entity"], "properties": { "do": { "const": "destroyEntity" }, "entity": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] } } },
                         { "type": "object", "additionalProperties": false, "required": ["do", "entity", "to"], "properties": { "do": { "enum": ["requestOwnership", "takeover"] }, "entity": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] }, "to": { "oneOf": [{ "type": "string", "minLength": 1 }, { "type": "null" }, { "$ref": "#/$defs/refExpr" }] } } },
-                        { "type": "object", "additionalProperties": false, "required": ["do", "target", "value"], "properties": { "do": { "const": "append" }, "target": { "type": "string", "pattern": "^(room|self)\\.[A-Za-z][A-Za-z0-9_]{0,31}$" }, "value": { "$ref": "#/$defs/expr" } } },
-                        { "type": "object", "additionalProperties": false, "required": ["do", "target"], "properties": { "do": { "const": "clear" }, "target": { "type": "string", "pattern": "^(room|self)\\.[A-Za-z][A-Za-z0-9_]{0,31}$" } } },
-                        { "type": "object", "additionalProperties": false, "required": ["do", "target", "key", "by"], "properties": { "do": { "const": "addCount" }, "target": { "type": "string", "pattern": "^(room|self)\\.[A-Za-z][A-Za-z0-9_]{0,31}$" }, "key": { "type": "string", "minLength": 1 }, "by": { "$ref": "#/$defs/expr" } } }
+                        { "type": "object", "additionalProperties": false, "required": ["do", "target", "value"], "properties": { "do": { "const": "append" }, "target": { "$ref": "#/$defs/lvalue" }, "value": { "anyOf": [{ "$ref": "#/$defs/payloadValue" }, { "$ref": "#/$defs/recordLiteral" }] } } },
+                        { "type": "object", "additionalProperties": false, "required": ["do", "target"], "properties": { "do": { "const": "clear" }, "target": { "$ref": "#/$defs/lvalue" } } },
+                        { "type": "object", "additionalProperties": false, "required": ["do", "target", "key", "by"], "properties": { "do": { "const": "addCount" }, "target": { "$ref": "#/$defs/lvalue" }, "key": { "type": "string", "minLength": 1 }, "by": { "$ref": "#/$defs/expr" } } },
+                        { "type": "object", "additionalProperties": false, "required": ["do", "target", "index"], "properties": { "do": { "const": "removeAt" }, "target": { "$ref": "#/$defs/lvalue" }, "index": { "$ref": "#/$defs/expr" } }, "description": "P3 Collections: remove the element at `index` from a list (shift down); out-of-range = no-op." },
+                        { "type": "object", "additionalProperties": false, "required": ["do", "target", "as", "where"], "properties": { "do": { "const": "removeWhere" }, "target": { "$ref": "#/$defs/lvalue" }, "as": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "where": { "$ref": "#/$defs/expr" } }, "description": "§5 (P3 Collections ext): remove ALL elements of a list matching `where` (a bounded scan binding `as` to the element). The scan-and-remove verb the iterated-list-mutation ban points to." },
+                        { "type": "object", "additionalProperties": false, "required": ["do", "field", "to"], "properties": { "do": { "const": "setField" }, "target": { "$ref": "#/$defs/lvalue" }, "index": { "$ref": "#/$defs/expr" }, "as": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "field": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9_]{0,31}$" }, "to": { "$ref": "#/$defs/payloadValue" } }, "description": "P3 Collections: write a record-list element's `field` — addressed by `index` into `target`, OR by a record element `as` bound by an enclosing forEachInList (§5 P3 ext)." },
+                        { "type": "object", "additionalProperties": false, "required": ["do", "order", "index"], "properties": { "do": { "const": "advanceTurn" }, "order": { "$ref": "#/$defs/lvalue" }, "index": { "$ref": "#/$defs/lvalue" } }, "description": "§7.4 (P3-B2): advance a turn `index` (a number var) over an `order` (`list of ref:player`) to the next active member — wraps + skips eliminated/disconnected. No-op if no other active member exists." },
+                        { "type": "object", "additionalProperties": false, "required": ["do", "player"], "properties": { "do": { "enum": ["eliminate", "revive"] }, "player": { "oneOf": [{ "type": "string", "minLength": 1 }, { "$ref": "#/$defs/refExpr" }] } }, "description": "§7.4 (P3-B2): toggle a player's reserved `active` flag. eliminate removes a still-connected player from the gameplay active set (a spectator — still rendered + reachable by broadcast); revive restores it." }
                     ] },
-                { "type": "object", "required": ["do"], "properties": { "do": { "type": "string", "not": { "enum": ["add", "set", "setRef", "teleport", "respawn", "forEachPlayer", "forEachEntity", "broadcast", "transitionTo", "startTimer", "cancelTimer", "spawnEntity", "destroyEntity", "requestOwnership", "takeover", "append", "clear", "addCount"] } } } }
+                { "type": "object", "required": ["do"], "properties": { "do": { "type": "string", "not": { "enum": ["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"] } } } }
             ]
         }
     }

package/dist/src/index.d.ts

@@ -51,12 +51,40 @@ export type HelixVarType = {
     default?: null;
 } | {
     type: 'list';
-    of: 'number' | 'string' | 'boolean';
+    of: HelixListElem;
     maxLen: number;
 } | {
     type: 'counterMap';
     keys: string[];
 };
+export type HelixRecordField = {
+    type: 'number';
+    default?: number;
+    min?: number;
+    max?: number;
+    integer?: boolean;
+} | {
+    type: 'string';
+    default?: string;
+    maxLen?: number;
+    enum?: string[];
+} | {
+    type: 'boolean';
+    default?: boolean;
+} | {
+    type: 'vec3';
+    default?: [number, number, number];
+} | {
+    type: 'ref';
+    of: 'player' | `entity:${string}`;
+};
+export type HelixListElem = 'number' | 'string' | 'boolean' | {
+    type: 'ref';
+    of: 'player' | `entity:${string}`;
+} | {
+    type: 'record';
+    fields: Record<string, HelixRecordField>;
+};
 /** A declared bag of custom vars: name -> type. Names are identifiers (see the v0.3 schema pattern). */
 export type HelixVarDecls = Record<string, HelixVarType>;
 /** v0.3 (Tier 2 Phase 1.3): the per-world DECLARED state — room-level + per-player custom vars. */
@@ -96,10 +124,17 @@ export type HelixRuleEvent = {
     kind: string;
 } | {
     on: 'varReached';
-    scope: 'room' | 'self';
+    scope: 'room' | 'self' | 'entity';
+    kind?: string;
     var: string;
     cmp: '==' | '!=' | '<' | '<=' | '>' | '>=';
-    value: number | string | boolean;
+    value: VarReachedThreshold;
+};
+export type VarReachedThreshold = number | string | boolean | {
+    var: string;
+} | {
+    ref: HelixRef;
+    var: string;
 };
 export type HelixExpr = number | string | boolean | {
     vec3: [number, number, number];
@@ -139,19 +174,43 @@ export type HelixExpr = number | string | boolean | {
     key?: HelixRef;
 } | {
     op: 'listLength';
-    list: string;
+    list: HelixLvalue;
 } | {
     op: 'listAt';
-    list: string;
+    list: HelixLvalue;
     index: HelixExpr;
+    field?: string;
 } | {
     op: 'count';
-    map: string;
+    map: HelixLvalue;
     key: string;
+} | {
+    op: 'listCount';
+    list: HelixLvalue;
+    as: string;
+    where: HelixExpr;
+} | {
+    op: 'listIndexOf';
+    list: HelixLvalue;
+    as: string;
+    where: HelixExpr;
 } | {
     op: 'randomPoint';
     min: [number, number, number];
     max: [number, number, number];
+} | {
+    op: 'controlledBy';
+    entity: HelixRef;
+    by: HelixRef;
+} | {
+    op: 'sameRef';
+    a: HelixRef;
+    b: HelixRef;
+} | {
+    op: 'hostLoad';
+    of: HelixRef;
+} | {
+    op: 'now';
 } | {
     op: 'playerCount' | 'random' | 'timeInState';
 };
@@ -164,6 +223,17 @@ export type HelixRef = string | {
     op: 'nearestEntity';
     from: HelixExpr;
     kind?: string;
+} | {
+    op: 'controllerOf';
+    entity: HelixRef;
+} | {
+    op: 'leastLoadedPlayer';
+    where?: HelixExpr;
+    as?: string;
+} | {
+    op: 'listAt';
+    list: HelixLvalue;
+    index: HelixExpr;
 } | {
     op: 'aggregate';
     scope: 'players' | `zone:${string}` | `entities:${string}`;
@@ -179,6 +249,7 @@ export type HelixLvalue = string | {
 export type HelixBroadcastTarget = 'all' | HelixRef | {
     team: string;
 };
+export type HelixRecordLiteral = Record<string, HelixExpr | HelixRef>;
 export type HelixRuleEffect = {
     do: 'add';
     target: HelixLvalue;
@@ -199,6 +270,7 @@ export type HelixRuleEffect = {
     do: 'forEachPlayer';
     as: string;
     where?: HelixExpr;
+    includeEliminated?: boolean;
     then: HelixRuleEffect[];
 } | {
     do: 'forEachEntity';
@@ -206,13 +278,19 @@ export type HelixRuleEffect = {
     as: string;
     where?: HelixExpr;
     then: HelixRuleEffect[];
+} | {
+    do: 'forEachInList';
+    list: HelixLvalue;
+    as: string;
+    where?: HelixExpr;
+    then: HelixRuleEffect[];
 } | {
     do: 'transitionTo';
     phase: string;
 } | {
     do: 'startTimer';
     timer: string;
-    seconds: number;
+    seconds: HelixExpr;
     key?: HelixRef;
 } | {
     do: 'cancelTimer';
@@ -238,16 +316,39 @@ export type HelixRuleEffect = {
     to: HelixRef | null;
 } | {
     do: 'append';
-    target: string;
-    value: HelixExpr;
+    target: HelixLvalue;
+    value: HelixExpr | HelixRef | HelixRecordLiteral;
 } | {
     do: 'clear';
-    target: string;
+    target: HelixLvalue;
 } | {
     do: 'addCount';
-    target: string;
+    target: HelixLvalue;
     key: string;
     by: HelixExpr;
+} | {
+    do: 'removeAt';
+    target: HelixLvalue;
+    index: HelixExpr;
+} | {
+    do: 'removeWhere';
+    target: HelixLvalue;
+    as: string;
+    where: HelixExpr;
+} | {
+    do: 'setField';
+    target?: HelixLvalue;
+    index?: HelixExpr;
+    as?: string;
+    field: string;
+    to: HelixExpr | HelixRef;
+} | {
+    do: 'advanceTurn';
+    order: HelixLvalue;
+    index: HelixLvalue;
+} | {
+    do: 'eliminate' | 'revive';
+    player: HelixRef;
 };
 export type HelixRule = {
     when: HelixRuleEvent;
@@ -266,8 +367,16 @@ export type HelixTimer = {
     keyed?: 'player' | `entity:${string}`;
 };
 export type HelixFieldType = {
-    type: HelixVarType['type'];
-    of?: 'player' | `entity:${string}`;
+    type: 'number' | 'string' | 'boolean' | 'vec3';
+} | {
+    type: 'ref';
+    of: 'player' | `entity:${string}`;
+} | {
+    type: 'list';
+    of: HelixListElem;
+} | {
+    type: 'counterMap';
+    keys: string[];
 };
 export type HelixEventDecl = {
     payload?: Record<string, HelixFieldType>;
@@ -326,6 +435,30 @@ export type HelixEntityMotion = {
     target: string;
     speed: number;
 };
+export type HelixEntityPhysics = {
+    bodyType: 'dynamic';
+    shape: {
+        type: 'sphere';
+        radius: number;
+    } | {
+        type: 'box';
+        halfExtents: [number, number, number];
+    } | {
+        type: 'capsule';
+        halfHeight: number;
+        radius: number;
+    };
+    mass?: number;
+    restitution?: number;
+    friction?: number;
+    linearDamping?: number;
+    angularDamping?: number;
+    maxAngularSpeed?: number;
+    collidesWith?: string[];
+    claimOnContact?: boolean;
+    revertOnRest?: boolean;
+    dualSimOnContact?: boolean;
+};
 export type HelixAttachedZone = {
     offset?: [number, number, number];
     tracks?: 'players' | `entity:${string}`;
@@ -348,6 +481,8 @@ export type HelixEntity = {
     idleTimeout?: number;
     ownerLifecycle?: 'despawnWithOwner' | 'persist' | 'migrateToServer' | 'hostMigrate';
     transferPolicy?: 'fixed' | 'request' | 'takeover';
+    physics?: HelixEntityPhysics;
+    rejoinOnRelease?: 'nearestPoint' | 'timeIndex' | 'seekBack';
 };
 export type HelixMultiplayerConfig = {
     /** Advisory interest radius in meters (drives later StateView interest management; may be ignored in v1). */
@@ -358,6 +493,13 @@ export type HelixMultiplayerConfig = {
      * solo player would be soft-locked. Set ≥ 2 to declare a genuinely multiplayer-only world (the gate stands down).
      */
     minPlayers?: number;
+    /**
+     * Client→server state upload rate tier: 10 (default) or 20 Hz. Raises BOTH the player-seat `state` channel and
+     * hosted-entity batch uploads together. 20 Hz ⇒ maxPlayers must be ≤ MULTIPLAYER_CAPS.maxPlayersAt20Hz (12) — the
+     * ~2× upstream cost is bounded by the player cap. Absent ⇒ 10 (normalized via the schema default). The platform
+     * still owns the SIM/patch rate (20 Hz); this is only the upstream cadence.
+     */
+    uploadHz?: 10 | 20;
     /** Server owns authoritative state + validates inputs (Tier 1). Defaulted to true; leave it true in v1. */
     authoritative?: boolean;
     /** Declared per-world custom state (roomVars + per-player vars); the room realizes + interprets it. */
@@ -414,6 +556,14 @@ export type ManifestValidationResult = {
 };
 export declare const PLATFORM_MAX_PLAYERS_PER_ROOM = 24;
 export declare const 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. */
+    readonly uploadHzAllowed: readonly [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. */
+    readonly maxPlayersAt20Hz: 12;
     /** Declared room-level vars. */
     readonly roomVars: 64;
     /** Declared per-player vars (these are realized once PER PLAYER at runtime, so the effective cost scales). */
@@ -426,6 +576,8 @@ export declare const MULTIPLAYER_CAPS: {
     readonly listMaxLen: 256;
     /** Keys in a `counterMap` collection var's declared key enum (4.5.13). */
     readonly counterKeys: 64;
+    /** Fields in a `list` of `record` element (P3 Collections — bounds one synced record's flat scalar fields). */
+    readonly recordFields: 8;
     /** Declared behavior rules (Tier 2 Phase 2). */
     readonly rules: 128;
     /** Effects in a single rule's `then`. */
@@ -467,6 +619,10 @@ export declare const MULTIPLAYER_CAPS: {
     /** 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). */
     readonly 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). */
+    readonly 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. */
     readonly zoneMaxExtent: 10000;