@threenative/core 0.2.0 → 0.3.0

package/capabilities.json

@@ -0,0 +1,3542 @@
+{
+  "entries": [
+    {
+      "constraints": [
+        "name the body a game moves as strideRoot when the animated rig is a child of it",
+        "a one-shot clip always plays at its authored rate; the matched rate re-times loops only"
+      ],
+      "example": "const player = new AnimationPlayer({ clips, root: rig, strideRoot: body });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [
+        "strideSync controls whether the matched rate is applied while stride is still measured"
+      ],
+      "package": "@threenative/core",
+      "signature": "export class AnimationPlayer { … }",
+      "situations": [
+        "play an animation on a character",
+        "switch a character between idle and attack clips",
+        "stop a walking character's feet from sliding or spinning",
+        "match a walk or run cycle to how fast a character is moving"
+      ],
+      "summary": "Play a skinned or sprite animation from game code. A travelling clip's playback rate is matched to the ground the body actually covers, so feet do not skate or spin — on by default, `strideSync: false` to keep the authored rate, and `player.stride` reports the measurement either way. Name the body a game moves as `strideRoot` when the rig is a child of it.",
+      "supersedes": [],
+      "symbol": "AnimationPlayer"
+    },
+    {
+      "constraints": [
+        "supply rayleigh, mie, ozone, planetRadius, and atmosphereRadius; there is no Earth fallback",
+        "the game creates the sky object, surface, and sun from the returned nodes"
+      ],
+      "example": "const atmosphere = new Atmosphere({ rayleigh, mie, ozone, planetRadius, atmosphereRadius });\nctx.add(atmosphere);",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class Atmosphere extends Group implements IComputeDriven { … }",
+      "situations": [
+        "render a sunrise that changes as time and place change",
+        "add distance haze from the depth of a scene pass"
+      ],
+      "summary": "Own the compute lifetime and expose only parameter-driven atmosphere nodes. The class deliberately creates no mesh, material, or scene light. A template chooses all of those, and the same object remains useful when a game supplies a completely different look.",
+      "supersedes": [],
+      "symbol": "Atmosphere"
+    },
+    {
+      "constraints": ["supply all physical parameters; this class creates no scene appearance"],
+      "example": "const luts = new AtmosphereLuts({ rayleigh, mie, ozone, planetRadius, atmosphereRadius });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class AtmosphereLuts { … }",
+      "situations": ["bake the three atmosphere LUTs once before a game shows its world"],
+      "summary": "Own the transmittance, multi-scattering, and sky-view compute lookup textures.",
+      "supersedes": [],
+      "symbol": "AtmosphereLuts"
+    },
+    {
+      "constraints": [
+        "when a request is to hold or attach a weapon to a hand, import and call `attachToBone` from `@threenative/core`; do not manually parent, position, or rotate the rifle",
+        "if a stock visual has no skeleton, add a portable Three.js Bone named `RightHand` under the character, then call `attachToBone`; do not replace the helper with manual parenting"
+      ],
+      "example": "import { attachToBone } from \"@threenative/core\";\nattachToBone(character, \"RightHand\", rifle);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function attachToBone(root: Object3D, boneName: string, child: Object3D): Object3D { … }",
+      "situations": [
+        "put a weapon in a character's hand",
+        "hold a rifle in a character's right hand",
+        "add an enemy that patrols the level, chases the player when it sees them, and holds a rifle in its right hand",
+        "attach an accessory to a skinned model",
+        "equip crew with swords and pistols",
+        "put a sword or pistol in a crew member's hand"
+      ],
+      "summary": "Attach a game-owned object to a named skeleton bone.",
+      "supersedes": [],
+      "symbol": "attachToBone"
+    },
+    {
+      "constraints": [
+        "create buses before playing clips and dispose them with the game",
+        "refDistance and rolloffFactor tune positional falloff and apply to playAt only"
+      ],
+      "example": "const effects = new AudioBus({ camera });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class AudioBus { … }",
+      "situations": [
+        "play a sound effect with a volume bus",
+        "mute or adjust a category of game audio",
+        "keep a gunshot audible at 20 metres by tuning positional falloff",
+        "play cannon, wave, and ship sound effects"
+      ],
+      "summary": "Route effects through a named audio bus.",
+      "supersedes": ["new Audio("],
+      "symbol": "AudioBus"
+    },
+    {
+      "constraints": [
+        "call update from the owning scene; no global scene scan is installed",
+        "orthographic cameras use their forward direction, and lockAxis restricts world rotation"
+      ],
+      "example": "const billboard = new Billboard3D(label, { camera });\nbillboard.update();",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class Billboard3D { … }",
+      "situations": [
+        "keep a world-space marker or nameplate facing the camera",
+        "billboard a tree, label, or effect under a rotated parent"
+      ],
+      "summary": "Face a game-owned object toward a perspective or orthographic camera.",
+      "supersedes": [],
+      "symbol": "Billboard3D"
+    },
+    {
+      "constraints": [
+        "amplitude, rotationAmplitude, frequency, decay, and curve are required game choices",
+        "update returns an offset and never writes to a camera"
+      ],
+      "example": "const shake = new CameraShake({ amplitude, rotationAmplitude, frequency, decay, curve });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class CameraShake { … }",
+      "situations": [
+        "add a hit, explosion, or landing shake to a camera",
+        "compose a transient camera offset after camera damping"
+      ],
+      "summary": "Produce a game-authored camera shake offset for a template-owned camera rig.",
+      "supersedes": [],
+      "symbol": "CameraShake"
+    },
+    {
+      "constraints": [],
+      "example": "const hud = new CanvasLayer({ camera });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class CanvasLayer { … }",
+      "situations": [
+        "place a HUD layer above the Three.js scene",
+        "attach a canvas layer to a camera"
+      ],
+      "summary": "Manage a camera or screen-facing canvas layer.",
+      "supersedes": [],
+      "symbol": "CanvasLayer"
+    },
+    {
+      "constraints": [
+        "the body's geometry must carry a cluster table from `assets.models.virtual`",
+        "every copy is placed before build(); place() after build() throws"
+      ],
+      "example": "const boulders = new ClusteredBatch({ geometry, material, table });\nboulders.place({ position: [x, y, z], rotation: [0, angle, 0] });\nboulders.build({ name: \"boulders\", parent: ctx.scene });\n// in the scene's update, before the render:\nboulders.update(ctx.camera, ctx.renderer.domElement.height);",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [
+        "distanceRatio sets how wide one distance group is, default 1.25",
+        "errorPixels sets the screen-space error budget, default 1 pixel"
+      ],
+      "package": "@threenative/core",
+      "signature": "export class ClusteredBatch { … }",
+      "situations": [
+        "draw hundreds of copies of a scanned or sculpted body without hundreds of draw calls",
+        "stop distant copies of a dense prop from costing their full triangle count"
+      ],
+      "summary": "Draw many copies of one over-detailed body, each at the detail its own distance earns. `InstancedBatch` collapses repeated props into one draw and gives every copy the same triangles. This gives a copy two hundred metres away a coarser cut than one twelve metres away, and still submits one draw per distance group rather than one per copy — which is what makes four hundred scanned boulders affordable. The shape, the surface and every transform stay the game's.",
+      "supersedes": [],
+      "symbol": "ClusteredBatch"
+    },
+    {
+      "constraints": [
+        "the bake happens in the asset pipeline, never at run time — there is no runtime flag",
+        "the payload costs about 3-4x a baked primitive's bytes; `assets.models.virtual: \"none\"` opts out and `minSourceTriangles` moves the 65,536 line",
+        "needs a perspective camera; a screen-space error has no meaning without one",
+        "one shadow cut is chosen at load and does not follow a shadow camera"
+      ],
+      "example": "// Nothing to call: the loader returns one of these and the engine cuts it every frame.\nconst face = await ctx.assets.model(\"quarry-face.glb\");\nctx.scene.add(face.scene);",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [
+        "errorPixels sets the screen-space error budget, default 1 pixel",
+        "recutDistance sets how far the camera moves before the cut is retaken, default a thousandth of the mesh's radius"
+      ],
+      "package": "@threenative/core",
+      "signature": "export class ClusteredMesh extends Mesh { … }",
+      "situations": [
+        "draw a model too detailed for the screen to resolve",
+        "import a scanned or sculpted mesh of millions of triangles and still hold the frame",
+        "stop a dense rock face or terrain body from costing its full triangle count up close"
+      ],
+      "summary": "Draw a model too detailed for the screen to resolve, without submitting the part it cannot. **This is on, and a game does not call it.** Any primitive of 65,536 triangles or more bakes to a cluster DAG in the asset pipeline, the loader returns a `ClusteredMesh` for it, and the engine takes the cut every frame before it renders. Each frame the mesh submits one draw holding only the clusters whose error projects to fewer than `errorPixels` screen pixels; a mesh nothing has cut yet draws in full, so the worst case is an ordinary `Mesh`. Geometry, surface and every appearance parameter stay the game's.",
+      "supersedes": [],
+      "symbol": "ClusteredMesh"
+    },
+    {
+      "constraints": [
+        "add the object through ctx.add so it attaches, dispatches, and releases with its scene"
+      ],
+      "example": "class Cloth extends Mesh implements IComputeDriven { ... }",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class ComputeDrivenRegistry { … }",
+      "situations": [
+        "use IComputeDriven for a cloth, fluid, boid, or other GPU simulation",
+        "run a cloth or fluid simulation with ordered GPU passes",
+        "keep IComputeDriven kernels warm before the first visible frame"
+      ],
+      "summary": "Register game-owned IComputeDriven objects with the shared compute lifetime.",
+      "supersedes": [],
+      "symbol": "ComputeDrivenRegistry"
+    },
+    {
+      "constraints": [
+        "reuse the loader handed to scenes as `ctx.assets` instead of building parallel caches"
+      ],
+      "example": "const assets = createAssetLoader({ basePath: \"/assets\" });\nconst rock = await assets.texture(\"rock.png\");",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function createAssetLoader(options: IAssetLoaderOptions = { … }",
+      "situations": [
+        "preload models, textures, or audio before a scene enters",
+        "load assets from a nonstandard base path or a compiled asset manifest"
+      ],
+      "summary": "Create the portable asset loader a scene also receives as `ctx.assets`.",
+      "supersedes": [],
+      "symbol": "createAssetLoader"
+    },
+    {
+      "constraints": ["use the returned source instead of Math.random for replayable behavior"],
+      "example": "const random = createRandom(42);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function createRandom(seed?: number): IRandom { … }",
+      "situations": [
+        "seed enemy patrol choices",
+        "reproduce the same procedural level in a playtest"
+      ],
+      "summary": "Create a deterministic random source for portable gameplay.",
+      "supersedes": ["Math.random("],
+      "symbol": "createRandom"
+    },
+    {
+      "constraints": [
+        "use a seeded random source and fixed-step simulation for meaningful replays"
+      ],
+      "example": "const driver = createReplayDriver({ recording });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function createReplayDriver( recording: Recording, target: EventTarget, pointerTarget = target, ) { … }",
+      "situations": [
+        "reproduce a gameplay bug from recorded input",
+        "run a deterministic replay in a playtest"
+      ],
+      "summary": "Record or replay deterministic game input and state.",
+      "supersedes": [],
+      "symbol": "createReplayDriver"
+    },
+    {
+      "constraints": [
+        "keep DOM and React mounting in src/main.ts",
+        "bind scroll or pinch and read the intent with ctx.input.axis(name); do not add a window wheel listener",
+        "scroll: true uses the DOM wheel sign on browser and native: negative deltaY toward the user is positive intent"
+      ],
+      "example": "const game = defineGame({ input: { zoom: { scroll: true, pinch: true } }, scenes: { Play } });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function defineGame<TState extends Record<string, unknown>, TPhysics = undefined>( config: IGameConfig<TState, TPhysics>, ): IGame<TState, TPhysics> { … }",
+      "situations": [
+        "start a ThreeNative game from src/game.ts",
+        "register physics and gameplay plugins",
+        "let the player zoom the camera with a wheel, pinch, or gamepad axis"
+      ],
+      "summary": "Define the portable game entry shared by web and native.",
+      "supersedes": [],
+      "symbol": "defineGame"
+    },
+    {
+      "constraints": ["pass a non-zero direction; coefficients and radii come from the game"],
+      "example": "const transmittance = directionalTransmittance(parameters, sunDirection);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function directionalTransmittance( parameters: IAtmosphereParameters | IResolvedAtmosphereParameters, direction: Vector3, ): Vector3 { … }",
+      "situations": ["colour a game-owned sun from atmosphere extinction"],
+      "summary": "Approximate direct transmittance for a ray leaving the game surface.",
+      "supersedes": [],
+      "symbol": "directionalTransmittance"
+    },
+    {
+      "constraints": ["elevation and azimuth must be finite degrees"],
+      "example": "const direction = directionFromSolarPosition(sun.elevation, sun.azimuth);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function directionFromSolarPosition(elevation: number, azimuth: number): Vector3 { … }",
+      "situations": ["aim a template's sun from solarPosition output"],
+      "summary": "Convert solar elevation and azimuth degrees into a normalized Three.js direction.",
+      "supersedes": [],
+      "symbol": "directionFromSolarPosition"
+    },
+    {
+      "constraints": [
+        "call `VelocityTracker.update()` before the render and `commit()` after it",
+        "a pass is only given a velocity target when a temporal stage consumes it",
+        "call only when a temporal stage is active"
+      ],
+      "example": "const scenePass = pass(scene, camera);\nensureVelocityOutput(scenePass);\nrenderer.setOutputNode(scenePass);\nconst tracker = new VelocityTracker();\ntracker.update(scene);\nrenderer.render(scene, camera);\ntracker.commit(scene);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function ensureVelocityOutput(pass: IVelocityRenderPass): MRTNode { … }",
+      "situations": [
+        "keep a skinned character or instanced crowd stable in a temporal stage",
+        "add the velocity output to a Three.js scene pass",
+        "add a velocity target before a temporal stage consumes a scene pass"
+      ],
+      "summary": "Provision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.",
+      "supersedes": [],
+      "symbol": "ensureVelocityOutput"
+    },
+    {
+      "constraints": [
+        "add the field through `ctx.add` so renderer attachment, fixed-step dispatch, and release are automatic",
+        "`dye` and `velocity` are numeric samplers; appearance stays in the game's `src/render/` code",
+        "the conformance sample measures mean absolute velocity divergence at 0.001732 after four 32² steps with pressureIterations 2, below the 0.0025 threshold"
+      ],
+      "example": "const field = new FluidField2D({ resolution: 256, pressureIterations: 20 });\nctx.add(field);\nfield.splat({ x: 0.5, y: 0.5 }, { x: 0.2, y: 0 }, 1);",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [
+        "pressureIterations, viscosity, vorticity, and splatRadius tune the solver without changing its pass order"
+      ],
+      "package": "@threenative/core",
+      "signature": "export class FluidField2D extends Group { … }",
+      "situations": [
+        "simulate smoke, fire, fog, wind, or fluid response on a grid",
+        "inject a touch, pointer, or gameplay impulse into a fluid field",
+        "sample fluid dye or velocity in a game-owned render node",
+        "simulate ocean currents and wind affecting a sailing ship",
+        "simulate ocean fluid dynamics and currents that affect a ship"
+      ],
+      "summary": "Simulate a deterministic 2D velocity-and-dye field on the GPU while exposing its data to game-owned rendering.",
+      "supersedes": [],
+      "symbol": "FluidField2D"
+    },
+    {
+      "constraints": [
+        "on by default and printed as TN_FRAME_BUDGET; defineGame({ frameBudget: false }) silences the marker, not the measurement"
+      ],
+      "example": "defineGame({ frameBudget: { reportEvery: 120 }, scenes: { Play } });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class FrameBudget { … }",
+      "situations": [
+        "find out why a game runs slowly on a phone",
+        "attribute a frame to present wait, simulation, three.js render, or overlay"
+      ],
+      "summary": "Read where the frame's milliseconds went, per presented frame, on any platform.",
+      "supersedes": [],
+      "symbol": "FrameBudget"
+    },
+    {
+      "constraints": [
+        "only use the returned platform facts; native globals are host-owned",
+        "ray tracing is unavailable on native until buffer-to-texture copy-out interop exists; `mystralRT.traceRays` refuses instead of resolving success without a readable result"
+      ],
+      "example": "if (isMobile()) showTouchControls();",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function getPlatform(): Readonly<IPlatformInfo> { … }",
+      "situations": [
+        "branch a portable game on web or native",
+        "choose touch controls for a mobile device",
+        "can I raytrace on native"
+      ],
+      "summary": "Read the host platform without reaching for browser globals.",
+      "supersedes": [],
+      "symbol": "getPlatform"
+    },
+    {
+      "constraints": ["geometry, color, and timing remain supplied by the game"],
+      "example": "const particles = new GPUParticles3D(particleOptions);",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class GPUParticles3D extends Sprite implements IComputeDriven { … }",
+      "situations": [
+        "emit sparks, smoke, or other transient effects",
+        "update many small visual particles",
+        "emit cannon smoke and muzzle flash particles",
+        "fire a cannonball projectile with cannon smoke particles"
+      ],
+      "summary": "Dispatch a game-owned particle surface and process function through a pooled system.",
+      "supersedes": [],
+      "symbol": "GPUParticles3D"
+    },
+    {
+      "constraints": [
+        "the copy is asynchronous, so every sample carries staleFrames and is never this frame",
+        "WebGPU only; the seam throws on a WebGL2 renderer rather than returning nothing",
+        "one copy is in flight at a time and requests made during one are dropped, not queued"
+      ],
+      "example": "const heights = new GPUReadback({ attribute: field.value, everyFrames: 4 });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class GPUReadback { … }",
+      "situations": [
+        "read a GPU simulation on the CPU without stalling the frame",
+        "float a body on a wave field whose height only exists on the GPU",
+        "count GPU-side survivors for a diagnostic without blocking drawing",
+        "keep a ship floating on simulated ocean waves"
+      ],
+      "summary": "Copy a GPU buffer back to the CPU on a throttle, and report how old each sample is.",
+      "supersedes": [],
+      "symbol": "GPUReadback"
+    },
+    {
+      "constraints": [
+        "call rebuild() after a scene transform or geometry change; the snapshot is static by default",
+        "rebuild() is an explicit CPU SAH build proportional to selected triangles; process() is a no-op, and the game pays upstream traversal per shader ray"
+      ],
+      "example": "const bvh = ctx.add(new GPUSceneBVH(ctx.scene, { include: (object) => object.userData.traceable === true }));",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class GPUSceneBVH extends Group implements IComputeDriven { … }",
+      "situations": [
+        "trace thousands of scene rays inside a TSL kernel",
+        "build a contact-occlusion or visibility query over loaded meshes"
+      ],
+      "summary": "Pack a selected static scene into TSL storage nodes for an upstream BVH ray query.",
+      "supersedes": [],
+      "symbol": "GPUSceneBVH"
+    },
+    {
+      "constraints": [
+        "import from `@threenative/core`; this moves the rendered model, not its physics collider"
+      ],
+      "example": "import { GroundSnap } from \"@threenative/core\";\nconst snap = new GroundSnap(character, { enabled: true });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [
+        "enabled controls whether correction is applied while clearance is still measured"
+      ],
+      "package": "@threenative/core",
+      "signature": "export class GroundSnap { … }",
+      "situations": [
+        "keep a character's feet on the floor",
+        "correct visual grounding after an animation update"
+      ],
+      "summary": "Keep a rendered model's feet on a surface while preserving an auditable override.",
+      "supersedes": [],
+      "symbol": "GroundSnap"
+    },
+    {
+      "constraints": [
+        "geometry and material are required and come from the game; the batch chooses neither",
+        "span stretches along +Y, so its geometry must be unit-height and centred on the origin",
+        "placing after build() throws, and build() returns undefined when nothing was placed"
+      ],
+      "example": "const curbs = new InstancedBatch({ geometry: new BoxGeometry(1, 1, 1), material });\ncurbs.place({ position: [x, 0.08, z], rotation: [0, angle, 0], scale: [length, 0.18, 0.42] });\ncurbs.build({ castShadow: true, name: \"curbs\", parent: ctx.scene });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [
+        "castShadow and receiveShadow pass through to the built mesh and default to Three.js's own false"
+      ],
+      "package": "@threenative/core",
+      "signature": "export class InstancedBatch { … }",
+      "situations": [
+        "draw hundreds of repeated props without hundreds of draw calls",
+        "place repeated props when the count is not known until the layout has been walked",
+        "build a chain, railing, cable, or tie rod out of point-to-point segments"
+      ],
+      "summary": "Collapse many copies of one game-authored shape into a single draw, without counting them first. `new InstancedMesh(geometry, material, count)` needs the count before anything is placed, so a procedural builder ends up walking its layout twice or over-allocating. Place as you go and `build()` once; the shape, the surface and every transform stay the game's, and the built mesh is returned so instances can still be animated by the index `place` and `span` hand back.",
+      "supersedes": [],
+      "symbol": "InstancedBatch"
+    },
+    {
+      "constraints": [
+        "only use the returned platform facts; native globals are host-owned",
+        "ray tracing is unavailable on native until buffer-to-texture copy-out interop exists; `mystralRT.traceRays` refuses instead of resolving success without a readable result"
+      ],
+      "example": "if (isMobile()) showTouchControls();",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function isMobile(): boolean { … }",
+      "situations": [
+        "branch a portable game on web or native",
+        "choose touch controls for a mobile device",
+        "can I raytrace on native"
+      ],
+      "summary": "Read the host platform without reaching for browser globals.",
+      "supersedes": [],
+      "symbol": "isMobile"
+    },
+    {
+      "constraints": [
+        "only use the returned platform facts; native globals are host-owned",
+        "ray tracing is unavailable on native until buffer-to-texture copy-out interop exists; `mystralRT.traceRays` refuses instead of resolving success without a readable result"
+      ],
+      "example": "if (isMobile()) showTouchControls();",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function isNative(): boolean { … }",
+      "situations": [
+        "branch a portable game on web or native",
+        "choose touch controls for a mobile device",
+        "can I raytrace on native"
+      ],
+      "summary": "Read the host platform without reaching for browser globals.",
+      "supersedes": [],
+      "symbol": "isNative"
+    },
+    {
+      "constraints": [
+        "only use the returned platform facts; native globals are host-owned",
+        "ray tracing is unavailable on native until buffer-to-texture copy-out interop exists; `mystralRT.traceRays` refuses instead of resolving success without a readable result"
+      ],
+      "example": "if (isMobile()) showTouchControls();",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function isTouchscreenAvailable(): boolean { … }",
+      "situations": [
+        "branch a portable game on web or native",
+        "choose touch controls for a mobile device",
+        "can I raytrace on native"
+      ],
+      "summary": "Read the host platform without reaching for browser globals.",
+      "supersedes": [],
+      "symbol": "isTouchscreenAvailable"
+    },
+    {
+      "constraints": [
+        "only use the returned platform facts; native globals are host-owned",
+        "ray tracing is unavailable on native until buffer-to-texture copy-out interop exists; `mystralRT.traceRays` refuses instead of resolving success without a readable result"
+      ],
+      "example": "if (isMobile()) showTouchControls();",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function isWeb(): boolean { … }",
+      "situations": [
+        "branch a portable game on web or native",
+        "choose touch controls for a mobile device",
+        "can I raytrace on native"
+      ],
+      "summary": "Read the host platform without reaching for browser globals.",
+      "supersedes": [],
+      "symbol": "isWeb"
+    },
+    {
+      "constraints": ["precise per-vertex measurement is opt-in and not for frame loops"],
+      "example": "const measurement = measureThreePose(model);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function measureThreePose( object: Object3D, options: IMeasureThreePoseOptions = { … }",
+      "situations": ["inspect a skinned model's posed bounds", "verify a character's visual pose"],
+      "summary": "Measure a Three.js pose for grounded or attachment-aware checks.",
+      "supersedes": [],
+      "symbol": "measureThreePose"
+    },
+    {
+      "constraints": [
+        "skinned height uses a crown bone; game-specific asset expectations stay in render code"
+      ],
+      "example": "normaliseToMetres(character, { metres: 1.8, axis: \"height\" });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function normaliseToMetres(object: Object3D, options: INormaliseToMetresOptions): number { … }",
+      "situations": [
+        "make a character exactly 1.8 metres tall",
+        "normalize a prop or weapon to a known longest axis"
+      ],
+      "summary": "Scale an asset to a real-world measurement and return the applied factor.",
+      "supersedes": ["new Box3().setFromObject("],
+      "symbol": "normaliseToMetres"
+    },
+    {
+      "constraints": ["recordings are version 1; the parser fails closed with TN_REPLAY_* codes"],
+      "example": "const recording = parseReplayRecording(rawRecording);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function parseReplayRecording(value: unknown): IReplayRecording { … }",
+      "situations": ["validate a recording before replaying it in another host"],
+      "summary": "Validate and parse a replay recording file.",
+      "supersedes": [],
+      "symbol": "parseReplayRecording"
+    },
+    {
+      "constraints": [],
+      "example": "const follower = new PathFollow3D(curve, { loop: true });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class PathFollow3D { … }",
+      "situations": [
+        "move an enemy or prop along a patrol path",
+        "sample a racing line from a curve"
+      ],
+      "summary": "Move an object along a Three.js curve with Godot-style path following.",
+      "supersedes": [],
+      "symbol": "PathFollow3D"
+    },
+    {
+      "constraints": [
+        "listeners are side-table registrations; Three.js prototypes are never patched",
+        "one raycast serves each active pointer and no raycast runs when nothing is registered"
+      ],
+      "example": "ctx.pointer.on(tile, \"tapped\", (event) => place(event.point));",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class PointerEvents3D implements IPointerEvents3D { … }",
+      "situations": [
+        "let the player click on a thing in the world",
+        "show a 3D object while a pointer hovers over it",
+        "handle touch and mouse taps on a loaded model without naming its child meshes"
+      ],
+      "summary": "Dispatch portable pointer events from the game surface to registered Three.js objects.",
+      "supersedes": [],
+      "symbol": "PointerEvents3D"
+    },
+    {
+      "constraints": ["precise per-vertex measurement is opt-in and not for frame loops"],
+      "example": "const measurement = measureThreePose(model);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function posedBounds(root: Object3D, meshes?: readonly Object3D[]): IThreePoseBounds { … }",
+      "situations": ["inspect a skinned model's posed bounds", "verify a character's visual pose"],
+      "summary": "Measure a Three.js pose for grounded or attachment-aware checks.",
+      "supersedes": [],
+      "symbol": "posedBounds"
+    },
+    {
+      "constraints": [
+        "keep the surface visible with zero opacity; do not hide it with `visible = false`"
+      ],
+      "example": "prewarm(tracerPool);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function prewarm(object: Object3D | readonly Object3D[]): void { … }",
+      "situations": [
+        "prewarm a projectile, tracer, particle, or other transient effect",
+        "avoid a long first-use frame for a newly visible effect"
+      ],
+      "summary": "Keep transient render surfaces in the renderer's pipeline cache before first use.",
+      "supersedes": [".visible = false"],
+      "symbol": "prewarm"
+    },
+    {
+      "constraints": [
+        "request a bake after static geometry and lights are authored; this is static-lighting-first, not fully dynamic relighting",
+        "add the volume with ctx.add() so its incremental work is measured in the render phase",
+        "call sample() or sampleNode() from a game-owned material before screen-space GI; the volume owns no light, material, or colour"
+      ],
+      "example": "const probes = new ProbeVolume({ bounds, density: 0.5 }); ctx.add(probes); void probes.requestBake(scene);",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": ["density, bounds, bakeBudgetMs, and bounces are game-owned choices"],
+      "package": "@threenative/core",
+      "signature": "export class ProbeVolume extends Object3D implements IComputeDriven { … }",
+      "situations": [
+        "light bouncing from a room I cannot see",
+        "light a wall with an off-screen emitter"
+      ],
+      "summary": "Bake static diffuse irradiance that reaches surfaces from outside the camera view.",
+      "supersedes": [],
+      "symbol": "ProbeVolume"
+    },
+    {
+      "constraints": [
+        "request a bake after static geometry and lights are authored; this is static-lighting-first, not fully dynamic relighting",
+        "add the volume with ctx.add() so its incremental work is measured in the render phase",
+        "call sample() or sampleNode() from a game-owned material before screen-space GI; the volume owns no light, material, or colour"
+      ],
+      "example": "const probes = new ProbeVolume({ bounds, density: 0.5 }); ctx.add(probes); void probes.requestBake(scene);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": ["density, bounds, bakeBudgetMs, and bounces are game-owned choices"],
+      "package": "@threenative/core",
+      "signature": "export function readProbeVolumeObservation(value: unknown): IProbeVolumeObservation | undefined { … }",
+      "situations": [
+        "light bouncing from a room I cannot see",
+        "light a wall with an off-screen emitter"
+      ],
+      "summary": "Bake static diffuse irradiance that reaches surfaces from outside the camera view.",
+      "supersedes": [],
+      "symbol": "readProbeVolumeObservation"
+    },
+    {
+      "constraints": ["stage factories own colour, strength, and all other appearance choices"],
+      "example": "const chain = new RenderChain(renderer, { input: colour, stages, request: { stages: [\"bloom\"], tier: \"auto\" } });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function readRenderChainObservation( renderer: unknown, ): IRenderChainMarker[\"applied\"] | undefined { … }",
+      "situations": [
+        "compose screen-space effects in a canonical order",
+        "report which render tier and velocity route actually ran"
+      ],
+      "summary": "Compose game-provided render nodes in a measured, fail-closed chain.",
+      "supersedes": [],
+      "symbol": "readRenderChainObservation"
+    },
+    {
+      "constraints": [
+        "stage factories own colour, strength, and all other appearance choices",
+        "an absent value means no chain was installed and must fail a chain assertion"
+      ],
+      "example": "const chain = new RenderChain(renderer, { input: colour, stages, request: { stages: [\"bloom\"], tier: \"auto\" } });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function readRenderChainReport(renderer: unknown): IRenderChainMarker | undefined { … }",
+      "situations": [
+        "compose screen-space effects in a canonical order",
+        "report which render tier and velocity route actually ran",
+        "expose the render tier and dropped-stage reasons to a playtest",
+        "inspect whether a temporal pass received velocity"
+      ],
+      "summary": "Compose game-provided render nodes in a measured, fail-closed chain.",
+      "supersedes": [],
+      "symbol": "readRenderChainReport"
+    },
+    {
+      "constraints": [
+        "call `VelocityTracker.update()` before the render and `commit()` after it",
+        "a pass is only given a velocity target when a temporal stage consumes it"
+      ],
+      "example": "const scenePass = pass(scene, camera);\nensureVelocityOutput(scenePass);\nrenderer.setOutputNode(scenePass);\nconst tracker = new VelocityTracker();\ntracker.update(scene);\nrenderer.render(scene, camera);\ntracker.commit(scene);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function readVelocityPreviousBoneMatrices(object: Object3D): Float32Array | undefined { … }",
+      "situations": [
+        "keep a skinned character or instanced crowd stable in a temporal stage",
+        "add the velocity output to a Three.js scene pass",
+        "inspect the previous skinned pose at a renderer adapter boundary"
+      ],
+      "summary": "Provision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.",
+      "supersedes": [],
+      "symbol": "readVelocityPreviousBoneMatrices"
+    },
+    {
+      "constraints": [
+        "call `VelocityTracker.update()` before the render and `commit()` after it",
+        "a pass is only given a velocity target when a temporal stage consumes it"
+      ],
+      "example": "const scenePass = pass(scene, camera);\nensureVelocityOutput(scenePass);\nrenderer.setOutputNode(scenePass);\nconst tracker = new VelocityTracker();\ntracker.update(scene);\nrenderer.render(scene, camera);\ntracker.commit(scene);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function readVelocityPreviousMatrices(object: Object3D): Float32Array | undefined { … }",
+      "situations": [
+        "keep a skinned character or instanced crowd stable in a temporal stage",
+        "add the velocity output to a Three.js scene pass",
+        "inspect the previous instance frame at a renderer adapter boundary"
+      ],
+      "summary": "Provision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.",
+      "supersedes": [],
+      "symbol": "readVelocityPreviousMatrices"
+    },
+    {
+      "constraints": [
+        "call `VelocityTracker.update()` before the render and `commit()` after it",
+        "a pass is only given a velocity target when a temporal stage consumes it"
+      ],
+      "example": "const scenePass = pass(scene, camera);\nensureVelocityOutput(scenePass);\nrenderer.setOutputNode(scenePass);\nconst tracker = new VelocityTracker();\ntracker.update(scene);\nrenderer.render(scene, camera);\ntracker.commit(scene);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function readVelocityPreviousWorldMatrix(object: Object3D): Matrix4 | undefined { … }",
+      "situations": [
+        "keep a skinned character or instanced crowd stable in a temporal stage",
+        "add the velocity output to a Three.js scene pass",
+        "inspect the previous rigid transform at a renderer adapter boundary"
+      ],
+      "summary": "Provision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.",
+      "supersedes": [],
+      "symbol": "readVelocityPreviousWorldMatrix"
+    },
+    {
+      "constraints": ["stage factories own colour, strength, and all other appearance choices"],
+      "example": "const chain = new RenderChain(renderer, { input: colour, stages, request: { stages: [\"bloom\"], tier: \"auto\" } });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class RenderChain { … }",
+      "situations": [
+        "compose screen-space effects in a canonical order",
+        "report which render tier and velocity route actually ran"
+      ],
+      "summary": "Compose game-provided render nodes in a measured, fail-closed chain.",
+      "supersedes": [],
+      "symbol": "RenderChain"
+    },
+    {
+      "constraints": [
+        "use a seeded random source and fixed-step simulation for meaningful replays"
+      ],
+      "example": "const driver = createReplayDriver({ recording });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function replay< TState extends Record<string, unknown> = Record<string, unknown>, TPhysics = undefined, >(options: IReplayOptions = { … }",
+      "situations": [
+        "reproduce a gameplay bug from recorded input",
+        "run a deterministic replay in a playtest"
+      ],
+      "summary": "Record or replay deterministic game input and state.",
+      "supersedes": [],
+      "symbol": "replay"
+    },
+    {
+      "constraints": [
+        "every width and height must be a positive integer; the dimensions are not a named fidelity tier"
+      ],
+      "example": "const resolutions = resolveAtmosphereLutResolutions({ skyView: { width: 128, height: 72 } });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function resolveAtmosphereLutResolutions( resolutions: Partial<IAtmosphereLutResolutions> | undefined, ): IAtmosphereLutResolutions { … }",
+      "situations": ["choose atmosphere LUT dimensions for a measured startup budget"],
+      "summary": "Resolve the three LUT dimensions, allowing a game to trade startup cost for resolution.",
+      "supersedes": [],
+      "symbol": "resolveAtmosphereLutResolutions"
+    },
+    {
+      "constraints": [
+        "provide all three coefficient vectors and both radii; omitted fields are errors"
+      ],
+      "example": "const parameters = resolveAtmosphereParameters({ rayleigh, mie, ozone, planetRadius, atmosphereRadius });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function resolveAtmosphereParameters( options: IAtmosphereParameters, ): IResolvedAtmosphereParameters { … }",
+      "situations": ["validate atmosphere coefficients before a game creates its sky"],
+      "summary": "Validate and clone game-owned atmosphere coefficients.",
+      "supersedes": [],
+      "symbol": "resolveAtmosphereParameters"
+    },
+    {
+      "constraints": ["scene code must stay portable across web and native"],
+      "example": "class Play extends Scene { update(ctx, dt) {} }",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export abstract class Scene< TState extends Record<string, unknown> = Record<string, unknown>, TPhysics = undefined, > { … }",
+      "situations": [
+        "add a playable level or menu scene",
+        "move scene setup and per-frame gameplay out of the entry point"
+      ],
+      "summary": "Implement a portable Godot-shaped game scene lifecycle.",
+      "supersedes": [],
+      "symbol": "Scene"
+    },
+    {
+      "constraints": [],
+      "example": "const picker = new ScenePicker({ camera, scene });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class ScenePicker { … }",
+      "situations": [
+        "select an object under the pointer",
+        "interact with the first collider or mesh hit"
+      ],
+      "summary": "Raycast the game scene using the framework's picker.",
+      "supersedes": ["new Raycaster("],
+      "symbol": "ScenePicker"
+    },
+    {
+      "constraints": [
+        "dispose returned handles when the owning scene exits",
+        "ease receives progress in the range 0 to 1 and its return value is the interpolation factor"
+      ],
+      "example": "const door = { y: 0 };\nawait ctx.tween(door, { y: 2.4 }, 0.5, { ease: (t) => 1 - (1 - t) ** 3 });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class Scheduler { … }",
+      "situations": [
+        "delay an enemy patrol transition",
+        "run a callback every simulation tick",
+        "tween a numeric property with a game-owned curve"
+      ],
+      "summary": "Schedule delayed and repeating callbacks or tween numeric properties with game-owned cleanup.",
+      "supersedes": [],
+      "symbol": "Scheduler"
+    },
+    {
+      "constraints": [],
+      "example": "import { skeletonBones } from \"@threenative/core\";\nconst bones = skeletonBones(character);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function skeletonBones(root: Object3D): readonly string[] { … }",
+      "situations": [
+        "inspect the available bones before attaching a game-owned object",
+        "debug a missing skeleton bone name"
+      ],
+      "summary": "List the names of every bone in a character hierarchy.",
+      "supersedes": [],
+      "symbol": "skeletonBones"
+    },
+    {
+      "constraints": [
+        "the mesh must use one Three.js node material and contain complete triangles",
+        "pinned, stiffness, damping, gravity, and wind are required game-owned inputs",
+        "Pixel 8 steady upper bound for the shipped 45-vertex pennant with readback every two frames: whole-starter update p95 4.66 ms, render p95 3.56 ms, and GPU timer 0.05 ms across three 300-frame final-rung windows at 552x248 with 4x MSAA; these whole-scene numbers are not isolated solver cost"
+      ],
+      "example": "const flag = new SoftBody3D(flagMesh, { pinned: topEdge, stiffness: 35, damping: 1.8, gravity: [0, -9.81, 0], wind: [1.5, 0, 0.4] });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [
+        "timeStep follows the engine 1/60-second convention unless the game overrides it",
+        "readbackEveryFrames enables an explicitly stale CPU position sample; zero disables it"
+      ],
+      "package": "@threenative/core",
+      "signature": "export class SoftBody3D extends Mesh<BufferGeometry, NodeMaterial> implements IComputeDriven { … }",
+      "situations": [
+        "make a flag, cape, or curtain move as cloth",
+        "simulate a deforming surface while keeping one edge pinned",
+        "simulate cloth sails blowing in the wind",
+        "make cloth sails billow in wind on a ship"
+      ],
+      "summary": "Simulate an ordinary game-authored triangle mesh as cloth on the existing fixed-step GPU lane. The mesh supplies every visible choice. This class welds exporter duplicates, owns spring and position buffers, and replaces only the cloned material's position node. It adds no material, colour, texture, wind, stiffness, damping, or pinning default.",
+      "supersedes": [],
+      "symbol": "SoftBody3D"
+    },
+    {
+      "constraints": [
+        "canvas-painted images sample black under WebGPURenderer; write sprites as pixel data there"
+      ],
+      "example": "const puff = softCircleDataTexture(64, 0.25);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function softCircleDataTexture(size = 64, hardness = 0.25): DataTexture { … }",
+      "situations": [
+        "give smoke, flash, or glow sprites a radial alpha falloff",
+        "generate sprite images that render identically under every backend"
+      ],
+      "summary": "Build a soft round sprite as pixel data instead of painting a canvas.",
+      "supersedes": [],
+      "symbol": "softCircleDataTexture"
+    },
+    {
+      "constraints": [
+        "dates are interpreted as UTC unless utcOffset is supplied; no fixed sun direction is assumed",
+        "pass a mutable { azimuth, elevation } target to reuse the result object in a steady frame loop"
+      ],
+      "example": "const sun = solarPosition({ date, latitude: 49.28, longitude: -123.12, utcOffset: -8 });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function solarPosition(input: ISolarPositionInput, target?: ISolarPosition): ISolarPosition;",
+      "situations": ["move a sun across a real day at a game's latitude and longitude"],
+      "summary": "Calculate solar elevation and azimuth from time, latitude, and longitude.",
+      "supersedes": [],
+      "symbol": "solarPosition"
+    },
+    {
+      "constraints": [
+        "dates are interpreted as UTC; use solarPosition for an explicit local offset"
+      ],
+      "example": "const sun = solarPositionAt(new Date(), 49.28, -123.12);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function solarPositionAt( date: Date | string, latitude: number, longitude: number, ): ISolarPosition { … }",
+      "situations": ["calculate a sun direction from a timestamp and a game location"],
+      "summary": "Calculate solar elevation and azimuth for one UTC date.",
+      "supersedes": [],
+      "symbol": "solarPositionAt"
+    },
+    {
+      "constraints": [
+        "it draws nothing; the game supplies the mesh, the material and every colour",
+        "CPU height is a throttled copy carrying staleFrames, never this frame and never exact",
+        "an exact free CPU height needs an analytic wave field instead; that is a different contract",
+        "cascades are ordered largest patchSize first and every tuning number is required"
+      ],
+      "example": "const sea = ctx.add(new SpectralOcean(oceanOptions));",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class SpectralOcean extends Object3D implements IComputeDriven { … }",
+      "situations": [
+        "make an ocean whose surface is the view rather than a background",
+        "float a boat on waves the GPU is drawing",
+        "drive a water material from a wave simulation without writing an FFT",
+        "sail a ship on simulated ocean waves with buoyancy"
+      ],
+      "summary": "Simulate a spectral ocean — cascaded wave spectra inverse-transformed on the GPU each frame.",
+      "supersedes": [],
+      "symbol": "SpectralOcean"
+    },
+    {
+      "constraints": [
+        "the game supplies the atlas texture, surface, filtering, layout, and every frame duration",
+        "update is driven by the scene fixed step; no wall clock or default frame rate is used"
+      ],
+      "example": "const animator = new SpriteAnimator3D({ texture: atlas, frames, mode: \"pingPong\" });",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class SpriteAnimator3D { … }",
+      "situations": [
+        "play an animated pickup or sprite-sheet effect",
+        "sequence atlas frames with different authored durations"
+      ],
+      "summary": "Advance a game-owned non-uniform sprite atlas on the fixed step.",
+      "supersedes": [],
+      "symbol": "SpriteAnimator3D"
+    },
+    {
+      "constraints": [
+        "the surface comes from the game; pooling, travel, and fading belong to the engine",
+        "update once per frame and dispose with the owning scene"
+      ],
+      "example": "const tracers = new TracerPool3D(ctx.scene, tracerOptions);\ntracers.spawn(muzzle, shotDirection, hit.distance);",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class TracerPool3D { … }",
+      "situations": [
+        "show where a hitscan round went",
+        "draw incoming fire without spawning projectiles"
+      ],
+      "summary": "Pool travelling bullet-streak meshes for hitscan shots.",
+      "supersedes": [],
+      "symbol": "TracerPool3D"
+    },
+    {
+      "constraints": ["patches cannot introduce omitted, negative, or non-finite physical values"],
+      "example": "atmosphere.setAtmosphere({ rayleigh: [0.008, 0.016, 0.04] });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function updateAtmosphereParameters( current: IResolvedAtmosphereParameters, patch: IAtmosphereParameterPatch, ): IResolvedAtmosphereParameters { … }",
+      "situations": ["change scattering coefficients and rebake an atmosphere"],
+      "summary": "Apply a partial game-owned atmosphere change while preserving validation.",
+      "supersedes": [],
+      "symbol": "updateAtmosphereParameters"
+    },
+    {
+      "constraints": [],
+      "example": "updateClusteredMeshes(stagedRoot, myCamera, ctx.renderer.domElement.height);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function updateClusteredMeshes( root: { … }",
+      "situations": ["cut a virtual-geometry subtree the engine does not render itself"],
+      "summary": "Take every clustered mesh under a root through this frame's cut, before the render. The engine already does this for the scene it renders; reach for it only to cut a subtree the engine does not render, such as one staged for a camera of your own.",
+      "supersedes": [],
+      "symbol": "updateClusteredMeshes"
+    },
+    {
+      "constraints": [
+        "call `VelocityTracker.update()` before the render and `commit()` after it",
+        "a pass is only given a velocity target when a temporal stage consumes it"
+      ],
+      "example": "const scenePass = pass(scene, camera);\nensureVelocityOutput(scenePass);\nrenderer.setOutputNode(scenePass);\nconst tracker = new VelocityTracker();\ntracker.update(scene);\nrenderer.render(scene, camera);\ntracker.commit(scene);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function velocityTexture(pass: IVelocityRenderPass): Node { … }",
+      "situations": [
+        "keep a skinned character or instanced crowd stable in a temporal stage",
+        "add the velocity output to a Three.js scene pass",
+        "read screen-space motion for a temporal stage"
+      ],
+      "summary": "Provision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.",
+      "supersedes": [],
+      "symbol": "velocityTexture"
+    },
+    {
+      "constraints": [
+        "call `VelocityTracker.update()` before the render and `commit()` after it",
+        "a pass is only given a velocity target when a temporal stage consumes it",
+        "call `update()` after gameplay writes and `commit()` after the render"
+      ],
+      "example": "const scenePass = pass(scene, camera);\nensureVelocityOutput(scenePass);\nrenderer.setOutputNode(scenePass);\nconst tracker = new VelocityTracker();\ntracker.update(scene);\nrenderer.render(scene, camera);\ntracker.commit(scene);",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class VelocityTracker { … }",
+      "situations": [
+        "keep a skinned character or instanced crowd stable in a temporal stage",
+        "add the velocity output to a Three.js scene pass",
+        "retain previous transforms for animated and instanced renderables"
+      ],
+      "summary": "Provision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.",
+      "supersedes": [],
+      "symbol": "VelocityTracker"
+    },
+    {
+      "constraints": [],
+      "example": "await warmUpScene(renderer, scene, camera, { onProgress: (p) => setLoading(p) });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export async function warmUpScene( renderer: IWarmUpRenderer, scene: Object3D, camera: Camera, options: IWarmUpOptions = { … }",
+      "situations": [
+        "compile a scene's shaders during the loading screen instead of on the first frame",
+        "stop a native launch freezing for seconds inside its first rendered frame"
+      ],
+      "summary": "Warms up `scene` for `camera`, in slices, presenting a frame between each. Fail closed on a nonsensical slice size rather than quietly choosing one: a zero or negative slice would loop forever, and a caller that passed it has a bug worth seeing now.",
+      "supersedes": [],
+      "symbol": "warmUpScene"
+    },
+    {
+      "constraints": [
+        "supply every wave amplitude, wavelength, direction, speed and warp value",
+        "call setTime for the default graph clock when the game advances its own time"
+      ],
+      "example": "const field = new WaveField({ waves });\nconst { height, normal } = field.sample(x, z, elapsed);",
+      "importPath": "@threenative/core",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export class WaveField { … }",
+      "situations": [
+        "float a boat on waves",
+        "make water move",
+        "find the water surface height at a point"
+      ],
+      "summary": "Evaluate analytic waves on CPU and displace game-owned vertices with the matching TSL graph.",
+      "supersedes": [],
+      "symbol": "WaveField"
+    },
+    {
+      "constraints": [
+        "call `VelocityTracker.update()` before the render and `commit()` after it",
+        "a pass is only given a velocity target when a temporal stage consumes it"
+      ],
+      "example": "const scenePass = pass(scene, camera);\nensureVelocityOutput(scenePass);\nrenderer.setOutputNode(scenePass);\nconst tracker = new VelocityTracker();\ntracker.update(scene);\nrenderer.render(scene, camera);\ntracker.commit(scene);",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function withVelocityContext<T>(node: T, source: Node): T { … }",
+      "situations": [
+        "keep a skinned character or instanced crowd stable in a temporal stage",
+        "add the velocity output to a Three.js scene pass",
+        "hand the provisioned velocity source through a composed temporal graph"
+      ],
+      "summary": "Provision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.",
+      "supersedes": [],
+      "symbol": "withVelocityContext"
+    },
+    {
+      "constraints": [
+        "use the returned value as a validation oracle; the rendered path samples the LUT"
+      ],
+      "example": "const zenith = zenithTransmittance({ rayleigh, mie, ozone, planetRadius, atmosphereRadius });",
+      "importPath": "@threenative/core",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function zenithTransmittance( parameters: IAtmosphereParameters | IResolvedAtmosphereParameters, ): AtmosphereRgb { … }",
+      "situations": ["check a supplied atmosphere's direct vertical transmittance"],
+      "summary": "Return direct vertical transmittance for the supplied atmosphere.",
+      "supersedes": [],
+      "symbol": "zenithTransmittance"
+    },
+    {
+      "constraints": ["use only in the web development entry"],
+      "example": "acceptHotUpdate(game, import.meta.hot);",
+      "importPath": "@threenative/core/hot",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function acceptHotUpdate<TState extends Record<string, unknown>, TPhysics>( game: IGame<TState, TPhysics>, hot: IImportMeta[\"hot\"], ): void { … }",
+      "situations": [
+        "keep game state while editing source in development",
+        "diagnose state shape changes during hot reload"
+      ],
+      "summary": "Register hot-reload state preservation for a game.",
+      "supersedes": [],
+      "symbol": "acceptHotUpdate"
+    },
+    {
+      "constraints": ["state must contain finite numbers and plain objects only"],
+      "example": "assertPortableState(game.state.getState());",
+      "importPath": "@threenative/core/hot",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function assertPortableState(state: unknown): void { … }",
+      "situations": [
+        "preserve JSON-shaped state during hot reload",
+        "reject a non-portable game state before reload"
+      ],
+      "summary": "Validate that hot-reload state can cross the Vite boundary.",
+      "supersedes": [],
+      "symbol": "assertPortableState"
+    },
+    {
+      "constraints": ["install once in the game's plugin list"],
+      "example": "const game = defineGame({ plugins: [playtest()] });",
+      "importPath": "@threenative/core/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function playtest< TState extends Record<string, unknown> = Record<string, unknown>, TPhysics = undefined, >(options: IPlaytestOptions = { … }",
+      "situations": [
+        "expose movement and world observations to a playtest",
+        "connect a game to the ThreeNative scenario runner"
+      ],
+      "summary": "Install the playtest bridge into a portable game.",
+      "supersedes": [],
+      "symbol": "playtest"
+    },
+    {
+      "constraints": [
+        "styling is the `style` prop; Tailwind class names are CSS and cannot cross",
+        "import `react`, never `react-dom`, from the portable native entry",
+        "import `react`, never `react-dom`, from a native entry"
+      ],
+      "example": "const overlay = createReactOverlay({ canvasLayer: ctx.canvasLayer });",
+      "importPath": "@threenative/core/react",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function createReactOverlay(options: IReactOverlayOptions): IReactOverlay { … }",
+      "situations": [
+        "render a React HUD on Android or iOS without a WebView",
+        "show the same React component on web and on a phone",
+        "show a React HUD on Android, iOS or desktop native",
+        "render the same React component on web and on a phone without a WebView"
+      ],
+      "summary": "`@threenative/core/react` — React that renders on a phone, with no DOM and no WebView. A subpath on purpose. `react` and `react-reconciler` are **optional** peers, and nothing in `@threenative/core`'s main entry imports either of them, so a game that never mounts a React overlay pays nothing and core stays consumable from React Three Fiber. Importing this module is the opt-in. The element vocabulary is two components, borrowed from React Native rather than invented: {@link View} is a rectangle, {@link Text} is a run of glyphs. They are components and not lowercase intrinsics because `view` and `text` are already SVG tags in `@types/react`, and a HUD element that silently means `<svg:text>` on one platform is exactly the kind of quiet divergence this path exists to end.",
+      "supersedes": [],
+      "symbol": "createReactOverlay"
+    },
+    {
+      "constraints": [],
+      "example": "const scoreWidth = measureText(\"SCORE 10\", 24)",
+      "importPath": "@threenative/core/react",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function measureText(text: string, fontSize: number, letterSpacing = 0): number { … }",
+      "situations": ["measure native React HUD text before laying it out"],
+      "summary": "Width in pixels of a glyph run at a given cell height.",
+      "supersedes": [],
+      "symbol": "measureText"
+    },
+    {
+      "constraints": [],
+      "example": "supportedGlyphs().includes(\"A\")",
+      "importPath": "@threenative/core/react",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function supportedGlyphs(): string { … }",
+      "situations": ["discover which characters a native React HUD can draw"],
+      "summary": "Every character this glyph set can draw, for error messages and for the templates' AGENTS.md.",
+      "supersedes": [],
+      "symbol": "supportedGlyphs"
+    },
+    {
+      "constraints": [],
+      "example": "supportedStyleKeys().includes(\"centerX\")",
+      "importPath": "@threenative/core/react",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function supportedStyleKeys(): readonly string[] { … }",
+      "situations": ["discover which React HUD style properties work on native"],
+      "summary": "Every style key the overlay implements, for the templates' AGENTS.md and for error messages.",
+      "supersedes": [],
+      "symbol": "supportedStyleKeys"
+    },
+    {
+      "constraints": [],
+      "example": "<Text style={{ color: \"#ffffff\", fontSize: 24 }}>SCORE 10</Text>",
+      "importPath": "@threenative/core/react",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function Text(props: ITextProps): ReactNode { … }",
+      "situations": ["show text in a native React HUD without a DOM"],
+      "summary": "A run of bitmap glyphs, drawn as one instanced quad per lit pixel.",
+      "supersedes": [],
+      "symbol": "Text"
+    },
+    {
+      "constraints": [],
+      "example": "<View style={{ centerX: 0, top: 24 }}><Text>READY</Text></View>",
+      "importPath": "@threenative/core/react",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function View(props: IViewProps): ReactNode { … }",
+      "situations": ["group and position native React HUD elements"],
+      "summary": "A rectangle. Paints when its style has a `background`; otherwise it only positions children.",
+      "supersedes": [],
+      "symbol": "View"
+    },
+    {
+      "constraints": ["the transport is discovered, never configured; no game names the web view"],
+      "example": "const bridge = connectUiBridge({ end: \"ui\" });",
+      "importPath": "@threenative/core/ui-layer",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function connectUiBridge(options: IConnectOptions): IUiBridge { … }",
+      "situations": [
+        "write a UI that talks to the game on web and on a phone alike",
+        "send a message from a HUD rendered over the game surface",
+        "connect game code to a platform-owned UI realm",
+        "share one UI bridge implementation across web, Android, iOS, and desktop"
+      ],
+      "summary": "Open the message channel between a game and its UI, whatever host is underneath.",
+      "supersedes": [],
+      "symbol": "connectUiBridge"
+    },
+    {
+      "constraints": ["prefer game.ui.onIntent, which connects the bridge for you"],
+      "example": "onUiIntent(bridge, (intent) => { if (intent === \"restart\") game.goto(\"Play\"); });",
+      "importPath": "@threenative/core/ui-layer",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function onUiIntent( bridge: IUiBridge, listener: (intent: string, payload: unknown) => void, ): () => void { … }",
+      "situations": [
+        "restart or pause a game from a button in its HUD",
+        "handle a HUD button action in game code",
+        "route native and web UI commands through one listener"
+      ],
+      "summary": "Handle the actions a UI sends back to the game.",
+      "supersedes": [],
+      "symbol": "onUiIntent"
+    },
+    {
+      "constraints": [
+        "mark controls with data-tn-interactive; pointer-events is not the mechanism"
+      ],
+      "example": "publishHitRegions({ bridge });",
+      "importPath": "@threenative/core/ui-layer",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function publishHitRegions(options: IRegistryOptions): IHitRegionRegistry { … }",
+      "situations": [
+        "let a touch on empty HUD space reach the game instead of the UI",
+        "make a HUD button receive taps on a phone",
+        "give native input hosts the rectangles claimed by UI controls",
+        "keep touch hit testing aligned with a moving web or native HUD"
+      ],
+      "summary": "Tell the native input host where a UI's touchable controls are.",
+      "supersedes": [],
+      "symbol": "publishHitRegions"
+    },
+    {
+      "constraints": [
+        "publishes at the store's throttled cadence, and not at all with no UI listening"
+      ],
+      "example": "publishUiState(bridge, game.state);",
+      "importPath": "@threenative/core/ui-layer",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function publishUiState<T>( bridge: IUiBridge, store: IPublishableStore<T>, options: IPublishOptions = { … }",
+      "situations": [
+        "show score or health in a UI rendered over the game surface",
+        "keep a HUD in step with the game without re-rendering on the loop",
+        "publish game state to a HUD in another realm",
+        "keep a web and native UI mirror on the same throttled state stream"
+      ],
+      "summary": "Publish the game's state so a UI in another process can mirror it.",
+      "supersedes": [],
+      "symbol": "publishUiState"
+    },
+    {
+      "constraints": ["one-way; the game decides what each name means and may ignore one"],
+      "example": "sendUiIntent(bridge, \"restart\");",
+      "importPath": "@threenative/core/ui-layer",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function sendUiIntent(bridge: IUiBridge, intent: string, payload?: unknown): void { … }",
+      "situations": [
+        "wire a Restart button in a HUD to the running game",
+        "pause a game from a menu drawn over its surface",
+        "send a button or menu action from a UI HUD to game code",
+        "keep UI input portable across web and native hosts"
+      ],
+      "summary": "Send a player action from the UI back to the game.",
+      "supersedes": [],
+      "symbol": "sendUiIntent"
+    },
+    {
+      "constraints": ["returns undefined until the game publishes its first state"],
+      "example": "const mirror = subscribeUiState(bridge);",
+      "importPath": "@threenative/core/ui-layer",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/core",
+      "signature": "export function subscribeUiState<T>(bridge: IUiBridge): IUiStateMirror<T> { … }",
+      "situations": [
+        "read game state from a HUD that runs in the platform's web view",
+        "read published game state from a UI HUD",
+        "subscribe a web or native UI to the game's mirrored state"
+      ],
+      "summary": "Mirror the game's published state on the UI side.",
+      "supersedes": [],
+      "symbol": "subscribeUiState"
+    },
+    {
+      "constraints": [
+        "sampleHeight owns the terrain shape and stays in game source; the framework stores and interpolates its output",
+        "rows and columns are vertex counts; geometry is row-major z-then-x and collider export transposes once into Rapier's column-major matrix order"
+      ],
+      "example": "const field = Heightfield.fromSampler({ rows: 65, columns: 65, width: 64, depth: 64, origin: { x: 0, z: 0 }, sampleHeight: terrainHeight });",
+      "importPath": "@threenative/core/world",
+      "kind": "class",
+      "overrides": [
+        "rows, columns, width, depth, origin, and sampleHeight are explicit on every field"
+      ],
+      "package": "@threenative/core",
+      "signature": "export class Heightfield { … }",
+      "situations": [
+        "build terrain geometry and collision from one game-authored height function",
+        "query the same ground height or normal that a player sees and collides with",
+        "build islands and coastlines from terrain"
+      ],
+      "summary": "One height buffer shared by world queries, rendered geometry, and a physics heightfield. The game supplies every value, so changing the terrain's shape never requires a package edit. `fromSampler` evaluates that game function exactly once at each vertex and retains only the resulting numbers. Queries interpolate those same numbers instead of evaluating the function again.",
+      "supersedes": [],
+      "symbol": "Heightfield"
+    },
+    {
+      "constraints": ["add the area to the physics context before stepping the world"],
+      "example": "const area = new Area3D({ context, shape });",
+      "importPath": "@threenative/physics",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export class Area3D { … }",
+      "situations": [
+        "detect when an enemy enters a trigger area",
+        "react to a player entering a zone"
+      ],
+      "summary": "Detect overlaps without turning the body into a moving collider.",
+      "supersedes": [],
+      "symbol": "Area3D"
+    },
+    {
+      "constraints": ["supply hull points, density, drag, and the height source"],
+      "example": "new Buoyancy3D({ body, surface: field, hullPoints, density: 1_000, drag: 4 });",
+      "importPath": "@threenative/physics",
+      "kind": "class",
+      "overrides": ["buoyancy disables force application while submergedFraction remains measured"],
+      "package": "@threenative/physics",
+      "signature": "export class Buoyancy3D { … }",
+      "situations": ["float a boat on waves", "keep a hull above a moving water surface"],
+      "summary": "Float a rigid body on a game-owned height source with fixed-step force ordering.",
+      "supersedes": [],
+      "symbol": "Buoyancy3D"
+    },
+    {
+      "constraints": ["use moveAndSlide inside the physics update"],
+      "example": "const body = new CharacterBody3D({ context, object });",
+      "importPath": "@threenative/physics",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export class CharacterBody3D { … }",
+      "situations": [
+        "move an enemy or player through a level",
+        "keep a character from walking through walls"
+      ],
+      "summary": "Move a character body with collision-aware sliding.",
+      "supersedes": [],
+      "symbol": "CharacterBody3D"
+    },
+    {
+      "constraints": ["create shapes through the owning physics context"],
+      "example": "const shape = new CollisionShape3D({ context, shape: \"capsule\" });",
+      "importPath": "@threenative/physics",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export class CollisionShape3D { … }",
+      "situations": [
+        "add a capsule or box collider to a character",
+        "configure the shape used by a rigid body"
+      ],
+      "summary": "Give a physics body a Three.js collision shape.",
+      "supersedes": [],
+      "symbol": "CollisionShape3D"
+    },
+    {
+      "constraints": [],
+      "example": "const groups = interactionGroups(1, 3);",
+      "importPath": "@threenative/physics",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export function interactionGroups(layer: number, mask: number): number { … }",
+      "situations": [
+        "make an enemy collide with the world but not pickups",
+        "configure which physics layers interact"
+      ],
+      "summary": "Encode collision layers and masks for Rapier groups.",
+      "supersedes": [],
+      "symbol": "interactionGroups"
+    },
+    {
+      "constraints": ["both bodies must belong to the same physics context"],
+      "example": "const joint = new Joint3D({ context, kind: \"hinge\" });",
+      "importPath": "@threenative/physics",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export class Joint3D { … }",
+      "situations": ["constrain a rigid body to another body", "build a hinge or pin mechanism"],
+      "summary": "Connect two physics bodies with a Godot-style joint.",
+      "supersedes": [],
+      "symbol": "Joint3D"
+    },
+    {
+      "constraints": ["query results are bounded by the configured result limit"],
+      "example": "const space = new PhysicsDirectSpaceState3D(context);",
+      "importPath": "@threenative/physics",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export class PhysicsDirectSpaceState3D { … }",
+      "situations": [
+        "raycast for visibility or aiming",
+        "find bodies inside a shape or point query"
+      ],
+      "summary": "Query the physics world without creating a body.",
+      "supersedes": [],
+      "symbol": "PhysicsDirectSpaceState3D"
+    },
+    {
+      "constraints": ["place rapier() before recast() in the plugin list"],
+      "example": "const game = defineGame({ plugins: [rapier()] });",
+      "importPath": "@threenative/physics",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export function rapier(options: IPhysicsOptions = { … }",
+      "situations": [
+        "add physics to a portable game",
+        "provide the context used by character and rigid bodies"
+      ],
+      "summary": "Install the Rapier physics plugin and simulation backend.",
+      "supersedes": [],
+      "symbol": "rapier"
+    },
+    {
+      "constraints": ["register rapier() in the game plugin list before using bodies"],
+      "example": "const crate = new RigidBody3D({ context, object, mode: \"dynamic\" });",
+      "importPath": "@threenative/physics",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export class RigidBody3D { … }",
+      "situations": [
+        "give a crate or prop physical motion",
+        "create a body that collides with a character",
+        "fire physical cannonballs that collide with ships or scenery",
+        "fire a cannonball projectile with cannon smoke particles"
+      ],
+      "summary": "Simulate a dynamic or static rigid body.",
+      "supersedes": [],
+      "symbol": "RigidBody3D"
+    },
+    {
+      "constraints": [
+        "every body must use CollisionShape3D.box and retain its Three.js object transform",
+        "rotated boxes become conservative cloth-local axis-aligned bounds"
+      ],
+      "example": "const cloth = new SoftBody3D(mesh, { ...options, collision: softBodyCollision(wall) });",
+      "importPath": "@threenative/physics",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export function softBodyCollision(...bodies: readonly RigidBody3D[]): ISoftBodyCollision { … }",
+      "situations": [
+        "stop a cloth flag, cape, or curtain at an existing physics wall",
+        "collide SoftBody3D with fixed box bodies"
+      ],
+      "summary": "Feed existing rigid-body boxes into `SoftBody3D` without inventing a second collider API.",
+      "supersedes": [],
+      "symbol": "softBodyCollision"
+    },
+    {
+      "constraints": [
+        "import NavigationAgent3D from exactly `@threenative/physics/navigation`; `@threenative/physics` is not a valid import for this symbol; use this capability instead of hand-written A*; requires recast() after rapier(), plus a baked NavigationRegion3D"
+      ],
+      "example": "import { NavigationAgent3D } from \"@threenative/physics/navigation\";\nimport { Vector3 } from \"three\";\nconst agent = new NavigationAgent3D({ navigation, object });\nagent.setTargetPosition(player.position);\nconst reusableTarget = new Vector3();\nconst next = agent.getNextPathPosition(reusableTarget);",
+      "importPath": "@threenative/physics/navigation",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export class NavigationAgent3D { … }",
+      "situations": [
+        "enemy walks around a wall",
+        "enemy patrols a level and chases the player",
+        "enemy walks around a patrol path and chases the player when it sees them",
+        "enemy patrols and chases while avoiding obstacles",
+        "enemy chases the player with line of sight and obstacle avoidance",
+        "NPC walks to a destination",
+        "move crew around a ship deck"
+      ],
+      "summary": "Move an agent along a baked navmesh toward a target.",
+      "supersedes": [],
+      "symbol": "NavigationAgent3D"
+    },
+    {
+      "constraints": ["create it after recast() and dispose it with the scene"],
+      "example": "const obstacle = new NavigationObstacle3D({ navigation, object });",
+      "importPath": "@threenative/physics/navigation",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export class NavigationObstacle3D { … }",
+      "situations": [
+        "keep navigation agents away from a blocking prop",
+        "make a stationary character affect crowd avoidance"
+      ],
+      "summary": "Add a non-moving crowd obstacle to a navmesh.",
+      "supersedes": [],
+      "symbol": "NavigationObstacle3D"
+    },
+    {
+      "constraints": ["bake before creating agents or obstacles"],
+      "example": "const region = new NavigationRegion3D({ navigation, meshes: [floor] });",
+      "importPath": "@threenative/physics/navigation",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export class NavigationRegion3D { … }",
+      "situations": [
+        "let enemies walk around level geometry",
+        "create the baked navmesh required by NavigationAgent3D"
+      ],
+      "summary": "Bake walkable Three.js geometry into a navigation region.",
+      "supersedes": [],
+      "symbol": "NavigationRegion3D"
+    },
+    {
+      "constraints": ["requires rapier() earlier in the plugins array"],
+      "example": "const game = defineGame({ plugins: [rapier(), recast()] });",
+      "importPath": "@threenative/physics/navigation",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/physics",
+      "signature": "export function recast(): NavigationPlugin { … }",
+      "situations": ["enemy walks around a wall", "NPC patrols a level and chases a player"],
+      "summary": "Install navmesh pathfinding and crowd avoidance.",
+      "supersedes": [],
+      "symbol": "recast"
+    },
+    {
+      "constraints": [
+        "bridge values must be JSON-shaped",
+        "throws instead of silently dropping the offending field"
+      ],
+      "example": "assertJsonSafe({ score: 10 });",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function assertJsonSafe(value: unknown, path = \"$\"): asserts value is JsonValue { … }",
+      "situations": [
+        "send a safe observation over the playtest bridge",
+        "reject an oversized or cyclic playtest payload",
+        "validate entity components and gameplay observations before crossing the bridge"
+      ],
+      "summary": "Validate JSON-safe bridge messages and protocol sizes.",
+      "supersedes": [],
+      "symbol": "assertJsonSafe"
+    },
+    {
+      "constraints": [
+        "a reading the device does not expose reports unavailable, never zero",
+        "a run that started hot or whose thermal status rose is flagged as confounded"
+      ],
+      "example": "const verdict = summarizeDeviceMetrics(observation.samples);",
+      "importPath": "@threenative/playtest",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class DeviceMetricsError extends Error { … }",
+      "situations": [
+        "find out whether an Android run was throttled or started hot",
+        "read battery temperature, current draw or per-rail power for a run"
+      ],
+      "summary": "Measure and judge device thermal, power and battery state around a device playtest run.",
+      "supersedes": [],
+      "symbol": "DeviceMetricsError"
+    },
+    {
+      "constraints": [
+        "a reading the device does not expose reports unavailable, never zero",
+        "a run that started hot or whose thermal status rose is flagged as confounded"
+      ],
+      "example": "const verdict = summarizeDeviceMetrics(observation.samples);",
+      "importPath": "@threenative/playtest",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class DeviceMetricsRecorder { … }",
+      "situations": [
+        "find out whether an Android run was throttled or started hot",
+        "read battery temperature, current draw or per-rail power for a run"
+      ],
+      "summary": "Measure and judge device thermal, power and battery state around a device playtest run.",
+      "supersedes": [],
+      "symbol": "DeviceMetricsRecorder"
+    },
+    {
+      "constraints": ["malformed or empty assertions fail closed"],
+      "example": "const result = evaluateRichPlaytestAssertions(input);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function evaluateRichPlaytestAssertions(input: { … }",
+      "situations": [
+        "assert movement, visibility, or diagnostics in a playtest",
+        "turn a scenario observation into a pass or failure"
+      ],
+      "summary": "Evaluate rich semantic assertions against captured observations.",
+      "supersedes": [],
+      "symbol": "evaluateRichPlaytestAssertions"
+    },
+    {
+      "constraints": ["unknown scenario keys fail closed"],
+      "example": "const scenario = await loadPlaytestScenario(project, file);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function invalidScenario(scenarioPath: string, message: string): PlaytestScenarioError { … }",
+      "situations": [
+        "create a browser or device playtest scenario",
+        "wait or hold a game for a deterministic number of ticks"
+      ],
+      "summary": "Load and validate a scenario, then control its tick steps.",
+      "supersedes": [],
+      "symbol": "invalidScenario"
+    },
+    {
+      "constraints": ["bridge values must be JSON-shaped"],
+      "example": "assertJsonSafe({ score: 10 });",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function jsonByteLength(value: JsonValue): number { … }",
+      "situations": [
+        "send a safe observation over the playtest bridge",
+        "reject an oversized or cyclic playtest payload",
+        "check a runtime observation against the protocol payload limit before sampling"
+      ],
+      "summary": "Validate JSON-safe bridge messages and protocol sizes.",
+      "supersedes": [],
+      "symbol": "jsonByteLength"
+    },
+    {
+      "constraints": ["unknown scenario keys fail closed"],
+      "example": "const scenario = await loadPlaytestScenario(project, file);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function loadPlaytestScenario(projectPath: string, scenarioPath: string): Promise<IPlaytestScenario> { … }",
+      "situations": [
+        "create a browser or device playtest scenario",
+        "wait or hold a game for a deterministic number of ticks"
+      ],
+      "summary": "Load and validate a scenario, then control its tick steps.",
+      "supersedes": [],
+      "symbol": "loadPlaytestScenario"
+    },
+    {
+      "constraints": [],
+      "example": "const missing = missingPlaytestCapabilities(required, available);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function missingPlaytestCapabilities(required: readonly string[], available: readonly string[]): string[] { … }",
+      "situations": [
+        "check whether a scenario's required capabilities are installed",
+        "report unknown or missing playtest capabilities"
+      ],
+      "summary": "Validate and inspect playtest capability declarations.",
+      "supersedes": [],
+      "symbol": "missingPlaytestCapabilities"
+    },
+    {
+      "constraints": [
+        "a reading the device does not expose reports unavailable, never zero",
+        "a run that started hot or whose thermal status rose is flagged as confounded"
+      ],
+      "example": "const verdict = summarizeDeviceMetrics(observation.samples);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function parseDeviceBattery(output: string): IPlaytestDeviceBattery { … }",
+      "situations": [
+        "find out whether an Android run was throttled or started hot",
+        "read battery temperature, current draw or per-rail power for a run"
+      ],
+      "summary": "Measure and judge device thermal, power and battery state around a device playtest run.",
+      "supersedes": [],
+      "symbol": "parseDeviceBattery"
+    },
+    {
+      "constraints": [
+        "a reading the device does not expose reports unavailable, never zero",
+        "a run that started hot or whose thermal status rose is flagged as confounded"
+      ],
+      "example": "const verdict = summarizeDeviceMetrics(observation.samples);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function parseDeviceCurrent(output: string): PlaytestDeviceMeasurement<number> { … }",
+      "situations": [
+        "find out whether an Android run was throttled or started hot",
+        "read battery temperature, current draw or per-rail power for a run"
+      ],
+      "summary": "Measure and judge device thermal, power and battery state around a device playtest run.",
+      "supersedes": [],
+      "symbol": "parseDeviceCurrent"
+    },
+    {
+      "constraints": [
+        "a reading the device does not expose reports unavailable, never zero",
+        "a run that started hot or whose thermal status rose is flagged as confounded"
+      ],
+      "example": "const verdict = summarizeDeviceMetrics(observation.samples);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function parseDevicePowerRails(output: string): PlaytestDevicePowerRails { … }",
+      "situations": [
+        "find out whether an Android run was throttled or started hot",
+        "read battery temperature, current draw or per-rail power for a run"
+      ],
+      "summary": "Measure and judge device thermal, power and battery state around a device playtest run.",
+      "supersedes": [],
+      "symbol": "parseDevicePowerRails"
+    },
+    {
+      "constraints": [
+        "a reading the device does not expose reports unavailable, never zero",
+        "a run that started hot or whose thermal status rose is flagged as confounded"
+      ],
+      "example": "const verdict = summarizeDeviceMetrics(observation.samples);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function parseDeviceThermal(output: string): IPlaytestDeviceThermal { … }",
+      "situations": [
+        "find out whether an Android run was throttled or started hot",
+        "read battery temperature, current draw or per-rail power for a run"
+      ],
+      "summary": "Measure and judge device thermal, power and battery state around a device playtest run.",
+      "supersedes": [],
+      "symbol": "parseDeviceThermal"
+    },
+    {
+      "constraints": [],
+      "example": "playtestDiagnostic(\"physics\", \"body missing\");",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function playtestDiagnostic( code: PlaytestDiagnosticCode, message: string, instruction: string, details: Pick<IPlaytestProtocolDiagnostic, \"capability\" | \"path\"> & { … }",
+      "situations": [
+        "report a named runtime diagnostic to a scenario",
+        "explain why a playtest assertion cannot pass"
+      ],
+      "summary": "Create a structured playtest diagnostic.",
+      "supersedes": [],
+      "symbol": "playtestDiagnostic"
+    },
+    {
+      "constraints": ["unknown scenario keys fail closed"],
+      "example": "const scenario = await loadPlaytestScenario(project, file);",
+      "importPath": "@threenative/playtest",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class PlaytestScenarioError extends Error { … }",
+      "situations": [
+        "create a browser or device playtest scenario",
+        "wait or hold a game for a deterministic number of ticks"
+      ],
+      "summary": "Load and validate a scenario, then control its tick steps.",
+      "supersedes": [],
+      "symbol": "PlaytestScenarioError"
+    },
+    {
+      "constraints": ["unknown scenario keys fail closed"],
+      "example": "const scenario = await loadPlaytestScenario(project, file);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function playtestStepHoldTicks(step: IPlaytestStep, fallback = 1): number { … }",
+      "situations": [
+        "create a browser or device playtest scenario",
+        "wait or hold a game for a deterministic number of ticks"
+      ],
+      "summary": "Load and validate a scenario, then control its tick steps.",
+      "supersedes": [],
+      "symbol": "playtestStepHoldTicks"
+    },
+    {
+      "constraints": ["unknown scenario keys fail closed"],
+      "example": "const scenario = await loadPlaytestScenario(project, file);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function playtestStepWaitTicks(step: IPlaytestStep): number { … }",
+      "situations": [
+        "create a browser or device playtest scenario",
+        "wait or hold a game for a deterministic number of ticks"
+      ],
+      "summary": "Load and validate a scenario, then control its tick steps.",
+      "supersedes": [],
+      "symbol": "playtestStepWaitTicks"
+    },
+    {
+      "constraints": ["unknown scenario keys fail closed"],
+      "example": "const scenario = await loadPlaytestScenario(project, file);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function rejectUnknownKeys( value: Record<string, unknown>, allowedKeys: readonly string[], scenarioPath: string, objectPath: string, ): void { … }",
+      "situations": [
+        "create a browser or device playtest scenario",
+        "wait or hold a game for a deterministic number of ticks"
+      ],
+      "summary": "Load and validate a scenario, then control its tick steps.",
+      "supersedes": [],
+      "symbol": "rejectUnknownKeys"
+    },
+    {
+      "constraints": ["malformed or empty assertions fail closed"],
+      "example": "const result = evaluateRichPlaytestAssertions(input);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function requiredPlaytestCapabilities(scenario: IPlaytestScenario): PlaytestCapability[] { … }",
+      "situations": [
+        "assert movement, visibility, or diagnostics in a playtest",
+        "turn a scenario observation into a pass or failure"
+      ],
+      "summary": "Evaluate rich semantic assertions against captured observations.",
+      "supersedes": [],
+      "symbol": "requiredPlaytestCapabilities"
+    },
+    {
+      "constraints": ["absent policy fields default to rejecting errors"],
+      "example": "const policy = resolveDiagnosticsPolicy(scenario.assert?.diagnostics);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function resolveDiagnosticsPolicy( policy: IPlaytestDiagnosticsAssertion | undefined, ): IPlaytestDiagnosticsPolicy { … }",
+      "situations": ["judge captured console, network, or runtime diagnostics for a playtest"],
+      "summary": "Resolve the effective diagnostics policy for a run, with fail-closed defaults applied.",
+      "supersedes": [],
+      "symbol": "resolveDiagnosticsPolicy"
+    },
+    {
+      "constraints": [
+        "a reading the device does not expose reports unavailable, never zero",
+        "a run that started hot or whose thermal status rose is flagged as confounded"
+      ],
+      "example": "const verdict = summarizeDeviceMetrics(observation.samples);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function summarizeDeviceMetrics( samples: readonly IPlaytestDeviceMetricsSample[], ): IPlaytestDeviceMetricsVerdict { … }",
+      "situations": [
+        "find out whether an Android run was throttled or started hot",
+        "read battery temperature, current draw or per-rail power for a run"
+      ],
+      "summary": "Measure and judge device thermal, power and battery state around a device playtest run.",
+      "supersedes": [],
+      "symbol": "summarizeDeviceMetrics"
+    },
+    {
+      "constraints": [],
+      "example": "const missing = missingPlaytestCapabilities(required, available);",
+      "importPath": "@threenative/playtest",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function unknownPlaytestCapabilities(capabilities: readonly string[]): string[] { … }",
+      "situations": [
+        "check whether a scenario's required capabilities are installed",
+        "report unknown or missing playtest capabilities"
+      ],
+      "summary": "Validate and inspect playtest capability declarations.",
+      "supersedes": [],
+      "symbol": "unknownPlaytestCapabilities"
+    },
+    {
+      "constraints": ["the assertion throws instead of returning a false pass"],
+      "example": "assertCaptureNotBlank(png, \"first frame\");",
+      "importPath": "@threenative/playtest/capture",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function assertCaptureNotBlank(png: Buffer, label: string): ICaptureFrameStats { … }",
+      "situations": [
+        "guard a visual playtest against a blank frame",
+        "prove a screenshot contains more than a loading surface"
+      ],
+      "summary": "Fail closed when a screenshot is blank or uniform.",
+      "supersedes": [],
+      "symbol": "assertCaptureNotBlank"
+    },
+    {
+      "constraints": [],
+      "example": "throw new CaptureGuardError(\"menu\", \"no bright pixels\");",
+      "importPath": "@threenative/playtest/capture",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class CaptureGuardError extends Error { … }",
+      "situations": [
+        "fail a visual test when the rendered frame is blank",
+        "include capture statistics in a playtest error"
+      ],
+      "summary": "Explain why a captured frame failed the non-blank guard.",
+      "supersedes": [],
+      "symbol": "CaptureGuardError"
+    },
+    {
+      "constraints": [],
+      "example": "const stats = inspectFrame(png);",
+      "importPath": "@threenative/playtest/capture",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function inspectFrame(png: Buffer): ICaptureFrameStats { … }",
+      "situations": [
+        "measure whether a screenshot contains a rendered game",
+        "diagnose a uniform or blank capture"
+      ],
+      "summary": "Inspect a PNG frame for visible pixels and luminance variation.",
+      "supersedes": [],
+      "symbol": "inspectFrame"
+    },
+    {
+      "constraints": ["throws instead of silently dropping the offending field"],
+      "example": "assertJsonSafe(snapshot, \"$.components\");",
+      "importPath": "@threenative/playtest/protocol",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function assertJsonSafe(value: unknown, path = \"$\"): asserts value is JsonValue { … }",
+      "situations": [
+        "validate entity components and gameplay observations before crossing the bridge"
+      ],
+      "summary": "Reject any value that would not survive JSON serialization.",
+      "supersedes": [],
+      "symbol": "assertJsonSafe"
+    },
+    {
+      "constraints": [],
+      "example": "const bytes = jsonByteLength(observation);",
+      "importPath": "@threenative/playtest/protocol",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function jsonByteLength(value: JsonValue): number { … }",
+      "situations": [
+        "check a runtime observation against the protocol payload limit before sampling"
+      ],
+      "summary": "Measure a payload's wire size in bytes.",
+      "supersedes": [],
+      "symbol": "jsonByteLength"
+    },
+    {
+      "constraints": ["Android evidence must name its target and transport"],
+      "example": "const adb = discoverAdb(process.env);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class AdbAndroidDriver implements IAndroidDriver { … }",
+      "situations": [
+        "run a scenario on an Android emulator or device",
+        "parse Android console diagnostics"
+      ],
+      "summary": "Drive and inspect Android playtest transport.",
+      "supersedes": [],
+      "symbol": "AdbAndroidDriver"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function advanceFixedStep( page: Page, bridge: Pick<IPlaytestBridgeClient, \"advance\">, ticks: number, ): Promise<void> { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "advanceFixedStep"
+    },
+    {
+      "constraints": ["the bridge must answer the handshake or the run fails"],
+      "example": "const bridge = await connectPlaytestBridge(page);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function advanceTimeoutMs( ticks: number, perTickMs: number = PLAYTEST_ADVANCE_TICK_BUDGET_MS, ): number { … }",
+      "situations": [
+        "run a browser scenario against a game",
+        "inspect bridge diagnostics from a runner"
+      ],
+      "summary": "Connect a Playwright page to a playtest bridge.",
+      "supersedes": [],
+      "symbol": "advanceTimeoutMs"
+    },
+    {
+      "constraints": ["paths stay inside the managed artifact directory"],
+      "example": "const paths = deviceMailboxPaths(projectRoot);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function androidMailboxPaths( packageName: string, root = `/sdcard/Android/data/$ { … }",
+      "situations": [
+        "connect a native host to the playtest runner",
+        "validate an Android or iOS device endpoint"
+      ],
+      "summary": "Resolve a native device transport and its mailbox paths.",
+      "supersedes": [],
+      "symbol": "androidMailboxPaths"
+    },
+    {
+      "constraints": ["Android evidence must name its target and transport"],
+      "example": "const adb = discoverAdb(process.env);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function androidTouchBatches( identity: readonly string[], positions: readonly string[], ): string[][] { … }",
+      "situations": [
+        "run a scenario on an Android emulator or device",
+        "parse Android console diagnostics"
+      ],
+      "summary": "Drive and inspect Android playtest transport.",
+      "supersedes": [],
+      "symbol": "androidTouchBatches"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function batchArtifactDirectory(base: string, scenarioPath: string, index: number): string { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "batchArtifactDirectory"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function boundedTeardownStep( step: Promise<unknown> | undefined, timeoutMs: number, ): Promise<boolean> { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "boundedTeardownStep"
+    },
+    {
+      "constraints": ["the bridge must answer the handshake or the run fails"],
+      "example": "const bridge = await connectPlaytestBridge(page);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function bridgeWaitTimeoutMs( operationMs: number = PLAYTEST_PROTOCOL_LIMITS.operationTimeoutMs, ): number { … }",
+      "situations": [
+        "run a browser scenario against a game",
+        "inspect bridge diagnostics from a runner"
+      ],
+      "summary": "Connect a Playwright page to a playtest bridge.",
+      "supersedes": [],
+      "symbol": "bridgeWaitTimeoutMs"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function buildReport( config: IStandalonePlaytestConfig, scenario: IPlaytestScenario, beforeSnapshot: IPlaytestObservationSnapshot | undefined, afterSnapshot: IPlaytestObservationSnapshot | undefined, consoleEntries: IRunnerConsoleEntry[], networkEntries: Array< { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "buildReport"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function captureVisualSurface( page: Page, artifactPath?: string, ): Promise<Buffer | undefined> { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "captureVisualSurface"
+    },
+    {
+      "constraints": ["the bridge must answer the handshake or the run fails"],
+      "example": "const bridge = await connectPlaytestBridge(page);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function connectPlaytestBridge( page: Page, scenario: IPlaytestScenario, timeoutMs: number = PLAYTEST_PROTOCOL_LIMITS.operationTimeoutMs, ): Promise<IPlaytestBridgeClient | undefined> { … }",
+      "situations": [
+        "run a browser scenario against a game",
+        "inspect bridge diagnostics from a runner"
+      ],
+      "summary": "Connect a Playwright page to a playtest bridge.",
+      "supersedes": [],
+      "symbol": "connectPlaytestBridge"
+    },
+    {
+      "constraints": ["the bridge must answer the handshake or the run fails"],
+      "example": "const bridge = await connectPlaytestBridge(page);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function connectPlaytestBridgeTransport( transport: IBridgeTransport, scenario: IPlaytestScenario, timeoutMs: number = bridgeWaitTimeoutMs(), ): Promise<IPlaytestBridgeClient | undefined> { … }",
+      "situations": [
+        "run a browser scenario against a game",
+        "inspect bridge diagnostics from a runner"
+      ],
+      "summary": "Connect a Playwright page to a playtest bridge.",
+      "supersedes": [],
+      "symbol": "connectPlaytestBridgeTransport"
+    },
+    {
+      "constraints": ["the mailbox lifecycle must be disposed after the run"],
+      "example": "const driver = new DesktopPlaytestDriver(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class DesktopPlaytestDriver implements IDevicePlaytestDriver { … }",
+      "situations": [
+        "run a desktop target through the playtest protocol",
+        "exchange observations with a native desktop host"
+      ],
+      "summary": "Drive a local desktop playtest mailbox.",
+      "supersedes": [],
+      "symbol": "DesktopPlaytestDriver"
+    },
+    {
+      "constraints": ["paths stay inside the managed artifact directory"],
+      "example": "const paths = deviceMailboxPaths(projectRoot);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class DeviceBridgeTransport implements IDevicePlaytestTransport { … }",
+      "situations": [
+        "connect a native host to the playtest runner",
+        "validate an Android or iOS device endpoint"
+      ],
+      "summary": "Resolve a native device transport and its mailbox paths.",
+      "supersedes": [],
+      "symbol": "DeviceBridgeTransport"
+    },
+    {
+      "constraints": ["paths stay inside the managed artifact directory"],
+      "example": "const paths = deviceMailboxPaths(projectRoot);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function deviceMailboxPaths(root: string): IDeviceMailboxPaths { … }",
+      "situations": [
+        "connect a native host to the playtest runner",
+        "validate an Android or iOS device endpoint"
+      ],
+      "summary": "Resolve a native device transport and its mailbox paths.",
+      "supersedes": [],
+      "symbol": "deviceMailboxPaths"
+    },
+    {
+      "constraints": ["paths stay inside the managed artifact directory"],
+      "example": "const paths = deviceMailboxPaths(projectRoot);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class DeviceMailboxTransport implements IDevicePlaytestTransport { … }",
+      "situations": [
+        "connect a native host to the playtest runner",
+        "validate an Android or iOS device endpoint"
+      ],
+      "summary": "Resolve a native device transport and its mailbox paths.",
+      "supersedes": [],
+      "symbol": "DeviceMailboxTransport"
+    },
+    {
+      "constraints": ["paths stay inside the managed artifact directory"],
+      "example": "const paths = deviceMailboxPaths(projectRoot);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function deviceTimeoutDiagnostic( diagnostic: IPlaytestProtocolDiagnostic, hostAlive: boolean | undefined, lastConsoleLines: readonly string[], ): IPlaytestProtocolDiagnostic { … }",
+      "situations": [
+        "connect a native host to the playtest runner",
+        "validate an Android or iOS device endpoint"
+      ],
+      "summary": "Resolve a native device transport and its mailbox paths.",
+      "supersedes": [],
+      "symbol": "deviceTimeoutDiagnostic"
+    },
+    {
+      "constraints": ["Android evidence must name its target and transport"],
+      "example": "const adb = discoverAdb(process.env);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function discoverAdb(environment: NodeJS.ProcessEnv = process.env): string { … }",
+      "situations": [
+        "run a scenario on an Android emulator or device",
+        "parse Android console diagnostics"
+      ],
+      "summary": "Drive and inspect Android playtest transport.",
+      "supersedes": [],
+      "symbol": "discoverAdb"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function failedDiagnosticsAssertion(policy: IPlaytestDiagnosticsPolicy): IPlaytestAssertionResult { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "failedDiagnosticsAssertion"
+    },
+    {
+      "constraints": ["invalid flags throw a named usage error"],
+      "example": "const config = parseStandalonePlaytestArgs(argv);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function formatUsage(): string { … }",
+      "situations": [
+        "invoke the playtest CLI from a scaffold",
+        "validate runner flags before launching a browser"
+      ],
+      "summary": "Parse standalone playtest runner configuration.",
+      "supersedes": [],
+      "symbol": "formatUsage"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function handlePlaytestSignal( teardown: (stopManagedServer: boolean) => Promise<void>, setExitCode: (code: number) => void = (code) => { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "handlePlaytestSignal"
+    },
+    {
+      "constraints": ["generated scenarios must contain real assertions"],
+      "example": "await initStandalonePlaytest(projectPath);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function initStandalonePlaytest(projectPath = process.cwd()): Promise< { … }",
+      "situations": ["add the runner contract to a new game", "create a starter scenario fixture"],
+      "summary": "Initialize the standalone playtest files for a project.",
+      "supersedes": [],
+      "symbol": "initStandalonePlaytest"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function isRuntimeReadout(entry: unknown): boolean { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "isRuntimeReadout"
+    },
+    {
+      "constraints": ["Android evidence must name its target and transport"],
+      "example": "const adb = discoverAdb(process.env);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function keyboardIsShown(dump: string): boolean { … }",
+      "situations": [
+        "run a scenario on an Android emulator or device",
+        "parse Android console diagnostics"
+      ],
+      "summary": "Drive and inspect Android playtest transport.",
+      "supersedes": [],
+      "symbol": "keyboardIsShown"
+    },
+    {
+      "constraints": ["the mailbox lifecycle must be disposed after the run"],
+      "example": "const driver = new DesktopPlaytestDriver(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class LocalDeviceMailbox { … }",
+      "situations": [
+        "run a desktop target through the playtest protocol",
+        "exchange observations with a native desktop host"
+      ],
+      "summary": "Drive a local desktop playtest mailbox.",
+      "supersedes": [],
+      "symbol": "LocalDeviceMailbox"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class ManagedServerError extends Error { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "ManagedServerError"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function openPageAndConnectBridge( page: Page, config: IStandalonePlaytestConfig, scenario: IPlaytestScenario, ): Promise<IPlaytestBridgeClient | undefined> { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "openPageAndConnectBridge"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function pageLifecycleDiagnostic( error: unknown, lifecycle: IPageLifecycle, url: string, ): IPlaytestProtocolDiagnostic | undefined { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "pageLifecycleDiagnostic"
+    },
+    {
+      "constraints": ["Android evidence must name its target and transport"],
+      "example": "const adb = discoverAdb(process.env);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function parseAndroidConsole(output: string): Array< { … }",
+      "situations": [
+        "run a scenario on an Android emulator or device",
+        "parse Android console diagnostics"
+      ],
+      "summary": "Drive and inspect Android playtest transport.",
+      "supersedes": [],
+      "symbol": "parseAndroidConsole"
+    },
+    {
+      "constraints": ["simulator evidence does not claim physical-device proof"],
+      "example": "const driver = new XcrunIosDriver(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function parseLaunchedPid(output: string): string { … }",
+      "situations": [
+        "run a scenario on the iOS simulator",
+        "parse the launched native process identifier"
+      ],
+      "summary": "Drive and inspect iOS simulator playtest transport.",
+      "supersedes": [],
+      "symbol": "parseLaunchedPid"
+    },
+    {
+      "constraints": ["invalid flags throw a named usage error"],
+      "example": "const config = parseStandalonePlaytestArgs(argv);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function parseStandalonePlaytestArgs(argv: readonly string[], cwd = process.cwd()): IStandalonePlaytestConfig { … }",
+      "situations": [
+        "invoke the playtest CLI from a scaffold",
+        "validate runner flags before launching a browser"
+      ],
+      "summary": "Parse standalone playtest runner configuration.",
+      "supersedes": [],
+      "symbol": "parseStandalonePlaytestArgs"
+    },
+    {
+      "constraints": ["the bridge must answer the handshake or the run fails"],
+      "example": "const bridge = await connectPlaytestBridge(page);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class PlaytestBridgeError extends Error { … }",
+      "situations": [
+        "run a browser scenario against a game",
+        "inspect bridge diagnostics from a runner"
+      ],
+      "summary": "Connect a Playwright page to a playtest bridge.",
+      "supersedes": [],
+      "symbol": "PlaytestBridgeError"
+    },
+    {
+      "constraints": ["invalid flags throw a named usage error"],
+      "example": "const config = parseStandalonePlaytestArgs(argv);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class PlaytestCliUsageError extends Error { … }",
+      "situations": [
+        "invoke the playtest CLI from a scaffold",
+        "validate runner flags before launching a browser"
+      ],
+      "summary": "Parse standalone playtest runner configuration.",
+      "supersedes": [],
+      "symbol": "PlaytestCliUsageError"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function playtestStepDrivesMovement( step: IPlaytestScenario[\"steps\"][number], hasHeldInput: boolean, ): boolean { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "playtestStepDrivesMovement"
+    },
+    {
+      "constraints": ["the bridge must answer the handshake or the run fails"],
+      "example": "const bridge = await connectPlaytestBridge(page);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class PlaywrightTransport implements IBridgeTransport { … }",
+      "situations": [
+        "run a browser scenario against a game",
+        "inspect bridge diagnostics from a runner"
+      ],
+      "summary": "Connect a Playwright page to a playtest bridge.",
+      "supersedes": [],
+      "symbol": "PlaywrightTransport"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function preflightDisplay( config: Pick<IStandalonePlaytestConfig, \"headless\">, scenario: Pick<IPlaytestScenario, \"artifacts\" | \"assert\" | \"steps\">, environment: NodeJS.ProcessEnv = process.env, platform = process.platform, ): IPlaytestDiagnostic | undefined { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "preflightDisplay"
+    },
+    {
+      "constraints": ["inspect the adapter name before claiming GPU proof"],
+      "example": "const args = resolveBrowserArguments(undefined);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function reconcileBrowserPointers( previous: ReadonlyMap<number, Required<IPlaytestPointer>>, next: readonly IPlaytestPointer[], ): IBrowserPointerChange[] { … }",
+      "situations": [
+        "run a browser playtest with Vulkan WebGPU",
+        "reject a SwiftShader adapter as evidence"
+      ],
+      "summary": "Select safe Chromium arguments for WebGPU playtests.",
+      "supersedes": [],
+      "symbol": "reconcileBrowserPointers"
+    },
+    {
+      "constraints": ["an empty assertion set is a failure"],
+      "example": "const scenario = recordToScenario(recording);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function recordToScenario( value: unknown, scenarioPath = \"recording.json\", oracleValue?: unknown, ): IPlaytestScenario { … }",
+      "situations": [
+        "preserve a failing playtest as a replay fixture",
+        "require assertions before recording a scenario"
+      ],
+      "summary": "Convert captured runner observations into a replay scenario.",
+      "supersedes": [],
+      "symbol": "recordToScenario"
+    },
+    {
+      "constraints": ["an empty assertion set is a failure"],
+      "example": "const scenario = recordToScenario(recording);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function requireAssertions( value: IPlaytestScenario[\"assert\"], scenarioPath: string, ): NonNullable<IPlaytestScenario[\"assert\"]> { … }",
+      "situations": [
+        "preserve a failing playtest as a replay fixture",
+        "require assertions before recording a scenario"
+      ],
+      "summary": "Convert captured runner observations into a replay scenario.",
+      "supersedes": [],
+      "symbol": "requireAssertions"
+    },
+    {
+      "constraints": ["inspect the adapter name before claiming GPU proof"],
+      "example": "const args = resolveBrowserArguments(undefined);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function resolveBrowserArguments(browserArgs: readonly string[] | undefined): string[] { … }",
+      "situations": [
+        "run a browser playtest with Vulkan WebGPU",
+        "reject a SwiftShader adapter as evidence"
+      ],
+      "summary": "Select safe Chromium arguments for WebGPU playtests.",
+      "supersedes": [],
+      "symbol": "resolveBrowserArguments"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function resolveManagedServerCommand( config: IStandalonePlaytestConfig, dynamicPort?: number, ): string { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "resolveManagedServerCommand"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function resolveManagedServerConfig( config: IStandalonePlaytestConfig, ): Promise<IStandalonePlaytestConfig> { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "resolveManagedServerConfig"
+    },
+    {
+      "constraints": ["Android evidence must name its target and transport"],
+      "example": "const adb = discoverAdb(process.env);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function rotatedTouchPosition(x: number, y: number, rotation: number): [number, number] { … }",
+      "situations": [
+        "run a scenario on an Android emulator or device",
+        "parse Android console diagnostics"
+      ],
+      "summary": "Drive and inspect Android playtest transport.",
+      "supersedes": [],
+      "symbol": "rotatedTouchPosition"
+    },
+    {
+      "constraints": ["the app bundle and device transport must be prepared"],
+      "example": "await runAndroidPlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function runAndroidPlaytest( config: IStandalonePlaytestConfig, dependencies: IAndroidPlaytestDependencies = { … }",
+      "situations": [
+        "execute a scenario on an Android target",
+        "collect Android playtest artifacts"
+      ],
+      "summary": "Run a playtest on Android through the configured device transport.",
+      "supersedes": [],
+      "symbol": "runAndroidPlaytest"
+    },
+    {
+      "constraints": ["the desktop host must be built before launching"],
+      "example": "await runDesktopPlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function runDesktopPlaytest( config: IStandalonePlaytestConfig, dependencies: IDesktopPlaytestDependencies = { … }",
+      "situations": [
+        "execute a scenario against the desktop host",
+        "verify native desktop behavior from the same scenario"
+      ],
+      "summary": "Run a desktop playtest and collect its report.",
+      "supersedes": [],
+      "symbol": "runDesktopPlaytest"
+    },
+    {
+      "constraints": ["the app bundle and device transport must be prepared"],
+      "example": "await runAndroidPlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function runDevicePlaytest( config: IStandalonePlaytestConfig, target: IDevicePlaytestTarget, ): Promise<IStandalonePlaytestReport> { … }",
+      "situations": [
+        "execute a scenario on an Android target",
+        "collect Android playtest artifacts"
+      ],
+      "summary": "Run a playtest on Android through the configured device transport.",
+      "supersedes": [],
+      "symbol": "runDevicePlaytest"
+    },
+    {
+      "constraints": ["identify simulator versus physical transport in evidence"],
+      "example": "await runIosPlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function runIosPlaytest( config: IStandalonePlaytestConfig, dependencies: IIosPlaytestDependencies = { … }",
+      "situations": ["execute a scenario on an iOS target", "collect iOS playtest artifacts"],
+      "summary": "Run a playtest on the iOS simulator or device transport.",
+      "supersedes": [],
+      "symbol": "runIosPlaytest"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function runStandalonePlaytest( config: IStandalonePlaytestConfig, options: IStandalonePlaytestRunOptions = { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "runStandalonePlaytest"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function runStandalonePlaytests( config: IStandalonePlaytestConfig, ): Promise<readonly IStandalonePlaytestReport[]> { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "runStandalonePlaytests"
+    },
+    {
+      "constraints": ["inspect the adapter name before claiming GPU proof"],
+      "example": "const args = resolveBrowserArguments(undefined);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function softwareAdapterName(adapter: Readonly<Record<string, string>> | undefined): string | undefined { … }",
+      "situations": [
+        "run a browser playtest with Vulkan WebGPU",
+        "reject a SwiftShader adapter as evidence"
+      ],
+      "summary": "Select safe Chromium arguments for WebGPU playtests.",
+      "supersedes": [],
+      "symbol": "softwareAdapterName"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function substituteManagedPort(command: string, port: number): string { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "substituteManagedPort"
+    },
+    {
+      "constraints": ["Android evidence must name its target and transport"],
+      "example": "const adb = discoverAdb(process.env);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function tapCommand(x: number, y: number): string[] { … }",
+      "situations": [
+        "run a scenario on an Android emulator or device",
+        "parse Android console diagnostics"
+      ],
+      "summary": "Drive and inspect Android playtest transport.",
+      "supersedes": [],
+      "symbol": "tapCommand"
+    },
+    {
+      "constraints": ["Android evidence must name its target and transport"],
+      "example": "const adb = discoverAdb(process.env);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function touchRotationFromWindowDump(dump: string): number | undefined { … }",
+      "situations": [
+        "run a scenario on an Android emulator or device",
+        "parse Android console diagnostics"
+      ],
+      "summary": "Drive and inspect Android playtest transport.",
+      "supersedes": [],
+      "symbol": "touchRotationFromWindowDump"
+    },
+    {
+      "constraints": ["paths stay inside the managed artifact directory"],
+      "example": "const paths = deviceMailboxPaths(projectRoot);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function validateDeviceEndpoint(value: string): URL { … }",
+      "situations": [
+        "connect a native host to the playtest runner",
+        "validate an Android or iOS device endpoint"
+      ],
+      "summary": "Resolve a native device transport and its mailbox paths.",
+      "supersedes": [],
+      "symbol": "validateDeviceEndpoint"
+    },
+    {
+      "constraints": ["Android evidence must name its target and transport"],
+      "example": "const adb = discoverAdb(process.env);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function viewportPresentationCommands( viewport: { … }",
+      "situations": [
+        "run a scenario on an Android emulator or device",
+        "parse Android console diagnostics"
+      ],
+      "summary": "Drive and inspect Android playtest transport.",
+      "supersedes": [],
+      "symbol": "viewportPresentationCommands"
+    },
+    {
+      "constraints": ["Android evidence must name its target and transport"],
+      "example": "const adb = discoverAdb(process.env);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function viewportRestoreCommands(): string[][] { … }",
+      "situations": [
+        "run a scenario on an Android emulator or device",
+        "parse Android console diagnostics"
+      ],
+      "summary": "Drive and inspect Android playtest transport.",
+      "supersedes": [],
+      "symbol": "viewportRestoreCommands"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function writeCaptureProvenance( artifactDirectory: string, provenance: IPlaytestCaptureProvenance, ): Promise<void> { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "writeCaptureProvenance"
+    },
+    {
+      "constraints": ["missing observations and malformed assertions fail closed"],
+      "example": "const report = await runStandalonePlaytest(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export async function writeObservationArtifacts( artifactDirectory: string, requested: IPlaytestArtifactRequest | undefined, observations: { … }",
+      "situations": [
+        "run a complete browser or device playtest",
+        "capture diagnostics and screenshots from a managed server"
+      ],
+      "summary": "Execute scenario steps, assertions, and evidence capture.",
+      "supersedes": [],
+      "symbol": "writeObservationArtifacts"
+    },
+    {
+      "constraints": ["simulator evidence does not claim physical-device proof"],
+      "example": "const driver = new XcrunIosDriver(options);",
+      "importPath": "@threenative/playtest/runner",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class XcrunIosDriver implements IDevicePlaytestDriver { … }",
+      "situations": [
+        "run a scenario on the iOS simulator",
+        "parse the launched native process identifier"
+      ],
+      "summary": "Drive and inspect iOS simulator playtest transport.",
+      "supersedes": [],
+      "symbol": "XcrunIosDriver"
+    },
+    {
+      "constraints": ["use measured input rather than visual guesses"],
+      "example": "const advice = adviseThreeRenderWorkload(input);",
+      "importPath": "@threenative/playtest/three",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function adviseThreeRenderWorkload(input: IRenderAdvisorInput): IRenderAdvisorReport { … }",
+      "situations": [
+        "diagnose a slow Three.js scene",
+        "choose a render optimization from observed workload data"
+      ],
+      "summary": "Explain which render workloads should be collapsed or retained.",
+      "supersedes": [],
+      "symbol": "adviseThreeRenderWorkload"
+    },
+    {
+      "constraints": ["use the device transport selected by the runner"],
+      "example": "const connection = await connectDevicePlaytestBridge();",
+      "importPath": "@threenative/playtest/three",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function connectDevicePlaytestBridge( bridge: IPlaytestBridgeV1, endpoint: string, ): IDeviceBridgeInstallation { … }",
+      "situations": [
+        "run the same playtest on an Android or iOS target",
+        "read the device bridge endpoint"
+      ],
+      "summary": "Connect a device-hosted game to the playtest bridge.",
+      "supersedes": [],
+      "symbol": "connectDevicePlaytestBridge"
+    },
+    {
+      "constraints": ["install once before the runner connects"],
+      "example": "const bridge = installThreePlaytestBridge(options);",
+      "importPath": "@threenative/playtest/three",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function installThreePlaytestBridge(options: IThreePlaytestBridgeOptions): IThreePlaytestBridgeInstallation { … }",
+      "situations": [
+        "expose a non-ThreeNative game to the scenario runner",
+        "add semantic observations to a browser playtest"
+      ],
+      "summary": "Install the playtest observation bridge for a plain Three.js game.",
+      "supersedes": [],
+      "symbol": "installThreePlaytestBridge"
+    },
+    {
+      "constraints": ["use the device transport selected by the runner"],
+      "example": "const connection = await connectDevicePlaytestBridge();",
+      "importPath": "@threenative/playtest/three",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export function readPlaytestEndpoint(): string | undefined { … }",
+      "situations": [
+        "run the same playtest on an Android or iOS target",
+        "read the device bridge endpoint"
+      ],
+      "summary": "Connect a device-hosted game to the playtest bridge.",
+      "supersedes": [],
+      "symbol": "readPlaytestEndpoint"
+    },
+    {
+      "constraints": ["keep recorder limits within the documented caps"],
+      "example": "const physics = new ThreePlaytestPhysicsRecorder();",
+      "importPath": "@threenative/playtest/three",
+      "kind": "class",
+      "overrides": [],
+      "package": "@threenative/playtest",
+      "signature": "export class ThreePlaytestPhysicsRecorder { … }",
+      "situations": [
+        "assert physics contacts in a plain Three.js game",
+        "capture bounded body state for a scenario"
+      ],
+      "summary": "Record Three.js physics bodies for playtest observations.",
+      "supersedes": [],
+      "symbol": "ThreePlaytestPhysicsRecorder"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "gradualBackground(...)",
+      "importPath": "@threenative/template/starter/src/render/effects/gradualBackground",
+      "kind": "function",
+      "overrides": [],
+      "package": "template:starter",
+      "signature": "function gradualBackground",
+      "situations": ["grade a background by distance"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects gradualBackground.",
+      "symbol": "gradualBackground"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "lensDistortion(...)",
+      "importPath": "@threenative/template/starter/src/render/effects/lensDistortion",
+      "kind": "function",
+      "overrides": [],
+      "package": "template:starter",
+      "signature": "function lensDistortion",
+      "situations": ["warp the image with radial lens distortion"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects lensDistortion.",
+      "symbol": "lensDistortion"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "sparkle(...)",
+      "importPath": "@threenative/template/starter/src/render/effects/sparkle",
+      "kind": "function",
+      "overrides": [],
+      "package": "template:starter",
+      "signature": "function sparkle",
+      "situations": ["add glints to bright highlights"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects sparkle.",
+      "symbol": "sparkle"
+    },
+    {
+      "constraints": [],
+      "example": "<DebugOverlay game={game} />",
+      "importPath": "@threenative/ui",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/ui",
+      "signature": "export function DebugOverlay() { … }",
+      "situations": [
+        "display runtime and playtest diagnostics in a React HUD",
+        "inspect a game without changing its scene"
+      ],
+      "summary": "Show framework diagnostics while developing a game.",
+      "supersedes": [],
+      "symbol": "DebugOverlay"
+    },
+    {
+      "constraints": ["keep the portable game entry free of React DOM code"],
+      "example": "<GameCanvas game={game} />",
+      "importPath": "@threenative/ui",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/ui",
+      "signature": "export function GameCanvas<TState extends Record<string, unknown>, TPhysics>( { … }",
+      "situations": [
+        "add a game viewport to a React application",
+        "connect a game canvas to the web UI shell"
+      ],
+      "summary": "Mount a ThreeNative game in a React canvas.",
+      "supersedes": [],
+      "symbol": "GameCanvas"
+    },
+    {
+      "constraints": ["mark every control the player touches with data-tn-interactive"],
+      "example": "<UiLayer><Hud /></UiLayer>",
+      "importPath": "@threenative/ui",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/ui",
+      "signature": "export function UiLayer( { … }",
+      "situations": [
+        "write one HUD that looks the same on the web build and on a phone",
+        "mount a React UI over the game surface on Android or iOS"
+      ],
+      "summary": "Render a game's UI so the same source runs on web and on every native target.",
+      "supersedes": [],
+      "symbol": "UiLayer"
+    },
+    {
+      "constraints": ["use this hook only from the web UI entry"],
+      "example": "const score = useGameState(game, (state) => state.score);",
+      "importPath": "@threenative/ui",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/ui",
+      "signature": "export function useGameState<TState extends Record<string, unknown>, TPhysics, TSelected>( game: IGame<TState, TPhysics>, selector: GameSelector<TState, TSelected>, ): TSelected;",
+      "situations": [
+        "bind a HUD component to game state",
+        "select a slice of state for a React panel"
+      ],
+      "summary": "Read throttled game state from React.",
+      "supersedes": [],
+      "symbol": "useGameState"
+    },
+    {
+      "constraints": ["the game decides what each intent name means; it may ignore one"],
+      "example": "const send = useUiIntent(); send(\"restart\");",
+      "importPath": "@threenative/ui",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/ui",
+      "signature": "export function useUiIntent(): (intent: string, payload?: unknown) => void { … }",
+      "situations": [
+        "wire a Restart button in a HUD to the running game",
+        "pause a game from a menu rendered over its surface"
+      ],
+      "summary": "Send a player action from the UI back to the game.",
+      "supersedes": [],
+      "symbol": "useUiIntent"
+    },
+    {
+      "constraints": ["returns undefined until the game publishes its first state"],
+      "example": "const score = useUiState((state) => state.score);",
+      "importPath": "@threenative/ui",
+      "kind": "function",
+      "overrides": [],
+      "package": "@threenative/ui",
+      "signature": "export function useUiState<TState extends object>(): TState | undefined;",
+      "situations": [
+        "bind a HUD to game state on web and native alike",
+        "show score or health in a UI rendered over the game surface"
+      ],
+      "summary": "Read the game's published state from a UI that may be in another process.",
+      "supersedes": [],
+      "symbol": "useUiState"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "DenoiseNode(...)",
+      "importPath": "three/addons/tsl/display/DenoiseNode.js",
+      "kind": "class",
+      "overrides": [],
+      "package": "three",
+      "signature": "class DenoiseNode",
+      "situations": ["denoise a noisy screen-space pass"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects DenoiseNode.",
+      "symbol": "DenoiseNode"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "motionBlur(...)",
+      "importPath": "three/addons/tsl/display/MotionBlur.js",
+      "kind": "function",
+      "overrides": [],
+      "package": "three",
+      "signature": "function motionBlur",
+      "situations": ["blur motion using a velocity buffer"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects motionBlur.",
+      "symbol": "motionBlur"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "RecurrentDenoiseNode(...)",
+      "importPath": "three/addons/tsl/display/RecurrentDenoiseNode.js",
+      "kind": "class",
+      "overrides": [],
+      "package": "three",
+      "signature": "class RecurrentDenoiseNode",
+      "situations": ["denoise a noisy screen-space pass"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects RecurrentDenoiseNode.",
+      "symbol": "RecurrentDenoiseNode"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "SharpenNode(...)",
+      "importPath": "three/addons/tsl/display/SharpenNode.js",
+      "kind": "class",
+      "overrides": [],
+      "package": "three",
+      "signature": "class SharpenNode",
+      "situations": ["make the image sharper"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects SharpenNode.",
+      "symbol": "SharpenNode"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "SSAAPassNode(...)",
+      "importPath": "three/addons/tsl/display/SSAAPassNode.js",
+      "kind": "class",
+      "overrides": [],
+      "package": "three",
+      "signature": "class SSAAPassNode",
+      "situations": ["anti-alias still and moving scenes"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects SSAAPassNode.",
+      "symbol": "SSAAPassNode"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "SSGINode(...)",
+      "importPath": "three/addons/tsl/display/SSGINode.js",
+      "kind": "class",
+      "overrides": [],
+      "package": "three",
+      "signature": "class SSGINode",
+      "situations": ["add screen-space global illumination"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects SSGINode.",
+      "symbol": "SSGINode"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "SSRNode(...)",
+      "importPath": "three/addons/tsl/display/SSRNode.js",
+      "kind": "class",
+      "overrides": [],
+      "package": "three",
+      "signature": "class SSRNode",
+      "situations": ["add screen-space reflections"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects SSRNode.",
+      "symbol": "SSRNode"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "TemporalReprojectNode(...)",
+      "importPath": "three/addons/tsl/display/TemporalReprojectNode.js",
+      "kind": "class",
+      "overrides": [],
+      "package": "three",
+      "signature": "class TemporalReprojectNode",
+      "situations": ["reproject a temporal history"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects TemporalReprojectNode.",
+      "symbol": "TemporalReprojectNode"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "TRAANode(...)",
+      "importPath": "three/addons/tsl/display/TRAANode.js",
+      "kind": "class",
+      "overrides": [],
+      "package": "three",
+      "signature": "class TRAANode",
+      "situations": ["temporally resolve a moving image"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects TRAANode.",
+      "symbol": "TRAANode"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "depth(...)",
+      "importPath": "three/tsl",
+      "kind": "function",
+      "overrides": [],
+      "package": "three",
+      "signature": "function depth",
+      "situations": ["provide depth to screen-space effects"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects depth.",
+      "symbol": "depth"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "mrt(...)",
+      "importPath": "three/tsl",
+      "kind": "function",
+      "overrides": [],
+      "package": "three",
+      "signature": "function mrt",
+      "situations": ["provision velocity, normal, and depth render targets"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects mrt.",
+      "symbol": "mrt"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "normal(...)",
+      "importPath": "three/tsl",
+      "kind": "function",
+      "overrides": [],
+      "package": "three",
+      "signature": "function normal",
+      "situations": ["provide normals to screen-space effects"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects normal.",
+      "symbol": "normal"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "velocity(...)",
+      "importPath": "three/tsl",
+      "kind": "function",
+      "overrides": [],
+      "package": "three",
+      "signature": "function velocity",
+      "situations": ["provide motion vectors to temporal effects"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects velocity.",
+      "symbol": "velocity"
+    },
+    {
+      "constraints": [
+        "Use the running WebGPU renderer and keep appearance choices in template render source."
+      ],
+      "example": "VelocityNode(...)",
+      "importPath": "three/webgpu",
+      "kind": "class",
+      "overrides": [],
+      "package": "three",
+      "signature": "class VelocityNode",
+      "situations": ["provide motion vectors to temporal effects"],
+      "supersedes": [],
+      "summary": "ThreeNative equivalent for realism-effects VelocityNode.",
+      "symbol": "VelocityNode"
+    }
+  ],
+  "version": 1
+}