CairnAPI

The button's GameObject.

The RectTransform (authored size 200×50; resize or let a layout group drive it).

The underlying uGUI Selectable, for navigation wiring.

Create an action button under parent. Click / Submit fires onClick. Returns null on failure (game UI not loaded yet).

Change the label text.

Enable/disable interaction (native disabled tint).

Move uGUI selection to this button.

Tear the button down. Safe to call more than once.

True if all requested items were added.

How many were actually added.

Failure reason when Ok is false.

Resolve a query (exact catalog key, GUID, full path, or bare asset name — case-insensitive) to the exact catalog key. When several assets share a bare name, typeName (e.g. "GameObject") picks between them. Returns false when nothing matches.

All catalog keys containing substring (case-insensitive) — discovery for tooling and exploratory code. GUID keys are included.

Load an asset synchronously. T is the expected asset type (GameObject for prefabs); the result is the ASSET, not an instance — Instantiate what you need from it. Returns null (with a logged warning) for unknown keys, failed loads, and type mismatches. The underlying Addressables handle is cached and held, so repeat calls are free and the asset stays valid until Assets.Release.

Load an asset without blocking; onReady fires on the main thread with the asset, or null on failure — synchronously when the asset is already cached. Same caching and resolution semantics as Assets.Load%60%601.

Release a previously loaded asset's Addressables handle. After this the asset (and clones of it) may be unloaded by the engine — only call it when the mod is done with the asset for good.

Show a center-screen announcement in the game's own banner style, auto-closing after seconds. Returns false if the game UI isn't loaded yet. A banner shown while one is already up replaces its text and timer.

Authored beat name.

World-space center of the sensor trigger.

True when the story manager is live. Check before calling Snapshot.

Every story-beat sensor in the current scene, sorted by label. Pure — no caching.

A climbbot is currently attached to the climber's harness.

Stand the belay down (stop securing + detach the rope) — the bot's own setters in its recall flow's order. Safe no-op when not belayed. Only call around a placement.

Re-establish the belay after a placement that ended in CLIMBING without a mode edge (the native attach only fires on entry into climbing). No-ops when the pawn isn't climbing — SetSecureClimber's own mode check guards it — or when no bot exists.

The verbatim pose captured with the bookmark, or null for a ground bookmark (existing stores load with no pose and behave exactly as before).

The bookmark's world position.

True when this bookmark was captured on the wall (it carries a climbing pose).

Fires when the live warp-point registry changes wholesale — after a lifecycle stand-down (session end, zone change) and after a rebuild completes. UIs holding warp-point rows should re-pull them.

Every bookmark saved for the current map, or an empty list when not in a level.

Every bookmark saved for an explicit map key (a shipped mountain's world name, or a custom level's "cml:" address — the same key World.CurrentMapKey reports in-level). For menu-time enumeration, when no world is loaded. Null or empty key → empty list.

Save a bookmark at the local climber's current spot on the current map. Standing on the ground saves a plain position; a stable climbing stance saves the verbatim on-wall pose with it. Pass allowOnWall false when the calling surface can only manage ground bookmarks — an on-wall capture is then refused (the grounded-only behavior). A null or blank name gets a default. Returns null when the climber is not spawned or is mid-move (falling, reaching, on the rope, or off every hold) — those states can't be captured.

Save a bookmark at an explicit world position on the current map. A null or blank name gets a default. Returns null when not in a level.

Rename a bookmark and persist; its warp-list row updates on the game's next refresh.

Remove a bookmark and its live warp point, if any. Returns false if unknown.

The bookmark behind a live warp point, or null if the point is not a bookmark's.

The loc key rendering a bookmark's name while it is materialized (for live edits via Localization.Update), or default when it has no live point.

Fires when a bookmark is warp-confirmed from the eagle-eye view (after the pawn is placed). A session mod (Boulderdash) uses it to fold the arrival into its own run/restart bookkeeping.

Resolve once and hold forever (until Unity-null). A null result is remembered too — resolve() won't run again unless CachedRef%601.Invalidate is called. Use when a null result means "confirmed absent, and nothing else here would make it appear" (e.g. a fixed, load-once asset).

Same, but a null result is NOT remembered — every call re-resolves until resolve() finally succeeds, then stays cached from then on. Use for a transient condition you're waiting on (e.g. "has the pawn spawned yet") where retrying every call is the point.

Resolve and cache, but re-resolve (including re-trying a previously-null result) whenever key differs from the key last used to produce the cached value — e.g. a scene name, so "no MainMenu in this scene" stays cached until the scene actually changes.

Add a main-menu entry that opens a mod CairnAPI.MenuScreen, behaving just like the game's own Settings button on the title screen: clicking it slides the main menu away and opens the screen built by buildScreen; backing out returns to the main menu. The entry sits above the Settings button. Returns a handle that removes the entry when disposed.

Add a title-screen mode-select entry, slotted directly above the native Settings button.

Add a title-screen mode-select entry directly above the native button GameObject named insertBefore (e.g. "SettingsButton"). Matched by GameObject name; if no child matches, the entry appends. The entry is injected on every MainMenuModeSelectElement.Awake and spliced into the native nav set via a GetButtons() postfix.

Add a pause-rail entry at the bottom of the rail.

Add a pause-rail entry directly above the native rail child named insertBefore (e.g. "RetryFromStart" to sit just after Settings). The anchor is matched by GameObject name and exists even when that native button is hidden, so the slot is stable across conditional buttons; if no child matches, the entry appends.

As above, plus a visibility predicate evaluated each time the pause menu opens — the entry is only injected while it returns true (e.g. gate a session-scoped tool on the session being live). A throwing predicate hides the entry.

Add a rail entry that opens a managed CairnAPI.SettingsPage — a native fieldsUI-backed page populated from buildFields. The returned page can swap its content live via SettingsPage.Refresh / SettingsPage.SetFields.

Re-seat the gameplay camera behind the pawn NOW — the native "climber reset" verb. Selects the current camera (ForceCameraChangeNow, byte-identical to CheckCurrentCamera) and resets the live rig (repositions its look-at pivot and computes the behind-her rotation). Mirrors the native teleport chain, which our teleport pipeline doesn't otherwise trigger. Returns false if the camera system isn't up or the call failed.

True while any eagle-eye view (plain / plus / free / route-scouting) is the active camera — the read-only observer for Cameras.Reseat's camera family. False on any failure.

The widget's root GameObject.

Fires with the newly-centered entry's index whenever the selection moves.

Build a native item carousel under parent. onPick fires with the centered entry's index on Submit / click; canPick (optional) refuses a pick with the native shake. Returns null when the carousel template isn't available.

The centered entry's index into the list passed to Create.

Move the selection left (-1) / right (+1) with the native slide.

Center an entry immediately (no slide).

Focus the carousel so gamepad/keyboard axis input drives it.

Tear the carousel down. Safe to call more than once.

The game clock in day-seconds (wraps daily; 3600 = 1:00 AM). 0 when no session is up.

How many in-game days have passed.

Time of day as 0..1 across the current day (0.5 = noon).

Whether the game clock is currently paused (menus, cinematics, photo mode).

Set the clock to an absolute day-seconds value, silently (no survival side effects). Returns false when no session is up.

Set the time of day within the current day, silently (no survival side effects).

The vanilla LT wheel (level-0). Actions here use only its free slots.

Define (or update) a menu selected by holding LT + the given modifier chord. Two mods must not claim the same chord; the first wins and a warning is logged. The base menu (LT alone) is implicit and need not be defined.

Register (or replace, by Id) a custom action. Safe to call before the HUD exists.

Remove a previously-registered action by Id. No-op if unknown.

True once the live menu is found and the library is driving it.

Stable unique id, e.g. "mymod.grapple". Re-registering the same id replaces it.

Shown in logs and (future) tooltips.

The menu this action lives in — a menu id previously passed to CrossMenu.DefineMenu. Defaults to CrossMenu.BaseMenu (the vanilla LT wheel — only its free slots may be used).

A built-in Lucide icon name (e.g. "anchor", "flame"). Used when CrossMenuAction.Icon is null.

Explicit icon sprite; takes precedence over CrossMenuAction.IconName. Null → placeholder.

If true a numeric badge (from CrossMenuAction.GetCount) is drawn on the icon.

At or below this count the badge turns to the warning colour. Only when DisplayCount.

Invoked when the action is executed (after the hold-to-confirm). Required.

Return false to grey-out / block. Optional — default always-available.

Numeric badge value when CrossMenuAction.DisplayCount is set. Optional — default 0.

Invoked when attempted-but-unavailable. Optional.

The widget's container — anchor/place it like any child (it also carries a LayoutElement, so layout-group hosts flow it inline).

Build the native arrows row under parent. onChanged fires with the new option index — from the arrow buttons AND from programmatic Cycler.Index writes (hotkey-driven cycling).

One-shot post-materialize normalization for standalone hosts — the row prefab is authored for the full settings-panel width (prefab-measured: label cell 0–40%, value cluster 60–100%, the value text spanning the WHOLE cluster with the 32px arrows floating on its ends, and the right arrow pivoted to hang 32px PAST the row edge). At widget widths (~480px) that collides. Retune: label 0–30%, cluster 30–100%, right arrow pivoted inside, text inset clear of both arrows. Call per frame (rows materialize a frame after build via the game's deferred refresh); no-ops once applied.

The selected option. Setting it drives the NATIVE row refresh (and the onChanged callback) through the model's own Index setter; an unchanged value is a no-op.

Tear the widget down. Safe to call more than once.

The rows' RectTransform — anchor/place it like any child; height auto-fits.

Build native rows under parent. Top-anchored, parent-width, auto-height; re-anchor FieldRows.Rect to place. Null when no donor templates exist yet (build once a menu or gameplay host is up).

True while the host and its donor templates are alive.

Replace the rows (the game's own RemoveAll → Add → Activate cycle).

The rows' Selectables in visual (sibling) order — for wiring explicit navigation between the rows and neighbouring controls. Live query: rows are born a frame after FieldRows.Set (the game's deferred Refresh), so call this from a later frame; empty until then.

The actual Selectable the game focuses on the LAST navigable row (native FieldsUI.GetLastSelectable) — not the first child Selectable FieldRows.Selectables returns, which on a value row (ListArrows/slider) can be an inner arrow. Use this when wiring a control BELOW the rows: UI.FieldsUI re-derives its rows' Navigation struct on every selection change (FieldUI.SetNavigation), nulling the bottom field's selectOnDown — so re-assert the link to this selectable each frame, don't set it once. Null when no rows / host dead.

The actual Selectable of the FIRST navigable row (native FieldsUI.GetFirstSelectable) — the counterpart to FieldRows.LastSelectable for wiring a control ABOVE the rows.

Hand EventSystem focus to the first selectable row.

Tear the rows down and invalidate the handle. Safe to call more than once.

A settings row with a REAL pill-chromed button as its widget — label on the left, button on the right (unlike Fields.Button, where the whole chromeless row is the button).

A grid of icon+label cells the player clicks to pick one. Renders in settings, photo mode, and debug menu pages alongside the other field rows.

A 2-component row of sliders for editing a Vector2, e.g. a min/max or X/Y pair.

A 3-component row of sliders for editing a Vector3, e.g. an X/Y/Z offset.

A 4-component row of sliders for editing a Vector4, e.g. a color or a rect.

A 2-component row of text inputs for editing a Vector2, e.g. a min/max or X/Y pair.

A 3-component row of text inputs for editing a Vector3, e.g. an X/Y/Z offset.

A 4-component row of text inputs for editing a Vector4, e.g. a color or a rect.

Build a hidden panel that will host native settings rows. The panel is created but NOT shown — call FieldsPanel.Show after adding fields. Row visuals come from the game's own settings-row templates, acquired once at build time. Returns an invalid handle (all methods no-op) if the game hasn't loaded its UI yet — build the panel once a menu or gameplay is up.

True once the panel is built and its FieldsUI + row templates are still alive.

True while the panel is on-screen (between FieldsPanel.Show and FieldsPanel.Hide).

Add native rows for the given game UI.Field data objects (the ones CairnAPI.Fields builds). Rows are born inactive and appear a frame later via the game's own deferred Refresh — do not fight it. Repeated Add of the same Field is NOT deduplicated; call FieldsPanel.Clear before rebuilding. Keep the total under ~12 rows (no scroll in v1).

Show the panel and hand focus to its first row (EventSystem row-nav then works). Idempotent. The game supplies the EventSystem; without one, rows draw but can't be navigated.

Hide the panel (rows and their state are kept; call FieldsPanel.Show to reveal again).

Destroy every current row (the game's own RemoveAll — unbinds, stops coroutines, destroys row GOs).

Tear the panel down entirely and invalidate the handle. Safe to call more than once.

Request a gameplay pause — freezes the simulated world (climber, physics) while leaving the camera and UI on the engine clock. Reference-counted; balance every call with GameTime.UnpauseGameplay. Returns false if the time system isn't up.

Release one gameplay-pause request. GUARDED against the OnLevelLoading drain trap: TimeManager.OnLevelLoading drains the pause-request counter to zero on every level load, so a request held across a reload is ALREADY released by the game — decrementing afterward would drive the counter negative and silently eat a future pause. So when the pawn is despawned (a level load in flight) or there is no world at all, the decrement is SKIPPED and this returns false. Otherwise it releases and returns true.

True while gameplay is paused (the request counter is above zero) — the read-only observer for the pause verbs. False on any failure.

The player's live InputAction for a curated game action (reflects their current rebind), or null if the input system isn't ready yet. Hand the result to a Prompt as its glyph.

Resolve any game action by its "Map/Action" (or bare "Action") name against the live input asset — the escape hatch for actions not in the CairnAPI.GameAction enum. Null if not found / not ready.

A glyph for a raw keyboard key, e.g. Glyph.Key("g"). Special keys (enter/space/esc/tab/arrows…) resolve to a stock sprite; plain letter/number keys have no sprite in the icon DB, so they render as the human-readable key text ("G") — exactly as the game does. See CairnAPI.Glyph.

A glyph for an arbitrary control path, e.g. Glyph.Path("/buttonSouth"). Buttons + special keys resolve to a stock sprite; anything without a DB sprite renders as human-readable text.

A cross-device action with MULTIPLE bindings (e.g. a keyboard key AND a gamepad button), enabled so it fires on either device, and usable BOTH as a prompt glyph (the glyph + adaptiveBinding auto-picks the active device's binding, so the keycap swaps to the pad button on a controller) AND as live input (poll action.WasPerformedThisFrame()). This is the parity path: bind "/b" + "/buttonWest" and the same action drives the icon and the trigger on both devices. name must be unique per logical action (it keys the action in the shared map).

The live InputActionAsset the game is driving (player's bindings live here), or null pre-game.

The widget's GameObject (an Image the native component drives). Parent/position freely.

The RectTransform, for layout.

Create an inline glyph image under parent showing the sprite for action's current binding (see CairnAPI.Glyph for obtaining actions). The icon tracks device changes and rebinds natively. Returns null if construction fails; a null action is allowed — the glyph stays hidden until GlyphImage.SetAction is called.

Create showing the player's current binding for a curated CairnAPI.GameAction.

Point the glyph at a different action (it re-renders; null hides it).

Show a specific binding of the action instead of the device-adaptive pick.

Tear the glyph down. Safe to call more than once.

True when the streamed climbing holds are present around pos — at least one registered SceneHoldsSpatialPartitioning answers with candidate holds there. False (never throws) while the holds subscene is still streaming in, or when the scene state can't be read.

The region to build panel content under (full-screen stretch; anchor your own layout).

Build a hidden HUD panel with the native open/close fade lifecycle. Build content under HudPanel.Content, then HudPanel.Open. The panel survives scene loads. Returns an invalid handle (all methods no-op) if construction fails.

True once built and still alive.

True while the panel is open or fading in (the native state query).

Open with the native fade-in. Idempotent while already open.

Close with the native fade-out. Idempotent while already closed.

Snap open/closed without the fade (the native ForceOpen/ForceClose path).

Snap closed without the fade.

Tear the panel down entirely and invalidate the handle. Safe to call more than once.

Move UI focus to the widget's first selectable element (called when its page opens).

Tear the widget down (called when its page closes or the screen is destroyed).

Short label for the source toggle prompt ("Bookmarks", "Routes").

The destinations for the CURRENT map (the source reads World.CurrentMapKey itself). Called on every (re)materialize; return a fresh list.

Arrive at a selected entry. Runs INSTEAD of the native warp (which is skipped), so this owns placement — use Teleport.To with a CairnAPI.Stance, or start a run; never the native WarpToPoint.

Whether this entry may be renamed/deleted from the eagle-eye view.

Rename an editable entry (persist + WarpSources.Invalidate).

Delete an editable entry (persist + WarpSources.Invalidate).

Whether this source is currently offerable at all — it only counts toward the toggle, can be switched to, and materializes while true. Bookmarks are always available; routes only inside a Boulderdash session, so in a plain campaign the routes list and its toggle never appear.

Whether the "add here" keybind applies to this source (bookmarks capture the climber's spot; sources whose destinations are authored elsewhere — routes are recorded — return false).

Whether the game's OWN warp points stay in the eagle-eye list while this source is active. Bookmarks say yes (native destinations belong with them); routes say no (the list shows routes only — natives are pulled while active and restored on toggle/stand-down).

Label for the game-provided entries this source can show/hide from its list ("game points", "game routes"), or null when it has none — the eagle-eye "show/hide" keybind only appears for a labelled source. The view flips IWarpSource.NativeShown and re-materializes via WarpSources.Refresh.

Whether the game-provided entries are currently shown in this source's list.

Optional in-view option cycler shown while this source is active (routes offer the launch mode). Null/empty = no selector; the view renders ": " and cycles IWarpSource.SelectorIndex on its selector keybinds. Confirm reads the selection.

What the selector chooses (e.g. "Mode") — the prompt's label prefix.

The selected option (index into IWarpSource.SelectorOptions); the view writes it as the player cycles.

Author a new destination at the climber's current spot. Returns true if one was added (the controller then rebuilds the list). No-op / false when unsupported.

Add items to the appropriate storage slot. Stops cleanly at capacity.

How many of an item the player currently holds.

Current total weight in a storage slot.

The bag's weight capacity.

The grid's root GameObject.

Build a scrollable native item grid under parent. onConfirm fires with the entry index on click / gamepad Submit. Returns null when the native cell template isn't available yet.

Number of cells.

Focus the first cell (gamepad/keyboard nav anchors here).

Re-bind one cell to a different item/count in place.

Tear the grid down. Safe to call more than once.

The item to display.

Count shown on the cell's native badge.

Enum identifier.

Display name.

Which storage slot holds this item.

Maximum stack count.

True when the item ships real icon art (not the game's placeholder icon).

The item's icon sprite, shared by reference; null when the item ships no real art (the game's placeholder icon — see ItemInfo.HasIcon).

Weight per unit. NaN for non-physical items.

Stable unique id of this location (the game's persistent provider id).

Name of the GameObject hosting the pickup (diagnostic).

Name of the scene the pickup lives in.

World position of the pickup.

The item yielded per slot, in slot order. Single pickups have one entry; containers have several.

True when the site holds more than one slot (opens the native item carousel).

Whether the site can currently be looted (not emptied, not gated).

Every item location in the currently loaded scenes. Only sites with a stable id (finite-stock pickups) are returned; infinite sources (e.g. bottomless bushes) are not item locations. Never throws; empty when no world is loaded.

The location with the given id, if it is loaded right now. Null otherwise.

Register a durable override: the location yields items (one per slot) and — for single pickups — shows label as its world-prompt name (defaults to the first item's own name). Applied now if the node is loaded, and re-applied whenever the game (re)creates it. Replaces any previous override for the same id.

Convenience for the common single-slot case; the prompt name follows the item.

Remove the override for a location, restoring its original loot and label (takes effect immediately if the node is loaded).

Remove every registered override, restoring loaded nodes.

Fires on the main thread when any item location is actually looted: (location id, slot index, item taken). Slot is -1 when the game looted without a specific slot (e.g. "take all" / auto-fit paths). This is the "check" signal for randomizers.

The cell's GameObject.

The cell's RectTransform (size it, or let a layout group drive it).

The cell's uGUI Selectable — compose into navigation chains (ItemGrid does).

The cell's authored (prefab) size — the native footprint layout containers should honor.

Create a native item cell under parent showing item. Hover selects; click / gamepad Submit fires onConfirm. Returns null when the native slot template isn't available (the game UI hasn't loaded).

Re-bind the cell to another item/count (the slot's own native Setup path).

Move uGUI selection to this cell (fires the authored selection feedback).

Show/hide the cell without destroying it (the slot's native ToggleDisplay).

Tear the cell down. Safe to call more than once.

Every item in the game (315 entries). Cached after first access.

Resolve a single item config by enum id.

The label's GameObject.

The RectTransform (sized by its parent layout or by you).

The underlying TextMeshPro component, for advanced styling.

The game's own TMP font asset; null until the game UI has loaded.

Create a native-font label under parent. Fills the parent by default — re-anchor Label.Rect or let a layout group drive it. Returns null on failure (game UI not loaded yet).

Change the text.

Change the text color.

Tear the label down. Safe to call more than once.

The local player's lamp mode, or null when no pawn is up.

Set the local player's lamp mode through the lamp's own verb (visuals update immediately). Returns false when no pawn is up.

A custom-level session is live — traveling into a custom level or its scene is resident.

Per-launch identity of the last MOD-INITIATED custom launch (the custom analog of Session.LaunchGuid). LevelLoader.CreateAndPlay's custom branch mints a fresh one at launch-fire; the launching mod captures it and compares on arrival to prove the gameplay that arrived is the launch it fired. CustomSessionLive alone is a CLASS check — a native Continue of a custom save arms the same session machinery — so the nonce narrows arrival to OUR launch. What keeps it honest: every save-READ while a launch is pending stands the whole launch down (SaveLoadCustomPatch — a mod launch never reads a save), so no Continue variant can be adopted; and quit-to-menu stands it down at residency end (OnSceneUnloaded), so nothing armed persists at the menu. The ONE remaining window: a player-initiated NEW GAME inside the wedge window (≤30s, the watchdog's bound) reads no save and resolves through the same armed new-game redirect — indistinguishable from our launch at the resolver — and is adopted.

The local player's active climbing controller, or null when not climbing. This is the game's own PawnManager.ClimbingPawnController: the local pawn, never a co-op ghost.

The local left-hand limb, or null when not climbing.

The local right-hand limb, or null when not climbing.

The local left-foot limb, or null when not climbing.

The local right-foot limb, or null when not climbing.

The local limb for a given target, or null when not climbing.

All four local limbs, in LeftHand, RightHand, LeftFoot, RightFoot order, skipping any that are null. Empty when not climbing.

The same-kind opposite of a limb (left↔right within hand, or within foot), or null. Useful for auto-pickers that must never hand back the passed limb.

True when the limb is gripping a hold (state == Holding). This is the game's load-bearing signal: the effort/stamina economy and every "is attached" predicate key on it.

True when the limb is in any active climbing state — reaching, holding, or moving to a hold (including the ice-climbing variants) — as opposed to Idle.

Snap every idle/reaching limb onto the nearest reachable hold — the game's own ForceAllReachingAndIdleLimbsToGrab. Used to attach the climber to the wall after a bare climbing placement (a route start with no captured pose): the pawn arrives in climbing mode with limbs dangling, and this grabs the holds around them. No-op (returns false) when not climbing.

Force the limb to let go through the game's own Drop path — clears its current grab and routes it back to Idle. Local pawn only. No-op (returns false) if the limb is null.

Register english under English and hand back a loc key that renders it in EVERY language (English is the fallback for all). For plain or user-generated content (names, labels) that is not translated. Write the returned key wherever the game wants a LocKeyStringId and the game's own text pipeline renders this string there, durably.

Register a full per-language table and hand back a loc key. Language codes are upper-normalized (so "en" and "EN" are the same entry). The English entry is the fallback for any language not in the table; if the table has no English entry the first entry is used as the fallback.

Replace the English / fallback text of a key returned by Localization.Register.

Set or replace the text for one language of a registered key (language code upper-normalized). A key not registered here is ignored.

Drop a registered key; the game falls back to its own resolution for that id afterward.

True if key is one this facade resolves.

All available Lucide icon names (loads the index on first call).

True if the named icon exists in the bundle.

Get the sprite for a Lucide icon name, decoding + caching on first use. Returns null if the name is unknown (caller falls back to a placeholder).

The button's GameObject.

The RectTransform (authored size 471×55; resize or let a layout group drive it).

The underlying uGUI Selectable, for navigation wiring.

Create a native menu button under parent. Hover/gamepad selection shows the native highlight; click / Submit fires onClick. Returns null on failure (game UI not loaded yet).

Change the label text.

Enable/disable interaction (native disabled tint).

Move uGUI selection to this button.

Tear the button down. Safe to call more than once.

Build a mod-owned menu screen (hidden — call MenuScreen.Open to show it). Hosts a left rail of pages; add pages with MenuScreen.AddPage. Row visuals come from the game's own settings-row templates, borrowed once at build time. Returns an invalid handle (all methods no-op) if the game UI isn't loaded.

True once the screen is built and still alive.

True while the screen is the foreground menu (between MenuScreen.Open and MenuScreen.Close).

Bouncing the rail highlight onto a page renders that page inert in the content area (visible, not clickable); picking it makes the same content live in place — no rebuild. Off by default.

Add a named page to the left rail. Picking it fills the content area with the rows returned by buildFields. The builder runs each time the page is opened. No page opens automatically — the content area stays empty until the user picks a rail item.

Add a named page whose content is a custom widget (e.g. a CairnAPI.ScrollList) instead of settings rows. build runs each time the page opens, receiving the content-area RectTransform to build under; the returned handle is destroyed when the page closes.

Re-run the open page's builder in place — fresh rows, rail state untouched. For rows whose callbacks change what the rest of the page shows (e.g. a selector driving a list). No-op when no page is open.

Open the screen through its host (stack over settings/pause, or self-open on the title screen).

Close the screen and return to what's underneath. Idempotent.

Close the screen AND the whole menu stack beneath it, returning to gameplay, then run afterResume (e.g. a level travel). The native start-a-load-from-pause sequence (MainSubmenu/OnLoadSaveClick.c): close our screen, then the host down to gameplay, then fire the load. Only the PAUSE host has a stack to unwind; other hosts degrade to a plain Close + the action.

Tear the screen down entirely and invalidate the handle. Safe to call more than once.

True while a modal surface (CairnAPI.Modal/CairnAPI.Prompt) owns input over the foreground screen — widget-level input polling (list keybinds, page hotkeys) must stand down.

Per-frame pump for the foreground mod screen — call once from the mod's OnUpdate. Polls the Cancel/ Special actions the host supplied and closes the screen (or backs out a page) on a hit. No-op when none.

The meter's GameObject.

The RectTransform (authored size 361×31; resize or let a layout group drive it).

Create a native stat bar under parent. Returns null on failure (game UI not loaded yet).

Set the meter. fill and preview are 0–1; preview shows a pending change (defaults to the fill value); low tints the fill, critical plays the critical state.

Tear the meter down. Safe to call more than once.

Show a two-button dialog. onConfirm fires when the player accepts, onCancel (if given) when they decline or dismiss. Game input is blocked while it's up. Returns false if the popup system isn't available yet or the call failed.

Show a one-button acknowledgement dialog. onDismiss (if given) fires when the player dismisses it. Game input is blocked while it's up. Returns false if the popup system isn't available yet or the call failed.

Show the game's item-reveal popup (the special-loot presentation: item render, title, flash effect, native accept prompt) for any game item. One-button acknowledge form — onDismiss fires when the player accepts or the popup dismisses. Returns false if the reveal surface isn't available.

Show the item-reveal popup with the native accept / refuse choice. onChoice fires with true when accepted, false when refused.

Launch a new story-mode game with the given difficulty and character, optionally skipping the tutorials and the practice wall. Returns a status string ("STORY_LAUNCH_INVOKED" on success); fire-and-return — the load runs natively.

The local player's current outfit, or null when no pawn is up.

Switch the local player's outfit through the pawn's own verb (meshes and materials swap immediately). Returns false when no pawn is up, the type is unknown to the skin database, or the outfit is already current.

Dress an arbitrary Aava-skeleton rig in type: the outfit's authored mesh, materials and bounds are copied onto the given body/outfit renderers with bones rebound by name against skeletonRoot's hierarchy — the game's own cross-rig skin worker. The skin data comes from the LOCAL pawn's skin database (always populated in gameplay). Returns false when no pawn is up or the type is unknown.

The panel's GameObject.

The panel's RectTransform (fills the parent by default; re-anchor or resize freely).

The content region, inset past the chrome's drawn border — build inside this.

Create a native-chromed panel under parent. Fills the parent by default — re-anchor Panel.Rect or let a layout group drive it. Returns null on failure (game UI not loaded yet).

Tear the panel down. Safe to call more than once.

The cream dialog-box background the game's popups use.

The border-only frame the in-game goals list uses.

Locomotion mode at capture (PawnControllerSwitcher.Mode; 2 = Climbing).

Body world transform, packed [px,py,pz, rx,ry,rz,rw].

Root-node world transform, packed [px,py,pz, rx,ry,rz,rw].

The left-hand limb snapshot.

The right-hand limb snapshot.

The left-foot limb snapshot.

The right-foot limb snapshot.

True when this pose was captured on the wall (climbing mode).

The limb's attachment state (ClimbingV2PawnLimb.LimbState; 2 = on a hold).

IK end-bone world transform, packed [px,py,pz, rx,ry,rz,rw].

Grab-anchor world transform, packed [px,py,pz, rx,ry,rz,rw].

IK bend-goal world position [x,y,z].

Local sub-bone rotation (foot ball bone) [x,y,z,w].

Persistent id of the hold the limb was on, or 0 when unattached.

True when this limb was captured gripping a hold.

The button's GameObject.

The RectTransform (authored footprint 200×50; resize or let a layout group drive it).

The underlying uGUI Selectable, for navigation wiring.

Create a pill button under parent. Click / Submit fires onClick. Returns null on failure (game UI not loaded yet).

Create a pill button with a sprite icon (e.g. ItemInfo.Icon) inside the left edge.

Change the label text.

Enable/disable interaction (native disabled tint).

Move uGUI selection to this button.

Tear the button down. Safe to call more than once.

Capture refused: the climber is mid-move (reaching, mantling, on the rope), off every wall hold, in a transitional state, or absent.

The climber is standing on the ground — a valid spot, but there is no wall pose to store (ground placement needs only a position).

The climber is in a stable climbing stance — a verbatim pose was captured.

The climber is falling — nothing meaningful to capture.

Capture the local climber's current stance. PoseCaptureStatus.OnWall fills pose with the verbatim on-wall pose (body + all four limbs); PoseCaptureStatus.Grounded also fills pose, with just the body position/rotation (no limbs — standing on the ground has nothing else to capture, but the facing is still worth restoring verbatim rather than losing it to a bare position); PoseCaptureStatus.Refused and PoseCaptureStatus.Falling leave pose null and set reason (a limb mid-move, on the rope, no wall hold gripped, falling, no climber).

True when a capture would succeed right now: standing on the ground, or a stable climbing stance (steady on the wall with at least one limb on a real hold). False while falling, reaching, mantling, or on the rope — use it to gate capture verbs live.

True while a restore's per-limb pass is still running.

Show the prompt. Returns false when the game UI isn't loaded yet.

Dismiss the open prompt, if any (no submit).

Whether a prompt is currently on screen.

Remove this prompt and its GameObject.

Show a CairnAPI.WorldPrompt over anchor while Aava is within distance of it. onInteract fires on the glyph's button while in range. Returns the component; call ProximityInteractable.Destroy to remove it.

Remove this prompt and its GameObject.

Attach a reach prompt to a MOVING anchor (e.g. the climbot, an NPC, a carried prop). Parented to the anchor, so it tracks it automatically — pass the transform of the thing the player reaches toward. Shows a CairnAPI.WorldPrompt with text + glyph while a limb is REACHING into radius; onInteract fires on the glyph's button while reaching. localOffset shifts the trigger from the anchor's pivot to the actual grab point. hands true = only hands trigger it; false = any limb.

Spawn a reach prompt at a FIXED world position (a lever, a wall panel — something that doesn't move). For anything that moves, use ReachPrompt.Show instead.

The synthetic CrossMenuActionType int this instance answers for. Set right after construction (managed-side field; not visible to Il2Cpp, which is fine — only our overrides read it).

The list's root GameObject.

Build a native save-slot list under parent from the game's cached Story-save previews (title-screen context — the same source the native save select reads). onPick fires with the row index and its preview on click / Submit. filter (optional) keeps only matching previews. Returns null when no previews are cached (not at the title screen yet) or the row template is unavailable.

Number of rows.

Focus the first row (gamepad/keyboard nav anchors here).

Tear the list down. Safe to call more than once.

GlobalGameManager.GameState enum value at the top of the state stack.

The main menu system is active (GameState stack contains Menu).

Gameplay is active (GameState stack contains InGame). This is true even when the pause menu or bivouac is on top.

A cutscene is playing (GameState stack contains Cutscene).

The game-over screen is up (GameState stack contains GameOver).

The bivouac rest menu is active (GameState == Bivouac).

The pawn (Aava) is spawned in the world — the real "we are in live gameplay" test. Unlike LoadingState.GameStarted this is not sticky across menu returns.

The game's detailed load pipeline stage. ⚠ Sticky: retains its last value (e.g. GameStarted=8) after returning to the menu. The authoritative "fully in gameplay" signal is PawnSpawned, not GameStarted.

A cross-world / cross-zone / menu scene transition is in flight.

Specifically a game→menu transition is in flight (subset of IsTransitioning).

The foremost open Menu canvas, or null. Changes only at UIManager.OnMenuClosed / OnMenuStacked — observe via OnMenuChanged if you need a callback.

Fires whenever GlobalGameManager.GameState changes. Arguments: (from, to). Sourced from GameEventManager.ChangeGameState — fires for every push/pop and direct set.

Fires when UIManager.CurrentMenu changes (a menu opens or the foreground menu closes). Argument is the NEW current menu (null when the stack empties).

Fires when any BasicCanvasHandlerBehaviour finishes opening (OnOpened). Fires for menus AND HUDs. Cast the argument to check the concrete type.

Fires when any BasicCanvasHandlerBehaviour finishes closing (OnClosed). Fires for menus AND HUDs. Cast the argument to check the concrete type.

Fires when a game→menu or menu→game scene transition starts. Sourced from CairnSceneManager.OnGameUnloadingAboutToStart.

Fires when a scene transition completes and all new scenes are ready. Sourced from CairnSceneManager.OnGameScenesReady.

Fires specifically when entering the main menu scene (game→menu path only), just before the menu scene itself loads. CairnSceneManager.OnPreparingToLoadMenu.

Show a screen-space prompt. text is shown as-is, glyph is the button icon (see CairnAPI.Glyph, null = none). If parent is null the row goes under a mod-owned overlay Canvas — place it with ScreenPrompt.Move; if given, the row is parented there (self-sizes for a HorizontalLayoutGroup). Returns a handle, or ScreenPromptHandle.Invalid if a required game asset isn't loaded yet.

Place an own-Canvas prompt anywhere on screen (its RectTransform's anchoredPosition). No-op for a prompt parented into your own layout (let the layout group place it).

Change a live prompt's text in place (set once; persists with no pump).

Show / hide the prompt (a layout group re-flows around a hidden one). Cheap — no re-register.

Destroy the prompt. Safe on an invalid handle.

A no-op handle returned when a required asset / the HUD wasn't available.

Show / hide the prompt (the layout group re-flows around a hidden one).

Destroy the prompt GameObject. Idempotent; on an already-dead row it just invalidates.

Prompt-strip label (e.g. "Rename").

Cross-device action — glyph AND trigger.

Runs with the selected row index when the action fires.

Per-row gate; null = every row. Returning false hides the strip prompt and swallows the key on that row.

Right-aligned dim metadata column (e.g. a best time); null = none. Ignored on a row with Row.Actions — a pill tray owns the right edge.

Build a scroll list filling parent. items are the row labels; onConfirm receives the row index on click or Submit. Rows are always the game's own warp-list rows: read from memory when their bundle is loaded (any gameplay context), else the owning prefab is asset-loaded through the game's Addressables (works on the title screen too).

Build a scroll list of ScrollList.Rows — labels with optional trailing action pills.

True once built and still alive.

Index of the currently-selected row, or -1 when none of ours is selected.

Replace the row labels. Rows are rebuilt to the new count; loc keys are reused per slot so repeated refreshes (e.g. a lobby list poll) don't grow the localization registry.

Replace the rows (labels + trailing action pills). Same slot-key reuse as the string form.

Number of rows currently shown.

The current top (first) row's Selectable (null when empty) — for wiring an outside widget's down-navigation INTO the list (so descending from a control above lands on the list, not past it).

The current bottom row's Selectable (null when empty) — for wiring an outside widget's up-navigation back into the list.

Wire the list's outside neighbours. before = the control above/left (selectOnLeft on every row, selectOnUp on the first row); after = the control below/right (selectOnRight on pill-less rows — on pill rows the last pill's selectOnRight — plus selectOnDown on the last row). Null = that edge stays dead. Persisted — ScrollList.SetItems row rebuilds re-apply it.

Selected-row keybinds with a bottom glyph-prompt strip. Each ScrollList.KeyAction is polled while a row is selected (no modal up, no focused text field): the first enabled action whose cross-device KeyAction.Action fired this frame runs KeyAction.OnPerformed with the row index — one per frame. The strip shows one glyph+label per action (hidden per-row by KeyAction.EnabledFor) and follows selection. Persisted across ScrollList.SetItems; null/empty clears.

Add a display-only prompt to the strip for the game's Confirm action (Submit = go). Null removes it.

Render the keybind prompt strip inside host — a layout band the consumer owns (e.g. below the list frame) — instead of a reserved band inset into the list's own viewport. Null returns it to the in-list band. A live strip relocates. Set this before ScrollList.SetKeyActions for no churn.

Move UI focus to a row by index (clamped; no-op when empty).

Focus the first row (the CairnAPI.IMenuWidget page-open hook).

Tear the list down and invalidate the handle. Safe to call more than once.

Per-frame pump for every live list's keybind polling + prompt strip — call once from OnUpdate.

A mod-launched session is live (armed at launch, cleared at the title menu).

The mod that launched the active session, or null.

The active session is save-less: while it runs (pawn spawned), every save the game attempts is refused through the game's own CanSave gate — no save file is created or touched, and the player's save list is unaffected. Armed only by the ephemeral launch surface (LevelLoader.PlayEphemeral); cleared when the session ends.

Identity of the GameSetup the owning launch planted (its freshly-minted guid), for arrival verification: compare against GameSetup.GetCurrentGameSetup().guid once gameplay is up to prove the arrived session is the launched one. Null for launches without a planted setup.

Raised once when the active session ends (title menu reached, or the early menu-transition signal). Subscribers are isolated: one throwing handler cannot starve the others.

The session has reached gameplay (pawn spawned at least once since launch). Latched — stays true through in-session despawn windows (retry reloads, travel) until the session ends.

The guid of the live session's GameSetup (every setup ctor mints a fresh one — a per-launch identity), or null while unreadable / still all-zeros. Compare with Session.LaunchGuid.

Arm the session at launch-fire time — call immediately after the launch mechanism has actually been invoked, before gameplay arrives.

End the active session from the owning mod's side — for when the owner determines the gameplay that arrived is not the session it launched (identity check failed). Raises Session.Ended exactly like a natural end.

Re-run the page builder and show the result without leaving the page.

Replace the page's visible rows with fields without leaving the page. Safe to call from inside a field callback — the swap is deferred to the next frame so the row that raised the event is not torn down mid-dispatch.

Remove the rail entry. Pages normally live for the mod's lifetime.

Register (or replace) a global effort cost multiplier. Applied uniformly to all limbs via CurrentEffortCostMultiplier. 1.0 = no effect.

Remove a registered global effort scale.

Register (or replace) a per-limb effort scale provider. Callback receives the limb and returns a multiplier for that limb's CurrentEffortCostMultiplier. 1.0 = no effect.

Remove a registered per-limb effort scale provider.

Register (or replace) a global drain speed multiplier. Applied to every limb's _CurrentStaminaConsumptionSpeed after UpdateStaminaState computes it. Only scales positive (draining) values; gaining limbs are not affected. 1.0 = no effect.

Remove a registered global drain scale.

Register (or replace) a per-limb drain speed scale provider. Callback receives the limb and returns a multiplier for that limb's drain rate. Only applied when the limb is draining (consumptionSpeed > 0). 1.0 = no effect.

Remove a registered per-limb drain scale provider.

The live ClimbingTweakablesPackage.Stamina for the local pawn. Fields: baseStamina, staminaGainSpeed, staminaLossSpeed, staminaLossCurve, criticalStaminaStateDuration, punishedCriticalStaminaStateDuration, effortExhaustionThreshold, handRestThreshold, footRestThreshold, handFreeEffortThreshold, footFreeEffortThreshold. Null if not in a session or the package isn't loaded.

Target world position (ignored when Stance.Pose is set — the pose carries its own).

World forward to face on arrival; degenerate values fall back to +Z.

Locomotion mode to arrive in (Walking / Climbing).

Verbatim stance (a CairnAPI.Poses capture). When set, the pose restore owns placement.

The level's default spawn — where THIS session's pawn first spawned, placed through the game's own spawner verb (mode, on-wall start, climbbot handling reproduced natively). A shared sentinel; do not mutate its fields.

True when this is the Stance.Spawn sentinel.

Where this stance puts the pawn (a pose carries its own body position; the spawn sentinel resolves to the session's default spawn).

The rail's root GameObject (a vertical column; size it via its RectTransform).

Build a native selection rail under parent with one entry per label. onPicked fires with the entry index on click / gamepad Submit. onSelected (optional) fires when the highlight moves (hover / gamepad nav). Returns null when the game UI isn't up yet (no chevron/highlight assets to decorate with).

True once built and still alive.

Move the native highlight (chevron + text slide) to an entry, as gamepad nav would.

Focus the first entry (gamepad/keyboard nav anchors here).

Pin an entry as the active tab (the picked-page look: highlight held while the selection roams). Picking an entry pins it automatically; -1 clears the pin.

The pinned tab's index (-1 when none is pinned yet).

Tear the rail down. Safe to call more than once.

A teleport (or a Travel launch riding this pipeline) is in flight.

Move the local climber to destination. Returns "OK" once the job is issued (or completed synchronously), "NOT_IN_SESSION" when there is no world at all, "TRAVEL_IN_FLIGHT" when a cross-level launch owns the slot, or "NO_STANCE" for a null destination. Supersedes any pending plain teleport.

Cancel the pending job without firing its arrival callback. Refuses (no-op) when a Travel launch owns the slot — symmetric with Teleport.To's refusal, so a session-scoped caller (a Boulderdash run teardown) can never destroy an in-flight cross-level launch and strand it. Travel / session teardown that legitimately abandons the journey goes through Teleport.CancelAny.

When the stance is applied: TeleportPlacement.WhenReady (default) waits for the destination to settle (and, for an on-wall stance, for the holds to stream in) before placing; TeleportPlacement.Immediate places at once (for callers holding their own freeze) — but TeleportOptions.OnArrived still defers to readiness. Placement and arrival are separate edges.

Runs on the same frame, immediately before the stance applies — for callers that must prepare the world first (e.g. freeze time so an on-wall placement doesn't fall while the holds subscene is still streaming). The stance is NOT applied yet when it runs.

Runs when the destination is REAL: settled, and (for an on-wall stance) the holds have arrived. The stance is already applied when it fires.

Runs when placement fails: Stance.Apply reported failure twice (once retried on the next tick). The job is cancelled before this fires; TeleportOptions.OnArrived will NOT run. Callers holding their own freeze wire this to stand it down.

Wait for the destination to settle (and its holds, on-wall) before placing.

Place at once, before readiness — for callers parking the pawn under their own freeze.

Queue a toast. Optional icon and background/foreground tints ride the native toast fields; omitted = the toast's authored defaults.

Arrival stance; null = the level's default spawn.

Zone known to own the arrival position, captured when it was recorded; lets a menu launch load the destination's own zone when live resolution is impossible (at the title menu no zone colliders are registered, so a position→zone probe always fails and falls back to the entry zone).

Force a NEW session even when already on the level (e.g. a mode/character change).

Whether the launch starts a fresh save-less session (TravelSession.Ephemeral, default) or preserves the running session and its save (TravelSession.Preserve).

New-session difficulty (TravelSession.Ephemeral only).

New-session character (TravelSession.Ephemeral only).

Session owner (Session.Owner of a launched ephemeral session).

Placement timing handed to the arrival's teleport pipeline (see CairnAPI.TeleportPlacement).

Fires right before the arrival stance is applied, on the same frame (e.g. freeze time so an on-wall start doesn't fall while the holds subscene is still streaming). Not applied yet when it runs.

Runs once the pawn stands on the destination — same call for a same-map hop, after arrival + settle (+ on-wall holds) for a launch. The stance is already applied when it fires.

Runs when the arrival placement fails (see TeleportOptions.OnFailed). The journey is cancelled before it fires; TravelOptions.OnArrived will NOT run.

A NEW save-less session: no save is created or touched, and it ends at the title menu.

The running session and its save are kept — native change-level travel (a member warp, story progression), session and save intact.

No axes.

Hunger decay.

Thirst decay.

Cold decay.

Hit points — over-time decay, damage (falls included), and any write that would lower HP.

Exhaustion buildup from climbing exertion.

Climbing limb stamina drain (regen is unaffected).

Every axis.

Register (or replace) a named freeze covering the given axes. Frozen stats stop draining and cannot be lowered (damage included); raising writes — eating, drinking, warming, healing — still apply.

Remove a registered freeze. Axes no longer covered by any key thaw and the game's own drain multipliers are restored.

The destination's world position (where the pin sorts and where confirm places the pawn).

The row label shown in the eagle-eye list.

The source's own object behind this entry (a Bookmark, a Route, …) — passed back on confirm/edit.

Register a warp source. Pass primary for the built-in default-active source (bookmarks) so it stays the active list regardless of mod load order; others append.

The active source (whose destinations the eagle-eye list currently shows), or null.

How many sources are currently AVAILABLE (a toggle is meaningful only when > 1) — an unavailable source (routes outside a Boulderdash session) is invisible here.

The label of the next AVAILABLE source WarpSources.Toggle would switch to, or null when fewer than two are available — for a "Show " prompt.

Cycle to the next AVAILABLE source and re-materialize its destinations. The open eagle-eye list re-pulls its rows via the Bookmarks.OnRegistryChanged subscription.

Force a re-materialize of the active source's destinations (call after its entries change).

Immediately re-materialize the active source and tell an open list to re-pull — for in-view state flips (the native-entries toggle) where the player is looking at the list and a deferred settle would read as a dead keybind.

Resolve a live warp point back to its owning source + entry, or false for a point that isn't one of ours (a native destination — let the native warp run).

The live loc key rendering a materialized entry's row (for in-view live-rename via Localization.Update), or default when it has no live point.

Live-rename a materialized entry's row without a rebuild (matches by payload identity).

Tear down one materialized entry: unregister, drop its loc key, destroy its GO.

The live weather state (forecast slot 0), or Undefined when no weather system is up.

The forecast (slot 0 = live state, later slots = the barometer's future). Empty when unavailable.

Seconds until the live weather state expires (counts down).

Total duration of the live weather state, in seconds.

Whether the current weather zone derives its weather from an authored time table instead of the forecast. In table zones weather is a pure function of the game clock — change the CairnAPI.Clock to change the sky; Weather.Set declines.

Raised when a weather state is applied (state changes, zone changes, save loads), with the new live WeatherZoneData.WeatherType.

Switch the live weather to type, resolved against the current zone's authored definitions and applied through the weather machine's own trigger — modules transition naturally and the forecast keeps advancing afterwards (nothing is latched). Returns false when the zone is table-driven, the zone can't express the type, or no weather system is up.

Apply a full weather snapshot — forecast types plus the live state's countdown — the way the game's own save-load does: each type is resolved against the LOCAL current zone, the trigger fires only when the live state actually changed, and the timer/duration are restored last. This is the replication verb (CairnCoop's world sync rides it); Weather.Set is the one-shot flavor. Returns false when nothing could be applied (table zone, no weather system, or slot 0 unresolvable in this zone).

The live state's rain component (None / Rain_Small / Rain_Heavy).

The live state's thunder component (None / Thunder_Far / Thunder_Close).

The live state's fog component (None / Fog_InsideCloud).

The live state's clouds component (None / Clouds_Small / Clouds_Heavy).

Live snow intensity, 0..1 (precipitation renders as snow at altitude/temperature).

How far precipitation currently leans to snow instead of rain, 0..1.

Force precipitation to render as snow or rain regardless of altitude/temperature, or None to restore the game's own choice.

Live wind strength (the value gameplay and cloth react to).

Live gust multiplier layered on Weather.WindForce.

Live wind direction (normalized, world-space).

The barometer's current score, 0 (storm) .. 1 (clear) — what the in-game barometer shows.

Force a fog layer over everything (opacity 0..1), independent of the weather state — the game's own forced-fog lever (it uses it on the avalanche summit). Call Weather.ClearForcedFog to release it.

Release the forced fog layer set by Weather.ForceFog.

The active world the StreamingManager is currently streaming, or null pre-gameplay.

The identity key of the current map — a shipped mountain's world name (e.g. "Kami"), or a custom level's "cml:" address. Null when not in a level. Map-bound data (bookmarks, routes) binds to this.

The identity key a level will have once loaded — the same rule as World.CurrentMapKey, resolved from the descriptor instead of the live world. Null for a null descriptor.

Where this session's pawn first spawned — the level's default spawn (the switcher's SpawnedFrom). Null off-gameplay. Session-relative by design: it works in ANY session, not just a mod-launched one.

Every authored world, resident even when only one is streamed (from StreamingTweakables).

Every zone of a world (its authored ZoneSceneData list).

Find a zone by its asset name (e.g. "01_FirstRidge") within a world.

The world that owns a zone (by identity scan over the catalog), or null.

Float a prompt over anchor. text is shown as-is, glyph is the button icon (see CairnAPI.Glyph, null = none). style tunes the float distance / wall-stick and whether it follows a moving anchor (null = the close default, ~1/3 of the game's wall-mount distance — live-tuned). Returns a handle for WorldPrompt.Hide. This drives our OWN widget, so a new Show replaces the previous mod prompt on it (one mod world prompt at a time); the game's own world prompts are untouched.

Remove a world prompt. Safe on an invalid / already-hidden handle.

OUR OWN world-prompt widget — a lazily-BUILT WorldGameplayPromptUI (from scratch, no clone), so a mod prompt coexists with the game's own in-world prompts instead of clobbering the single shared widget. Null before in-game UI init (the build needs the game's fonts/materials/sprites loaded).

Configure a world-prompt TMP so PLAIN text (written by us or the glyph component) routes to a TMP_SubMeshUI and renders through the after-image pass: fontStyle=Bold → Boxed-DemiBold SDF (index ≥1). A component-level property, so it survives the glyph's per-frame raw text writes — no tag-wrapping.

Construct a fresh, independent WorldGameplayPromptUI under GlobalUIs (DontDestroyOnLoad). Returns the live component (Awake/OnEnable have run; the widget self-hides until Display), or null pre-asset-load (the build needs the game's fonts/materials/sprites loaded) or on any construction failure.

Anchor radius. Game default 0.25; we use ~0.083.

Wall-stick push offset. Game default 0.2; we use ~0.067 (small = stays near the anchor).

Max height it floats to. Game default 1.3; we use ~0.43.

Height above the anchor. Game default 0.2; we use ~0.067.

Flip vertically.

Whether the prompt follows a moving anchor. true → a per-frame position pump; false → zero pump.

The close default (~1/3 of the game's wall-mount distance).