@threenative/core 0.3.3 → 0.3.4

package/dist/playtest.d.ts

@@ -1,10 +1,10 @@
 import { JsonValue, JsonPrimitive } from '@threenative/playtest/protocol';
-import { b as IGamePluginHooks } from './game-D_6r-k4Y.js';
-import './assets-CYKk2WTu.js';
+import { b as IGamePluginHooks } from './game-CljaDv4D.js';
+import './assets-CqvE429w.js';
 import 'three';
-import './renderer-Cy4qeBOA.js';
+import './renderer-CfsS2hxi.js';
 import 'three/webgpu';
-import './canvas-layer-C1SnMoJ-.js';
+import './canvas-layer-DDmC_VVF.js';
 import 'zustand/vanilla';
 
 /**
@@ -31,6 +31,12 @@ declare const PLAYTEST_ATTACH_TIMEOUT_MS = 30000;
  */
 /** The global a playtest runner sets before the page loads, so a game can tell one is coming. */
 declare const PLAYTEST_RUNNER_EXPECTED_GLOBAL = "__THREENATIVE_PLAYTEST_RUNNER_EXPECTED__";
+/**
+ * The clock a consumer asks this game to run on, named in the protocol's own vocabulary. Set before
+ * the game module evaluates — a production profile does it in the instrumentation it injects ahead
+ * of the bundle, on the browser and on native alike.
+ */
+declare const PLAYTEST_CLOCK_GLOBAL = "__THREENATIVE_PLAYTEST_CLOCK__";
 interface IPlaytestOptions {
     readonly events?: () => JsonValue[];
     /**
@@ -63,4 +69,4 @@ interface IPlaytestTransition {
     to: JsonPrimitive;
 }
 
-export { type IPlaytestOptions, type IPlaytestTransition, PLAYTEST_ATTACH_TIMEOUT_MS, PLAYTEST_RUNNER_EXPECTED_GLOBAL, PLAYTEST_TRANSITION_LOG_LIMIT, playtest };
+export { type IPlaytestOptions, type IPlaytestTransition, PLAYTEST_ATTACH_TIMEOUT_MS, PLAYTEST_CLOCK_GLOBAL, PLAYTEST_RUNNER_EXPECTED_GLOBAL, PLAYTEST_TRANSITION_LOG_LIMIT, playtest };

package/dist/playtest.js

@@ -42,7 +42,7 @@ new Vector3();
 new Vector3();
 
 // src/version.ts
-var CORE_VERSION = "0.3.3";
+var CORE_VERSION = "0.3.4";
 
 // src/pipeline-census.ts
 var PIPELINE_CENSUS_CAPABILITY = "runtime.pipelineCensus";
@@ -92,6 +92,8 @@ function playtest(options = {}) {
     setup: async (ctx, runtime) => {
       readTick = runtime?.tick;
       const seed = runtime?.seed ?? null;
+      const clockMode = requestedClockMode();
+      const wallClock = clockMode === "wall-clock";
       const replayRuntime = runtime?.seed === null || runtime?.seed === void 0 ? void 0 : {
         agent: currentAgent,
         core: CORE_VERSION,
@@ -101,9 +103,15 @@ function playtest(options = {}) {
       };
       const installation = installThreePlaytestBridge({
         camera: ctx.camera,
+        ...clockMode === void 0 ? {} : { clockMode },
         entities: () => bridgeEntities(ctx),
         components: () => componentObservations(ctx.entities.snapshot()),
-        ...runtime === void 0 ? {} : { fixedStep: runtime.fixedStep, tick: runtime.tick },
+        // The live clock has to be driven by the host's own frame pump, so a live run's `advance`
+        // waits the span of wall time the count names and reports the ticks that pump ran.
+        ...runtime === void 0 ? {} : {
+          fixedStep: wallClock ? wallClockAdvance(runtime) : runtime.fixedStep,
+          tick: runtime.tick
+        },
         ...runtime?.runtimeDiagnosticsSeries === void 0 ? {} : { runtimeDiagnosticsSeries: runtime.runtimeDiagnosticsSeries },
         ...options.events === void 0 ? {} : { events: options.events },
         gameplay: () => gameplayObservations(ctx, contactHistory, seed, replayRuntime, watcher),
@@ -154,7 +162,10 @@ function playtest(options = {}) {
         });
       }
       installRuntimeChannels(installation.bridge, runtime);
-      if (runnerAnnounced()) runtime?.enableRuntimeDiagnostics?.();
+      if (runnerAnnounced()) {
+        runtime?.enableRuntimeDiagnostics?.();
+        if (!wallClock) runtime?.freezeClock?.();
+      }
       dispose = installation.dispose;
       attached = holdUntilAttached(installation.bridge, options, () => startSceneEntered);
       const cleanup = () => {
@@ -187,6 +198,27 @@ function playtest(options = {}) {
 }
 var PLAYTEST_ATTACH_TIMEOUT_MS = 3e4;
 var PLAYTEST_RUNNER_EXPECTED_GLOBAL = "__THREENATIVE_PLAYTEST_RUNNER_EXPECTED__";
+var PLAYTEST_CLOCK_GLOBAL = "__THREENATIVE_PLAYTEST_CLOCK__";
+function requestedClockMode() {
+  const requested = globalThis[PLAYTEST_CLOCK_GLOBAL];
+  if (requested === void 0) return void 0;
+  if (requested === "wall-clock") return "wall-clock";
+  throw new Error(
+    `TN_PLAYTEST_CLOCK_UNSUPPORTED: '${PLAYTEST_CLOCK_GLOBAL}' is ${JSON.stringify(requested)}; this protocol knows 'wall-clock' and nothing else.`
+  );
+}
+var WALL_CLOCK_PUMP_STEPS = 4;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function wallClockAdvance(runtime) {
+  const stepMs = runtime.step * 1e3;
+  return async (ticks) => {
+    const before = runtime.tick();
+    await sleep(ticks * stepMs);
+    for (let waited = 0; waited < WALL_CLOCK_PUMP_STEPS && runtime.tick() === before; waited += 1)
+      await sleep(stepMs / 2);
+    return runtime.tick() - before;
+  };
+}
 function shouldHoldUntilAttached(options) {
   if (options.holdUntilAttached !== void 0) return options.holdUntilAttached;
   return runnerAnnounced();
@@ -469,11 +501,29 @@ function stateResources(ctx) {
         // `state` is canonical. Keep `GameState` as a compatibility alias until published
         // scenarios have migrated, then remove the alias in a future breaking release.
         ["state", value],
-        ["GameState", value]
+        ["GameState", value],
+        // Where every asset was actually served from, on every target and not only in a browser
+        // console log: a game whose manifest never loaded runs on the uncompiled source directory
+        // and looks healthy, and without this nothing observable says so.
+        ["assets", assetResolutions(ctx.assets)]
       ]);
     }
   };
 }
+function assetResolutions(assets) {
+  const nested = {};
+  for (const [logical, record] of assets.resolved) {
+    const parts = logical.split(".");
+    let node = nested;
+    for (const part of parts.slice(0, -1)) {
+      const child = node[part] ?? {};
+      node[part] = child;
+      node = child;
+    }
+    node[parts.at(-1) ?? logical] = { url: record.url, via: record.via };
+  }
+  return nested;
+}
 function cloneJsonValue(value) {
   if (Array.isArray(value)) return value.map((item) => cloneJsonValue(item));
   if (typeof value === "object" && value !== null) {
@@ -484,4 +534,4 @@ function cloneJsonValue(value) {
   return value;
 }
 
-export { PLAYTEST_ATTACH_TIMEOUT_MS, PLAYTEST_RUNNER_EXPECTED_GLOBAL, PLAYTEST_TRANSITION_LOG_LIMIT, playtest };
+export { PLAYTEST_ATTACH_TIMEOUT_MS, PLAYTEST_CLOCK_GLOBAL, PLAYTEST_RUNNER_EXPECTED_GLOBAL, PLAYTEST_TRANSITION_LOG_LIMIT, playtest };

package/dist/react.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
-import { C as CanvasLayer } from './canvas-layer-C1SnMoJ-.js';
+import { C as CanvasLayer } from './canvas-layer-DDmC_VVF.js';
 import 'three';
-import './renderer-Cy4qeBOA.js';
+import './renderer-CfsS2hxi.js';
 import 'three/webgpu';
 
 /**

package/dist/{renderer-Cy4qeBOA.d.ts → renderer-CfsS2hxi.d.ts}

@@ -1,4 +1,4 @@
-import { Object3D, Matrix4, Camera } from 'three';
+import { Object3D, Matrix4, Camera, BufferGeometry } from 'three';
 import { MRTNode, Node } from 'three/webgpu';
 
 /**
@@ -85,6 +85,78 @@ interface IRenderPassSample {
     readonly triangles: number;
 }
 
+type PlatformRuntime = "web" | "native";
+type PlatformOS = "android" | "ios" | "linux" | "macos" | "windows" | "unknown";
+type PlatformFormFactor = "mobile" | "desktop" | "unknown";
+interface IPlatformInfo {
+    readonly runtime: PlatformRuntime;
+    readonly os: PlatformOS;
+    readonly formFactor: PlatformFormFactor;
+    readonly maxTouchPoints: number;
+}
+declare function getPlatform(): Readonly<IPlatformInfo>;
+declare function isWeb(): boolean;
+declare function isNative(): boolean;
+declare function isMobile(): boolean;
+declare function isTouchscreenAvailable(): boolean;
+
+/**
+ * One rule for what `display.maxFps` means when a game does not say.
+ *
+ * A template that shipped `maxFps: 60` taught every agent to copy the line, and every 120 Hz
+ * desktop then ran its game at half the panel it was sitting on — a default that is a constant the
+ * author is told to revisit later is a bug, not an option. So the default follows the display,
+ * capped at 120 on desktop and web, and stays 60 on mobile where the ceiling is power and heat
+ * rather than pixels. An explicit number still wins and `0` still removes the ceiling.
+ *
+ * **A browser has no refresh-rate API**, so "follows the display" is a measurement: the median
+ * interval between presented frames over the frame budget's first window is the panel's period,
+ * because on the web one rAF callback is one vblank. A native host says its own rate through the
+ * present counter, which is the only series there that counts displays rather than loop
+ * iterations. Both arrive as `measuredRefreshHz`; until one does, the answer is 60 and says so.
+ */
+
+/** What a game gets before anything has been measured, and all a mobile gets. */
+declare const DEFAULT_TARGET_FPS = 60;
+/** The desktop and web ceiling, whatever the panel runs at. */
+declare const MAX_TARGET_FPS = 120;
+/**
+ * Where a resolved target came from, so a harness can assert the *rule* and not just the number:
+ * `"config"` is the game naming it, `"display"` a measured panel rate, `"mobile-default"` the
+ * mobile power ceiling, and `"fallback"` the 60 held until a measurement exists. An unmeasured 60
+ * is not the display's rate and does not report as one.
+ */
+type TargetFpsSource = "config" | "display" | "fallback" | "mobile-default";
+/** A resolved frame budget: the rate the loop holds, and what decided it. */
+interface ITargetFps {
+    readonly targetFps: number;
+    readonly source: TargetFpsSource;
+}
+/** Whatever holds `display.maxFps` — `IGameConfig`, `IThreeNativeConfig`, or a bare object. */
+interface ITargetFpsConfig {
+    readonly display?: {
+        readonly maxFps?: number | undefined;
+    } | undefined;
+}
+/** Only the one field the rule reads, so a caller need not hold a whole `IPlatformInfo`. */
+type ITargetFpsPlatform = Pick<IPlatformInfo, "formFactor">;
+/**
+ * The nearest common refresh rate, never above `MAX_TARGET_FPS`.
+ *
+ * A measured 59.94 Hz panel and a measured 60 Hz one are the same panel, and a value the engine
+ * invents rather than reads is a value no display can be asked to hold.
+ */
+declare function snapRefreshRate(refreshHz: number): number;
+/**
+ * The single reader of `display.maxFps`, used by the loop, the resolution scaler, the scene-shape
+ * warning, the frame-budget marker and the templates.
+ *
+ * `measuredRefreshHz` is the display's own rate when the platform can say it, and is what turns
+ * `"fallback"` into `"display"`. A negative or non-finite configured rate throws rather than
+ * quietly falling back: a config the engine ignored is worse than a config it rejected.
+ */
+declare function resolveTargetFps(config: ITargetFpsConfig | undefined, platform: ITargetFpsPlatform | undefined, measuredRefreshHz?: number): ITargetFps;
+
 /**
  * Per-presented-frame cost attribution, on by default, for every platform.
  *
@@ -173,6 +245,11 @@ interface IFrameBudgetSummary {
     readonly p99: number;
     readonly max: number;
 }
+/** Where one resolved frame's GPU milliseconds went. Closed on purpose, like the phases. */
+declare const FRAME_GPU_BUCKETS: readonly ["main", "shadow", "other", "compute"];
+type FrameGpuBucket = (typeof FRAME_GPU_BUCKETS)[number];
+/** One frame's GPU milliseconds per bucket; a bucket the device did not resolve is absent. */
+type IFrameGpuBucketSample = Partial<Record<FrameGpuBucket, number>>;
 /**
  * One render-pass kind's submissions across a window, so a change that trades triangles for CPU is
  * visible in the same report as the milliseconds it traded for.
@@ -241,12 +318,33 @@ interface IFrameBudgetWindow {
      * is absent; `frames` says how many frames did.
      */
     readonly passes?: Readonly<Partial<Record<FramePassKind, IFrameBudgetPassSummary>>>;
+    /**
+     * Instances and triangles the GPU actually selected in the main pass, from the streamed world's
+     * own indirect-args tally when it has one.
+     *
+     * These are the honest counterpart of `passes.main`: three's `renderer.info.render.triangles`
+     * counts a mesh's CPU window/capacity for an indirect draw, so `passes.main.triangles` is an upper
+     * bound over what the GPU could draw, while `mainGpuTriangles` is the sum over the indirect
+     * records of `instanceCount x indexCount / 3` — what the kernel selected. Main pass only: shadow
+     * passes are not tallied. Absent, never zero, before the first sample lands.
+     */
+    readonly mainGpuInstances?: number;
+    readonly mainGpuTriangles?: number;
     /**
      * The resolution and sampling this window's frames were drawn at, when the loop reported one.
      * Absent rather than defaulted: a consumer asserting on it must fail loudly instead of reading
      * a fabricated `1.0` that no frame was ever drawn at.
      */
     readonly surface?: IFrameSurfaceState;
+    /**
+     * The rate the loop is holding, and what decided it, when the engine resolved one.
+     *
+     * Two fields rather than an object, and a harness reads them without unwrapping anything: a
+     * number nobody can place (`targetSource: "fallback"`) is the difference between a game holding
+     * its panel and a game settling for 60, and only this line says which one happened.
+     */
+    readonly targetFps?: number;
+    readonly targetSource?: TargetFpsSource;
     /**
      * GPU milliseconds per resolved frame in this window, from `timestamp-query`, summarised like a
      * phase — mean/p50/p95/p99/max over the frames the device actually reported.
@@ -273,6 +371,19 @@ interface IFrameBudgetWindow {
     readonly gpuMs?: number;
     /** Age of the most recent resolved GPU timestamp in Three.js frame IDs; absent means unobservable. */
     readonly gpuAgeFrames?: number;
+    /**
+     * GPU milliseconds per resolved frame, split by where the device spent them: the main scene
+     * pass, every shadow pass, everything else in the render pool (post chain, reflections, HUD) and
+     * the compute pool. Each is the window's p50 over the frames that resolved it, one decimal.
+     *
+     * `gpu` is their sum's series; these say which pass owns it. Absent rather than zero when that
+     * bucket never resolved — an unmeasured pass and a free one are different facts — so
+     * `gpuMain + gpuShadow + gpuOther` reconciles with `gpuMs` only when all three are present.
+     */
+    readonly gpuMain?: number;
+    readonly gpuShadow?: number;
+    readonly gpuOther?: number;
+    readonly gpuCompute?: number;
     /**
      * The frame's boundary counts, when something counted them.
      *
@@ -309,6 +420,13 @@ interface IFrameBudgetOptions {
      * loop, which is the only place that knows both the renderer and the window boundary.
      */
     readonly readSurface?: () => IFrameSurfaceState;
+    /**
+     * The engine's resolved frame budget, read once per reported window.
+     *
+     * Wired by the game, which owns the rule and the panel measurement behind it. A window with no
+     * resolver reports no target rather than a default that looks measured.
+     */
+    readonly readTarget?: () => ITargetFps | undefined;
     /**
      * Frames the display has presented so far, when the platform can say.
      *
@@ -319,6 +437,16 @@ interface IFrameBudgetOptions {
     readonly readPresentCount?: () => number | undefined;
     /** Reads the successful GPU query frame age, not the age of the last resolve attempt. */
     readonly readGpuAgeFrames?: () => number | undefined;
+    /**
+     * The GPU-selected main-pass instance and triangle count, read once per reported window.
+     *
+     * Wired by the game from the streamed world's own tally; `undefined` until its first sample lands
+     * or when the world has none, so a window reports absent rather than a fabricated zero.
+     */
+    readonly readGpuTally?: () => {
+        readonly instances: number;
+        readonly triangles: number;
+    } | undefined;
 }
 /**
  * Accumulates one frame at a time and reports windowed attribution.
@@ -356,6 +484,15 @@ declare class FrameBudget {
      * Once per frame. A window with no reading at all reports `gpu` absent, never a zero.
      */
     addGpuMs(ms: number | undefined, frame?: number): void;
+    /**
+     * Records where one resolved frame's GPU time went, from the per-pass timestamp split.
+     *
+     * Alongside `addGpuMs`, once per frame. A bucket the producer could not attribute is left out
+     * rather than passed as zero: an unmeasured pass and a free one are different facts, and the
+     * p50 of a bucket that was never measured is absent from the window. An unknown bucket name
+     * throws rather than being dropped, the same fail-closed rule as a phase.
+     */
+    addGpuBucketMs(sample: IFrameGpuBucketSample): void;
     /**
      * Records the frame's host-boundary counts, from `FrameCounters` or any other source.
      *
@@ -878,7 +1015,33 @@ interface IRendererLike {
      * the `TN_ALPHA_ANTIALIASING` marker is printed either way, so nothing is only readable here.
      */
     alphaAntialiasing?: () => IAlphaAntialiasingReport;
+    /**
+     * The `adapter.info` field value that identifies a CPU rasteriser — `swiftshader`, `llvmpipe`,
+     * a `Microsoft Basic Render Driver` — when the adapter named one, else absent.
+     *
+     * Reading it needs `navigator.gpu`, so it is read here rather than in a game's render source.
+     * It is a fact about the machine, not a look: which tier a game runs on a software adapter is
+     * that game's own decision, and every tier name it might pick is already in its own
+     * `src/render/quality.ts`. What this removes is the reason it could not make that decision
+     * before its first expensive frame — a CPU rasteriser running a desktop render chain can lose
+     * the device on the very first frame, which no adaptation after it survives.
+     *
+     * Absent means no software name was found, never that the adapter is hardware. The native host
+     * exposes the same four `adapter.info` fields, so the same read works on every target.
+     */
+    readonly softwareAdapter?: string;
     compute(node: unknown): void;
+    /**
+     * Creates the GPU buffers these geometries draw from, through the backend's own attribute path,
+     * and reports how many it created.
+     *
+     * `compileAsync` builds pipelines, not buffers: a streamed mesh's first draw is where its
+     * attributes reach the device, and one chunk's first draw measured 230 ms of a frame for it. This
+     * moves that to admission, one chunk at a time. WebGPU only — the WebGL fallback has no seam
+     * this can call without inventing a GL enum — and absent or throwing answers 0, so the first
+     * draw uploads exactly as it did before.
+     */
+    uploadAttributes?(geometries: Iterable<BufferGeometry>): number;
     /**
      * Copies one GPU storage attribute back to the CPU, asynchronously.
      *
@@ -932,6 +1095,31 @@ interface IRendererLike {
         readonly frame: number;
         readonly ms: number;
     } | undefined;
+    /**
+     * GPU milliseconds of the last resolved compute frame, when the adapter reports one.
+     *
+     * The compute pool is a separate series from the render pool and `resolveGpuFrame` resolves it,
+     * so a GPU simulation's cost is measurable instead of being charged to whatever render frame
+     * happened to overlap. `undefined` for a WebGL2 fallback, an adapter without timestamps, or a
+     * frame that ran no compute.
+     */
+    gpuComputeMs?(): number | undefined;
+    /**
+     * The main render pass's GPU milliseconds, smoothed over fresh resolved samples, or `undefined`
+     * while no reading is fresh.
+     *
+     * `gpuFrameMs` is the whole render pool, main plus every shadow, reflection, post and HUD pass;
+     * the adaptive LOD control loop needs the main-pass share alone. `game.ts` splits the resolved
+     * frame through the pass recorder and feeds the sample here with {@link noteGpuMainMs}. A
+     * repeated frame id is a resolve still in flight and not a new reading, and with no fresh sample
+     * for too long the value reads absent, so a caller never adapts on a stale number.
+     */
+    gpuMainMs?(): number | undefined;
+    /**
+     * Records one resolved frame's main-pass GPU milliseconds into {@link gpuMainMs}. Called once a
+     * frame by `game.ts`; `ms` is `undefined` when the frame attributed no main-pass reading.
+     */
+    noteGpuMainMs?(ms: number | undefined, frame?: number): void;
     /** Starts a resolve of the GPU timestamps for the frames drawn since the last call. */
     resolveGpuFrame(): void;
     /**
@@ -1001,4 +1189,4 @@ interface IRendererOptions {
     }>) => unknown;
 }
 
-export { VELOCITY_PREVIOUS_INSTANCE_MATRICES as $, type IRenderChainStageContext as A, type IRenderChainVelocityMeasurement as B, type IRenderChainVelocityReport as C, DEFAULT_PIPELINE_CENSUS_LIMIT as D, type IRenderChainVelocityRequest as E, type FramePassKind as F, type IRenderChainVelocityResult as G, type IRenderPassSample as H, type IRendererLike as I, type IVelocityRenderPass as J, PIPELINE_CENSUS_VERSION as K, PipelineCensus as L, type PipelineCensusMode as M, type PipelineCensusStatus as N, RENDER_CHAIN_STAGE_ORDER as O, PIPELINE_CENSUS_CAPABILITY as P, RENDER_CHAIN_TIERS as Q, RENDER_CHAIN_MARKER as R, RenderChain as S, type RenderChainSource as T, type RenderChainStageId as U, type RenderChainStageName as V, type RenderChainTier as W, type RenderChainTierRequest as X, type RenderChainVelocitySource as Y, VELOCITY_OUTPUT_NAME as Z, VELOCITY_PREVIOUS_BONE_MATRICES as _, type IFrameBudgetWindow as a, VELOCITY_PREVIOUS_WORLD_MATRIX as a0, VelocityTracker as a1, counterDeviceOf as a2, createPipelineCensus as a3, ensureVelocityOutput as a4, prewarm as a5, readRenderChainObservation as a6, readRenderChainReport as a7, readVelocityPreviousBoneMatrices as a8, readVelocityPreviousMatrices as a9, readVelocityPreviousWorldMatrix as aa, velocityTexture as ab, withVelocityContext as ac, type IRendererOptions as ad, FRAME_BUDGET_MARKER as b, FRAME_BUDGET_PHASES as c, FRAME_HITCH_MARKER as d, FrameBudget as e, type FrameBudgetPhase as f, FrameCounters as g, type ICounterDevice as h, type IFrameBudgetOptions as i, type IFrameBudgetPassSummary as j, type IFrameBudgetSummary as k, type IFrameCounters as l, type IFramePhaseSample as m, type IPipelineCensus as n, type IPipelineCensusCounts as o, type IPipelineCensusEvent as p, type IPipelineCensusOptions as q, type IPipelineProvenance as r, type IPipelineShaderObservation as s, type IRenderChainApplied as t, type IRenderChainBudgetWindow as u, type IRenderChainDroppedStage as v, type IRenderChainOptions as w, type IRenderChainRenderer as x, type IRenderChainRequest as y, type IRenderChainStage as z };
+export { type RenderChainStageId as $, type IRenderChainRequest as A, type IRenderChainStage as B, type IRenderChainStageContext as C, DEFAULT_PIPELINE_CENSUS_LIMIT as D, type IRenderChainVelocityMeasurement as E, type FramePassKind as F, type IRenderChainVelocityReport as G, type IRenderChainVelocityRequest as H, type IRendererLike as I, type IRenderChainVelocityResult as J, type IRenderPassSample as K, type ITargetFps as L, type IVelocityRenderPass as M, MAX_TARGET_FPS as N, PIPELINE_CENSUS_VERSION as O, PIPELINE_CENSUS_CAPABILITY as P, PipelineCensus as Q, type PipelineCensusMode as R, type PipelineCensusStatus as S, type PlatformFormFactor as T, type PlatformOS as U, type PlatformRuntime as V, RENDER_CHAIN_MARKER as W, RENDER_CHAIN_STAGE_ORDER as X, RENDER_CHAIN_TIERS as Y, RenderChain as Z, type RenderChainSource as _, type IFrameBudgetWindow as a, type RenderChainStageName as a0, type RenderChainTier as a1, type RenderChainTierRequest as a2, type RenderChainVelocitySource as a3, type TargetFpsSource as a4, VELOCITY_OUTPUT_NAME as a5, VELOCITY_PREVIOUS_BONE_MATRICES as a6, VELOCITY_PREVIOUS_INSTANCE_MATRICES as a7, VELOCITY_PREVIOUS_WORLD_MATRIX as a8, VelocityTracker as a9, counterDeviceOf as aa, createPipelineCensus as ab, ensureVelocityOutput as ac, getPlatform as ad, isMobile as ae, isNative as af, isTouchscreenAvailable as ag, isWeb as ah, prewarm as ai, readRenderChainObservation as aj, readRenderChainReport as ak, readVelocityPreviousBoneMatrices as al, readVelocityPreviousMatrices as am, readVelocityPreviousWorldMatrix as an, resolveTargetFps as ao, snapRefreshRate as ap, velocityTexture as aq, withVelocityContext as ar, type IRendererOptions as as, DEFAULT_TARGET_FPS as b, FRAME_BUDGET_MARKER as c, FRAME_BUDGET_PHASES as d, FRAME_HITCH_MARKER as e, FrameBudget as f, type FrameBudgetPhase as g, FrameCounters as h, type ICounterDevice as i, type IFrameBudgetOptions as j, type IFrameBudgetPassSummary as k, type IFrameBudgetSummary as l, type IFrameCounters as m, type IFramePhaseSample as n, type IPipelineCensus as o, type IPipelineCensusCounts as p, type IPipelineCensusEvent as q, type IPipelineCensusOptions as r, type IPipelineProvenance as s, type IPipelineShaderObservation as t, type IPlatformInfo as u, type IRenderChainApplied as v, type IRenderChainBudgetWindow as w, type IRenderChainDroppedStage as x, type IRenderChainOptions as y, type IRenderChainRenderer as z };

package/dist/ui-layer.d.ts

@@ -58,10 +58,12 @@ declare const GAME_STATE_MESSAGE = "tn:state";
 /** The message the UI end sends when the player acts on a control. */
 declare const UI_INTENT_MESSAGE = "tn:intent";
 /**
- * The frame rate the game end publishes when it was launched in dev mode.
+ * The scene-shape verdict the game end publishes when it was launched in dev mode.
  *
- * Separate from the state stream because it is not game state: a HUD that showed it would be
- * showing the engine's own measurement, and a game that never asked for dev mode never sends it.
+ * Separate from the state stream because it is not game state: it is the engine's own measurement
+ * of the scene, and a game that never asked for dev mode never sends it. No frame rate rides it —
+ * the loop's rAF rate reads throttled under a compositor or a virtual display, so a number drawn
+ * from it lies in exactly the sessions where somebody is trying to measure.
  */
 declare const UI_DEV_METRICS_MESSAGE = "tn:dev-metrics";
 /**