@hypersoniclabs/helix-cli 0.1.7 → 0.1.24-helix3.438

package/vendor/README.md

@@ -0,0 +1,63 @@
+# vendor/ — generated artifacts, do not edit by hand
+
+Files here are produced elsewhere and copied in so the standalone CLI works with no engine checkout and no
+installed asset pack. Same reasoning as `src/character/canonicalSkeletonData.ts`.
+
+| File | Produced by | Purpose |
+|---|---|---|
+| `capture-body.glb` | `helix-web-engine-new/tools/character-pipeline` → `export-capture-body-cli` | the default character's body, for `helix gesture shot` |
+| `capture-face.glb` | same | the default character's head/face — the body GLB has none |
+| `ability-manifest.mjs` | the ability-v1 contract module | bundle validation |
+| `installed-index.mjs` | the installed-index schema | `installed.json` validation |
+| `vehicle-package-v2.mjs` | `scripts/vendor-vehicle-package-v2.mjs` from the engine's `vehicle/package/format.ts` module graph at the commit pinned in that script | dependency-free canonical validator and publish gate, the socket-name resolver, plus a separately exported Bridge JSON/schema preflight. Used by `helix vehicle validate` and (as a byte-identical mirror in `plugins/beamng-vehicle/vendor/`) the BeamNG plugin; the validated Vehicle Package must be sealed before `helix continuum make-item` can offer it |
+
+The Vehicle Package validator is reproducible rather than merely protected by a checksum. `format.ts` is not one
+file: it imports the specialty-manifest validator, the land solver's authoring checks, the seat-declaration resolver,
+the suspension-source checks and more (about 11k lines, no npm dependencies). The vendoring script therefore bundles
+the whole module graph reachable from its entry points: `git show <commit>:<path>` for each file, a deterministic
+TypeScript CommonJS transpile, and a tiny module registry in one `.mjs`. Every source file's SHA-256 is embedded in
+`VEHICLE_PACKAGE_V2_SOURCE.files`, the aggregate is pinned in the script (`PIN.closureSha256`), and `--check`
+regenerates the artifact from the named commit and fails on any byte of drift. The Bridge JSON/schema preflight is
+generated separately and is not allowed to masquerade as an engine validation rule.
+
+Run the full provenance and parity check against any engine clone containing the pinned commit:
+
+```sh
+node scripts/vendor-vehicle-package-v2.mjs \
+  --engine-root /path/to/helix-web-engine-new \
+  --check
+```
+
+To move the pin: change `PIN.commit`, run `--write` (it prints the new closure digest in its error), paste that into
+`PIN.closureSha256`, run `--write` again, then update the pinned values in
+`src/bridge/bridge.vehicle-package-validator.spec.ts` and review the diff. `--write` mirrors the artifact into the
+BeamNG plugin. The script refuses working-tree substitutions because its inputs always come from the named commit.
+
+## The capture GLBs
+
+`helix gesture shot` always renders the **default** character. A gesture clip replicates by NAME and plays on
+whatever body each player has, so a pose is authored against the canonical body every custom character is
+conformed to — and the one the runtime falls back to when an avatar fails to load. The sheet is a reference
+render against that contract, not a preview of any particular player's view.
+
+Each is scene 0 (the highest LOD) with every texture dropped and materials flattened to grey. That removes the
+`KHR_texture_basisu` requirement, so the browser needs no KTX2 transcoder; it keeps the files small; and an
+untextured body reads *better* for judging a pose than a textured one.
+
+They stay **two files** because body and face carry separate skeletons with different skin joint counts (the
+body's full 77-node tree vs the face's 16-node `root → spine → neck → head` chain), so they cannot share one
+skin. The capture page poses each by bone name instead, which is what keeps the head following spine and neck
+keys.
+
+Regenerate only when the default character itself changes:
+
+```
+cd helix-web-engine-new/tools/character-pipeline
+npx tsx src/export-capture-body-cli.ts \
+  --body ../../asset-packs/humanoid-character/body-m-default.web.glb \
+  --face ../../asset-packs/humanoid-character/face-m-default.web.glb \
+  -o ../../../helix-creator-cli/vendor
+```
+
+The generator fails loudly if an output still declares a required glTF extension, since the browser could not
+then load it.

package/vendor/ability-manifest.mjs

@@ -1,4 +1,4 @@
-// @helix/humanoid-character@0.2.2 — ability.json validator (frozen C3 contract).
+// @helix/humanoid-character@0.3.0 — ability.json validator (frozen C3 contract).
 // Generated by emit-schemas; vendored by @hypersoniclabs/helix-cli. Do not edit; changes require ability-v2.
 
 // src/core/config/paths.ts
@@ -34,6 +34,514 @@ function nearestKey(key, candidates) {
   return best !== void 0 && bestDist <= Math.max(2, Math.floor(key.length * 0.4)) ? best : void 0;
 }
 
+// src/core/input/gamepadStandard.ts
+var StandardButton = {
+  faceDown: 0,
+  faceRight: 1,
+  faceLeft: 2,
+  faceUp: 3,
+  bumperL: 4,
+  bumperR: 5,
+  triggerL: 6,
+  triggerR: 7,
+  select: 8,
+  start: 9,
+  stickL: 10,
+  stickR: 11,
+  dpadUp: 12,
+  dpadDown: 13,
+  dpadLeft: 14,
+  dpadRight: 15
+};
+var StandardAxis = {
+  leftStick: [0, 1],
+  rightStick: [2, 3]
+};
+var BUTTON_NAMES = Object.keys(StandardButton);
+var AXIS_NAMES = Object.keys(StandardAxis);
+
+// src/core/input/xrInputChannels.ts
+var HUMANOID_XR_INPUT = Object.freeze({
+  leftStick: "xr.left-stick",
+  rightStick: "xr.right-stick",
+  leftPrimary: "xr.left-primary",
+  leftSecondary: "xr.left-secondary",
+  rightPrimary: "xr.right-primary",
+  rightSecondary: "xr.right-secondary",
+  leftTrigger: "xr.left-trigger",
+  rightTrigger: "xr.right-trigger",
+  leftGrip: "xr.left-grip",
+  rightGrip: "xr.right-grip",
+  leftStickClick: "xr.left-stick-click",
+  rightStickClick: "xr.right-stick-click"
+});
+var HUMANOID_XR_INPUT_AXES = Object.freeze([
+  HUMANOID_XR_INPUT.leftStick,
+  HUMANOID_XR_INPUT.rightStick
+]);
+var HUMANOID_XR_INPUT_BUTTONS = Object.freeze([
+  HUMANOID_XR_INPUT.leftPrimary,
+  HUMANOID_XR_INPUT.leftSecondary,
+  HUMANOID_XR_INPUT.rightPrimary,
+  HUMANOID_XR_INPUT.rightSecondary,
+  HUMANOID_XR_INPUT.leftTrigger,
+  HUMANOID_XR_INPUT.rightTrigger,
+  HUMANOID_XR_INPUT.leftGrip,
+  HUMANOID_XR_INPUT.rightGrip,
+  HUMANOID_XR_INPUT.leftStickClick,
+  HUMANOID_XR_INPUT.rightStickClick
+]);
+var HUMANOID_XR_INPUT_CHANNELS = Object.freeze([
+  ...HUMANOID_XR_INPUT_AXES,
+  ...HUMANOID_XR_INPUT_BUTTONS
+]);
+
+// src/core/input/standardActions.ts
+var XR_TURN_ACTION_ID = "xrTurn";
+var HELIX_OS_ACTION_ID = "helixOs";
+var STANDARD_ACTIONS = [
+  // ---- character / gameplay ----
+  {
+    id: "move",
+    kind: "vec2",
+    domain: "character",
+    context: "gameplay",
+    bindings: { composite: { up: ["KeyW"], down: ["KeyS"], left: ["KeyA"], right: ["KeyD"] }, stick: "leftStick", sourceAxis: HUMANOID_XR_INPUT.leftStick },
+    label: "Move",
+    description: "Planar movement (vec2; WASD composite or left stick)",
+    touch: "stick"
+  },
+  {
+    id: "look",
+    kind: "vec2",
+    domain: "character",
+    context: "gameplay",
+    bindings: { stick: "rightStick" },
+    label: "Look",
+    description: "Camera look (pointer delta or right stick). Pointer lock auto-acquires on the camera toggle and re-acquires on a canvas click, in both camera modes (Esc releases); touch uses unlocked drag",
+    touch: "drag"
+  },
+  {
+    id: XR_TURN_ACTION_ID,
+    kind: "vec2",
+    domain: "character",
+    context: "gameplay",
+    bindings: { sourceAxis: HUMANOID_XR_INPUT.rightStick, deadzone: 0.15 },
+    label: "VR turn",
+    description: "VR-only comfort turn intent from the right tracked-controller stick",
+    touch: "none"
+  },
+  {
+    id: "jump",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["Space"], pad: "faceDown", sourceButtons: [HUMANOID_XR_INPUT.rightPrimary] },
+    label: "Jump",
+    description: "Jump (when grounded)",
+    touch: "button"
+  },
+  {
+    id: "sprint",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["ShiftLeft", "ShiftRight"], pad: "stickL", sourceButtons: [HUMANOID_XR_INPUT.leftStickClick] },
+    label: "Sprint",
+    description: "Sprint-tier speed while held (touch: auto by stick magnitude)",
+    touch: "none"
+  },
+  {
+    // AltLeft is the browser-safe primary (Ctrl+W closes the tab and cannot be prevented);
+    // Ctrl stays bound for fullscreen/wrapped builds where the genre convention applies.
+    id: "walk",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["AltLeft", "ControlLeft", "ControlRight"] },
+    label: "Walk",
+    description: "Force walk-tier speed while held",
+    touch: "none"
+  },
+  {
+    id: "crouch",
+    kind: "toggle",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["KeyC"], pad: "faceRight", sourceButtons: [HUMANOID_XR_INPUT.rightStickClick] },
+    label: "Crouch",
+    description: "Toggle crouch",
+    touch: "button"
+  },
+  {
+    id: "primary",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { mouseButtons: [0], pad: "triggerR", sourceButtons: [HUMANOID_XR_INPUT.rightTrigger] },
+    label: "Primary",
+    description: "Primary use/fire (abilities bind this instead of minting a private fire action)",
+    touch: "button"
+  },
+  {
+    id: "secondary",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { mouseButtons: [2], pad: "triggerL", sourceButtons: [HUMANOID_XR_INPUT.leftTrigger] },
+    label: "Aim / secondary",
+    description: "Secondary use \u2014 the character system will drive aim-down-sights from this id",
+    touch: "button"
+  },
+  {
+    id: "interact",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["KeyE"], pad: "faceLeft", sourceButtons: [HUMANOID_XR_INPUT.leftPrimary] },
+    label: "Interact",
+    description: "Contextual world interaction (doors, pickups, NPCs)",
+    touch: "button"
+  },
+  {
+    id: "reload",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["KeyR"], pad: "faceUp" },
+    label: "Reload",
+    description: "Reload / secondary contextual action",
+    touch: "button"
+  },
+  // Direct slot select is keyboard-only (digits); the gamepad cycles via equipPrev/equipNext instead.
+  ...Array.from({ length: 9 }, (_, i) => ({
+    id: `ability${i + 1}`,
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: [`Digit${i + 1}`] },
+    label: `Ability ${i + 1}`,
+    description: `Ability/item slot ${i + 1} (direct select; pad players cycle with equipPrev/equipNext)`,
+    touch: "radial"
+  })),
+  {
+    id: "equipNext",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["BracketRight"], pad: "bumperR" },
+    label: "Next equip",
+    description: "Cycle the active ability/equip slot forward (1-9). Slot state is game-side \u2014 worlds/abilities consume this",
+    touch: "none"
+  },
+  {
+    id: "equipPrev",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["BracketLeft"], pad: "bumperL" },
+    label: "Previous equip",
+    description: "Cycle the active ability/equip slot back (1-9). Slot state is game-side \u2014 worlds/abilities consume this",
+    touch: "none"
+  },
+  {
+    id: "melee",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["KeyV"], pad: "stickR" },
+    label: "Melee",
+    description: "Melee strike. No built-in behavior \u2014 worlds/abilities consume it",
+    touch: "button"
+  },
+  {
+    id: "emote",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["KeyG"], pad: "dpadDown" },
+    label: "Emote",
+    description: "Carried emotes: TAP to replay the last one played (the first equipped slot until then), HOLD to open the radial wheel \u2014 steer with the cursor or the right stick, release over a petal to play it, release in the middle to cancel",
+    touch: "button"
+  },
+  {
+    id: "point",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["KeyB"] },
+    label: "Point",
+    description: "Hold to point the right index finger along the camera direction (native humanoid gesture)",
+    touch: "hold"
+  },
+  {
+    // KeyF was the one genuinely free letter left in the gameplay context when this was written: not in
+    // RESERVED_KEYS (Escape/KeyN/Backquote), claimed by no standard action — the neighbours a camera would
+    // collide with are all taken elsewhere (E interact, R reload, C crouch, V melee, G emote, B point,
+    // T camera, M map, I inventory). No pad binding: every
+    // unchorded face button, bumper, trigger, stick and d-pad direction is already claimed, and dpadUp is
+    // the world-custom slot no standard action may take (layout v2).
+    id: "shutter",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["KeyF"] },
+    label: "Shutter",
+    description: "Take the photo (or start/stop the clip) while the avatar camera is open; also cancels a running self-timer",
+    touch: "button"
+  },
+  {
+    // KeyX — and the ROUND TRIP that brought it back here is the point, not a footnote. The
+    // reasoning that moved it OFF KeyX is kept below in full: it was considered, it was correct
+    // about the danger, and it was overruled on a different axis. Do not read this as a key that
+    // was never argued about.
+    //
+    // ── WHY IT LEFT KeyX (the original record, unedited in substance) ──
+    // This shipped first on KeyX, where `multiplayer-turn-arena` registers `world.surrender`, so
+    // inspecting an opponent also forfeited the match. It then moved to Backslash, chosen because
+    // every letter A-Z was claimed somewhere in this repo. Backslash was a defensible answer to the
+    // wrong question: what made a shared key dangerous was that it was SILENT, and `conflicts()`
+    // reports one at registration now. Once a collision is detectable it is a migration task, not a
+    // blocker — so the right move is to take a good key and move the few things in its way, rather
+    // than exile a headline social action to punctuation nobody will reach for.
+    //
+    // It then moved to KeyZ, measured across the shipped world templates as the lightest claim on
+    // the board and the only candidate displacing NO registered world action at all: its three uses
+    // were the same manual ragdoll toggle (`multiplayer-ragdoll-pad`, and the debug chains in the
+    // two shooter templates), all raw keydown handlers, none of them destructive or match-affecting.
+    // They sit on Equal, and THAT migration still stands — nothing has moved back onto Z.
+    // KeyU/KeyY/KeyO each had a real `registerAction` in `multiplayer-props`.
+    //
+    // ── WHY IT IS BACK ON KeyX (2026-08-20, on Jack's instruction, asked for twice) ──
+    // The KeyZ reasoning was right about the collision and wrong about the axis. It optimised for
+    // "which key is cheapest to take", when the binding a player already has in their fingers is
+    // worth more than the migration it costs. Everything else in this ecosystem that means x-ray is
+    // already on X: `hyperspace-online` binds `KeyX` keydown/keyup directly to its hold-to-scan and
+    // release-to-showroom flow (`src/game/app.js`), and the Homes runtime renders whatever this
+    // table says via `input.hint('xray')` — so the platform default is the only thing that was
+    // disagreeing with the rest of the ecosystem.
+    //
+    // Vacating Z also settles a live conflict rather than creating one: the Homes editor binds
+    // `KeyF`/`KeyZ` to zoom-to-selected-item, Unreal-editor style (`HomeWorld.ts`), on a raw window
+    // keydown that this table's `conflicts()` could never have seen.
+    //
+    // Creators can override any of this. What the platform default owes them is agreement with what
+    // the rest of the ecosystem already teaches.
+    //
+    // ── THE X COLLISION WAS PAID, NOT WAVED THROUGH ──
+    //   • `multiplayer-turn-arena`'s `world.surrender` — the one real registered action on KeyX and
+    //     the original bug — moved to `Minus`. Nothing else in the standard table, RESERVED_KEYS or
+    //     any shipped template reads Minus, and an irreversible forfeit is better on a deliberate
+    //     reach than under the movement hand.
+    //   • The `tune` debug toggles in `multiplayer-shooter-capstone` / `multiplayer-shooter-range`
+    //     read `e.code === 'KeyX'` off a raw, ungated `window` keydown chain, which
+    //     `InputService.conflicts()` cannot see AT ALL. They are creator-editable debug affordances,
+    //     not registered actions, so they are left where they are and RECORDED as accepted in
+    //     `worldTemplateBindings.test.ts`'s equality-asserted baseline — visible debt, not silence.
+    // `worldTemplateBindings.test.ts` asserts no shipped template REGISTERS this key again.
+    //
+    // KeyZ is now free, and deliberately left free: it is the first unclaimed letter since that
+    // table was audited, and the `addons` note below is what has been waiting for one. The
+    // "no free LETTER left" test records Z by equality so the option cannot go unnoticed again.
+    //
+    // Ergonomically X keeps what Z had: bottom-left, under the WASD hand, so it can be HELD while
+    // moving and looking — which Backslash could not.
+    //
+    // Pad: `modifier + bumperL` is the chord slot this file documents as platform-reserved (see the
+    // header) and nothing has claimed it — every unchorded face/bumper/trigger/stick/d-pad direction
+    // is taken, and dpadUp belongs to worlds.
+    id: "xray",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["KeyX"], sourceButtons: [HUMANOID_XR_INPUT.leftSecondary], withModifier: { pad: "bumperL" } },
+    label: "X-ray",
+    description: "Hold to scan whatever is under the reticle \u2014 a player, a placed item or a vehicle \u2014 and show its instance details. Native: available in every world, on every character, with no world code",
+    touch: "hold"
+  },
+  {
+    id: HELIX_OS_ACTION_ID,
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { sourceButtons: [HUMANOID_XR_INPUT.rightSecondary] },
+    label: "Helix OS",
+    description: "Open or close Helix OS from a tracked controller; the shell owns the panel",
+    touch: "none"
+  },
+  {
+    // ── THERE WAS NO FREE LETTER LEFT WHEN THIS WAS CHOSEN — AND AS OF 2026-08-20 THERE IS ONE ──────────
+    // The design doc proposed KeyH or KeyU. Both are taken — not by this table, but by the SHIPPED WORLD
+    // TEMPLATES, which is the half a reading of `standardActions.ts` alone cannot see: KeyH is a registered
+    // world action in eight of them (`world.speedBoost`, `world.joinBlue`, `world.discard`, `world.sway`,
+    // `world.donate`, `world.torch`, …) and KeyU in three. When Backslash was picked, auditing all 40
+    // templates against the standard table left NO unclaimed letter at all.
+    //
+    // THAT IS NO LONGER TRUE, and this note is the thing that has been waiting for it: moving `xray` back
+    // to KeyX (see above) vacated KeyZ, and nothing claims it. The current census is
+    // A/B/C/D/E/F/G/I/M/N/Q/R/S/T/V/W/X standard or reserved, H/J/K/L/O/P/U/Y template-registered,
+    // and **Z FREE**. Moving the add-on menu onto KeyZ is now a live option for the layout owner — it is
+    // deliberately NOT taken here, because that is a layout decision and not a side effect of an x-ray
+    // rebind. `worldTemplateBindings.test.ts` asserts the free-letter list by EQUALITY, so Z cannot quietly
+    // get consumed by the next thing that wants a key.
+    //
+    // The collision baseline in that same test is also asserted by EQUALITY, so taking a TEMPLATE-held
+    // letter would not merely double-fire — it would fail that test until somebody widened the baseline,
+    // which is precisely what the baseline exists to prevent.
+    //
+    // Of the three codes that audited clean when this was chosen — Backslash, Slash, Minus — Slash is
+    // Firefox's quick-find accelerator and the de-facto "search" key in web pages (worlds run in a page),
+    // and Minus sat beside Equal, which two templates already read raw for a dev toggle, so a mis-hit lands
+    // on a surprise. Backslash is adjacent to neither and is claimed by nothing anywhere. (Minus is no
+    // longer even a candidate: `multiplayer-turn-arena`'s `world.surrender` moved onto it in the KeyX
+    // migration above.)
+    //
+    // It is a PLACEHOLDER the layout owner may move, and moving it costs nothing: being in this table is what
+    // buys rebinding, the settings entry, the generated touch widget and discovery through describeSystem().
+    //
+    // Pad: NO DEFAULT. Every face button, bumper, trigger, stick and d-pad direction is claimed; dpadUp is the
+    // world-custom slot no standard action may take (layout v2); and all three documented modifier chords are
+    // now spent (rightStick→zoom, bumperR→voicePTT, bumperL→xray). Pad players reach it through the
+    // pause/system menu, or rebind, until layout v3 allocates a slot.
+    id: "addons",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["Backslash"] },
+    label: "Add-ons",
+    description: "Open the add-on menu for whatever you are sitting in or wearing \u2014 every add-on that fits it, owned or not, filtered by category, equipped and unequipped from the grid. Native: available in every world",
+    touch: "button"
+  },
+  {
+    id: "zoom",
+    kind: "delta",
+    domain: "character",
+    context: "gameplay",
+    bindings: { wheel: "y", deltaRate: 1200, withModifier: { stick: "rightStick" } },
+    label: "Zoom",
+    description: "Camera zoom delta (wheel px; pinch on touch; hold modifier + right stick on pad \u2014 forward zooms in). Positive = zoom out",
+    touch: "pinch"
+  },
+  {
+    id: "modifier",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { pad: "dpadRight" },
+    label: "Modifier",
+    description: "Held chord layer: while down, withModifier bindings resolve (zoom on the right stick) and their sources go quiet for their normal owners",
+    touch: "none"
+  },
+  {
+    id: "cameraMode",
+    kind: "button",
+    domain: "character",
+    context: "gameplay",
+    bindings: { keys: ["KeyT"], pad: "dpadLeft" },
+    label: "Camera",
+    description: "Cycle the camera: first-person \u2192 third-person \u2192 shoulder right \u2192 shoulder left. allowModeToggle gates the FP\u2194TP legs, allowShoulderSwap the shoulder legs; all-gated = inert",
+    touch: "button"
+  },
+  // ---- world / system (worlds opt in via registerStandardActions) ----
+  {
+    // Not Escape — the SDK owns Escape (tablet overlay) and pointer-lock exit rides it at browser level.
+    id: "pause",
+    kind: "button",
+    domain: "world",
+    context: "gameplay",
+    bindings: { keys: ["Pause"], pad: "start" },
+    label: "Pause",
+    description: "Open the pause/system menu",
+    touch: "button"
+  },
+  {
+    id: "inventory",
+    kind: "button",
+    domain: "world",
+    context: "gameplay",
+    bindings: { keys: ["Tab", "KeyI"], pad: "select" },
+    label: "Inventory",
+    description: "Open the inventory (worlds push the menu context)",
+    touch: "button"
+  },
+  {
+    id: "map",
+    kind: "button",
+    domain: "world",
+    context: "gameplay",
+    bindings: { keys: ["KeyM"] },
+    label: "Map",
+    description: "Toggle the map/overview",
+    touch: "button"
+  },
+  {
+    // Keyboard PTT stays SDK-side (the reserved KeyN / pttKey listener — pointer-lock focus lives in
+    // the iframe); this action is the pad/touch leg. attachVoice registers it and forwards to setPttDown.
+    id: "voicePTT",
+    kind: "button",
+    domain: "world",
+    context: "global",
+    bindings: { withModifier: { pad: "bumperR" } },
+    label: "Push to talk",
+    description: "Hold to talk in PTT voice mode (modifier + right bumper on pad; keyboard uses the SDK pttKey, default N). Global context \u2014 keeps working under menus. Auto-registered when the world attaches voice",
+    touch: "hold"
+  },
+  {
+    id: "confirm",
+    kind: "button",
+    domain: "world",
+    context: "menu",
+    bindings: { keys: ["Enter", "Space"], pad: "faceDown", sourceButtons: [HUMANOID_XR_INPUT.rightTrigger, HUMANOID_XR_INPUT.rightPrimary] },
+    label: "Confirm",
+    description: "Accept the focused menu item",
+    touch: "tap"
+  },
+  {
+    id: "cancel",
+    kind: "button",
+    domain: "world",
+    context: "menu",
+    bindings: { keys: ["Backspace"], pad: "faceRight", sourceButtons: [HUMANOID_XR_INPUT.rightSecondary] },
+    label: "Cancel",
+    description: "Back out of the current menu level",
+    touch: "button"
+  },
+  {
+    // Right stick: 'look' is gameplay-context so the stick is free in menus — the "look becomes
+    // navigate" handoff, mirroring how pointer lock releases when a menu opens.
+    id: "uiNavigate",
+    kind: "vec2",
+    domain: "world",
+    context: "menu",
+    bindings: { composite: { up: ["ArrowUp"], down: ["ArrowDown"], left: ["ArrowLeft"], right: ["ArrowRight"] }, stick: "rightStick", sourceAxis: HUMANOID_XR_INPUT.rightStick },
+    label: "Navigate",
+    description: "Move the menu focus",
+    touch: "swipe"
+  },
+  {
+    id: "tabPrev",
+    kind: "button",
+    domain: "world",
+    context: "menu",
+    bindings: { keys: ["KeyQ"], pad: "bumperL" },
+    label: "Previous tab",
+    description: "Cycle menu tabs left",
+    touch: "swipe"
+  },
+  {
+    id: "tabNext",
+    kind: "button",
+    domain: "world",
+    context: "menu",
+    bindings: { keys: ["KeyE"], pad: "bumperR" },
+    label: "Next tab",
+    description: "Cycle menu tabs right",
+    touch: "swipe"
+  }
+];
+var byId = new Map(STANDARD_ACTIONS.map((a) => [a.id, a]));
+var STANDARD_CHARACTER_ACTION_IDS = STANDARD_ACTIONS.filter((a) => a.domain === "character").map((a) => a.id);
+
 // src/bundle/abilityManifest.ts
 var ABILITY_ID_PATTERN = "^[a-z0-9](?:[a-z0-9-]{1,48})[a-z0-9]$";
 var SEMVER_PATTERN = "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-[0-9A-Za-z.-]+)?$";
@@ -243,15 +751,22 @@ function validateAbilityManifest(value) {
           issues.push({ path, message: `must be an object (got ${typeName(action)})` });
           return;
         }
-        const actionId = checkQualifiedName(action.id, `${path}.id`, issues, id, "action");
+        const isStandard = typeof action.id === "string" && STANDARD_CHARACTER_ACTION_IDS.includes(action.id);
+        const actionId = isStandard ? action.id : checkQualifiedName(action.id, `${path}.id`, issues, id, "action");
         if (actionId !== void 0) {
           if (actionIds.includes(actionId)) issues.push({ path: `${path}.id`, message: `duplicate action id '${actionId}'` });
           actionIds.push(actionId);
         }
+        if (isStandard && action.kind !== void 0) {
+          issues.push({ path: `${path}.kind`, message: `standard action '${actionId}' takes its kind from the platform registry \u2014 omit kind` });
+        }
+        if (isStandard && action.defaultBinding !== void 0) {
+          issues.push({ path: `${path}.defaultBinding`, message: `standard action '${actionId}' takes its bindings from the platform registry \u2014 omit defaultBinding` });
+        }
         if (action.kind !== void 0 && (typeof action.kind !== "string" || !["button", "toggle", "vec2"].includes(action.kind))) {
           issues.push({ path: `${path}.kind`, message: "must be one of: button, toggle, vec2" });
         }
-        if (action.defaultBinding !== void 0) checkBindings(action.defaultBinding, `${path}.defaultBinding`, issues);
+        if (!isStandard && action.defaultBinding !== void 0) checkBindings(action.defaultBinding, `${path}.defaultBinding`, issues);
         for (const key of Object.keys(action)) {
           if (!["id", "kind", "defaultBinding"].includes(key)) issues.push({ path: `${path}.${key}`, message: "unknown field (allowed: id, kind, defaultBinding)" });
         }
@@ -371,7 +886,10 @@ var ABILITY_V1_JSON_SCHEMA = {
   required: ["schemaVersion", "id", "version", "title", "system", "activation", "configSchema", "entry"],
   properties: {
     $schema: { type: "string", description: "Editor convenience \u2014 ignored by the validator." },
-    schemaVersion: { const: 1, description: "Payload schema version. Post-freeze changes bump this (ability-v2), never edit v1." },
+    schemaVersion: {
+      const: 1,
+      description: "Payload schema version. Post-freeze changes bump this (ability-v2), never edit v1. One deliberate pre-public exception (2026-07-20): bare STANDARD character action ids became legal in `actions` \u2014 a backward-compatible loosening (every previously-valid manifest still validates). The freeze is absolute once the platform is public."
+    },
     id: {
       type: "string",
       pattern: ABILITY_ID_PATTERN,
@@ -459,7 +977,10 @@ var ABILITY_V1_JSON_SCHEMA = {
         additionalProperties: false,
         required: ["id"],
         properties: {
-          id: { type: "string", description: "Qualified action id '<abilityId>.<action>', e.g. 'fly.toggle'." },
+          id: {
+            type: "string",
+            description: "Qualified action id '<abilityId>.<action>' (e.g. 'fly.toggle') \u2014 or a bare STANDARD character action id (e.g. 'primary', 'reload'): the platform registry then owns kind + bindings, so omit both fields."
+          },
           kind: { enum: ["button", "toggle", "vec2"], default: "button", description: "Action kind (mirrors the system input service)." },
           defaultBinding: {
             type: "object",
@@ -526,7 +1047,7 @@ var ABILITY_V1_JSON_SCHEMA = {
 
 // src/core/identity.ts
 var SYSTEM_ID = "humanoid-character";
-var SYSTEM_VERSION = "0.2.2";
+var SYSTEM_VERSION = "0.3.0";
 var SKELETON_STANDARD = "helix-humanoid@1";
 var SYSTEM_IDENTITY = { id: SYSTEM_ID, version: SYSTEM_VERSION, skeleton: SKELETON_STANDARD };
 export {