@aethervtt/shard-render 0.0.1 → 0.2.0

package/dist/outline.js

@@ -0,0 +1,42 @@
+import { defineComponent, defineResource, onAdd, t } from "@aethervtt/shard-core";
+import { warnFeatureMissing } from "./features.js";
+const OUTLINE_OCCLUSION = ["hide", "show", "dim"];
+const Outline = defineComponent(
+  "render/Outline",
+  {
+    color: t.color({
+      default: [1, 0.78, 0.2, 1],
+      description: "Outline color (linear), with alpha."
+    }),
+    width: t.f32({
+      default: 2,
+      min: 0,
+      max: 32,
+      unit: "px",
+      description: "Width in CSS pixels, outside the silhouette, at any zoom and display density."
+    }),
+    occluded: t.enum(OUTLINE_OCCLUSION, {
+      description: "Where something hides the outlined object: hide the outline there, show it anyway, or dim it."
+    })
+  },
+  {
+    description: "Outlines a renderable, or every renderable under this entity. Selection and hover are two Outlines with different colors; the host sets and clears them."
+  }
+);
+const OutlinePath = defineResource("render/OutlinePath", {
+  description: "Present when the outline pass is installed."
+});
+const MAX_OUTLINE_STYLES = 16;
+function observeOutlinesWithoutPass(world) {
+  world.observe(onAdd(Outline), ({ world: w }) => {
+    if (!w.hasResource(OutlinePath))
+      warnFeatureMissing(w, "An entity has Outline", "outlinePlugin", "it draws no outline");
+  });
+}
+export {
+  MAX_OUTLINE_STYLES,
+  OUTLINE_OCCLUSION,
+  Outline,
+  OutlinePath,
+  observeOutlinesWithoutPass
+};

package/dist/overlay-registry.d.ts

@@ -1,6 +1,8 @@
 import type { Entity, World } from '@aethervtt/shard-core';
 import type { GizmoStore } from './gizmos.js';
-export declare const OVERLAYS: readonly ['bounds', 'lights', 'cameras', 'cascades', 'normals', 'axes', 'labels'];
+export declare const OVERLAYS: readonly ['bounds', 'lights', 'cameras', 'cascades', 'normals', 'axes', 'labels', 
+/** Frame time, the top 8 spans, and the GPU frame (0074). */
+'perf'];
 export type Overlay = (typeof OVERLAYS)[number];
 /** An overlay another package draws (physics colliders, the navmesh, UI rects). */
 export interface OverlayDef {

package/dist/overlay-registry.js

@@ -5,7 +5,9 @@ const OVERLAYS = [
   "cascades",
   "normals",
   "axes",
-  "labels"
+  "labels",
+  /** Frame time, the top 8 spans, and the GPU frame (0074). */
+  "perf"
 ];
 const extraOverlays = /* @__PURE__ */ new Map();
 function defineOverlay(def) {

package/dist/overlays.js

@@ -15,6 +15,7 @@ import {
 import { DirectionalLight, Lights } from "./lights.js";
 import { defineOverlay, OVERLAYS, registeredOverlays } from "./overlay-registry.js";
 const extraOverlays = registeredOverlays();
+import { drawPerfOverlay } from "./perf-overlay.js";
 import { Views } from "./plugin.js";
 import { Cameras, cameraOf } from "./view.js";
 import {
@@ -34,7 +35,8 @@ function scenePath(world, entity) {
   return v?.path || void 0;
 }
 const DebugOverlays = defineResource("render/DebugOverlays", {
-  description: "Built-in debug drawings, each drawn through Gizmos: bounds, light volumes, camera frustums, shadow cascades, normals, transform axes, and entity labels.",
+  hostWritable: true,
+  description: "Built-in debug drawings, each drawn through Gizmos: bounds, light volumes, camera frustums, shadow cascades, normals, transform axes, entity labels, and perf (frame time, top spans, GPU frame).",
   init: () => ({
     bounds: false,
     lights: false,
@@ -43,6 +45,7 @@ const DebugOverlays = defineResource("render/DebugOverlays", {
     normals: false,
     axes: false,
     labels: false,
+    perf: false,
     extra: {},
     filter: { components: [], path: "" },
     name: scenePath
@@ -226,7 +229,7 @@ const drawOverlays = defineSystem({
     g.overlay.clear();
     let extra = false;
     for (const name in o.extra) if (o.extra[name] && extraOverlays.has(name)) extra = true;
-    if (!(o.bounds || o.lights || o.cameras || o.cascades || o.normals || o.axes || o.labels || extra))
+    if (!(o.bounds || o.lights || o.cameras || o.cascades || o.normals || o.axes || o.labels || o.perf || extra))
       return;
     g.beginOverlays();
     try {
@@ -249,6 +252,7 @@ function draw(world, o, g) {
     }
     if (o.lights) drawLights(world, o, g, defs);
     const primary = primaryCamera(world);
+    if (o.perf) drawPerfOverlay(world, g, primary);
     if (o.cameras) {
       for (const [entity, cam] of world.resource(Cameras)) {
         if (entity === primary || !passes(world, o, entity, defs)) continue;

package/dist/perf-overlay.d.ts

@@ -0,0 +1,9 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+import type { GizmoStore } from './gizmos.js';
+/** The overlay's text and colours: refreshed four times a second, so it's readable and cheap. */
+export declare function perfOverlayLines(world: World): {
+    lines: string[];
+    colors: number[][];
+};
+/** Draws the perf overlay for the primary camera. Gizmo labels center on their anchor, above it. */
+export declare function drawPerfOverlay(world: World, g: GizmoStore, camera: Entity | undefined): void;

package/dist/perf-overlay.js

@@ -0,0 +1,125 @@
+import { ProfilerResource, spanStats } from "@aethervtt/shard-core";
+import {
+  gpuPassOverlap,
+  isGpuPass,
+  measureSlices,
+  PerfBudgets,
+  PerfScenario,
+  perfBudgetState,
+  Time
+} from "@aethervtt/shard-runtime";
+import { PassCosts } from "./ablation.js";
+import { LABEL_FONT, labelWidth } from "./gizmo-font.js";
+import { Cameras } from "./view.js";
+const LINES = 8;
+const PASS_LINES = 4;
+const REFRESH_S = 0.25;
+const MARGIN = 8;
+const COLOR = [1, 1, 1, 1];
+const HEADER = [0.55, 0.9, 1, 1];
+const GREY = [0.6, 0.6, 0.6, 1];
+const RED = [1, 0.35, 0.3, 1];
+const LABEL_OPTIONS = { depthTest: false };
+const states = /* @__PURE__ */ new WeakMap();
+const pad = (ms) => ms.toFixed(2).padStart(6);
+const percent = (share) => `${Math.round(share * 100)}%`.padStart(4);
+function perfOverlayLines(world) {
+  const now = world.tryResource(Time)?.elapsed ?? 0;
+  let state = states.get(world);
+  if (state && now - state.at < REFRESH_S && now >= state.at) return state;
+  const profiler = world.tryResource(ProfilerResource);
+  const lines = [];
+  const colors = [];
+  const line = (text, color) => {
+    lines.push(text);
+    colors.push(color);
+  };
+  if (profiler) {
+    const frame = spanStats(profiler, "frame");
+    const gpu = spanStats(profiler, "gpu:frame");
+    line(
+      `frame ${frame ? pad(frame.avg) : "     -"} ms  p95 ${frame ? pad(frame.p95) : "     -"}` + (profiler.gpu.status === "unavailable" ? "   gpu n/a" : `   gpu ${gpu ? pad(gpu.avg) : "     -"} ms`),
+      HEADER
+    );
+    const overlapping = gpuPassOverlap(profiler)?.overlapping ?? false;
+    const spans = [];
+    const passes = [];
+    for (const name2 of profiler.names()) {
+      if (name2 === "frame" || name2 === "gpu:frame" || name2.startsWith("schedule/") || name2.startsWith("commands/"))
+        continue;
+      const entry = { name: name2, avg: profiler.timing(name2).avg };
+      if (overlapping && name2.startsWith("gpu:")) {
+        if (isGpuPass(name2)) passes.push(entry);
+      } else spans.push(entry);
+    }
+    spans.sort((a, b) => b.avg - a.avg || (a.name < b.name ? -1 : 1));
+    for (let i = 0; i < Math.min(LINES, spans.length); i++) {
+      line(`${pad(spans[i].avg)} ms  ${spans[i].name}`, COLOR);
+    }
+    if (overlapping) {
+      const ablation = world.tryResource(PassCosts)?.latest;
+      if (ablation && ablation.passes.length > 0) {
+        line("gpu passes by ablation (timestamps overlap)", GREY);
+        const ranked = [...ablation.passes].sort((a, b) => b.ms - a.ms);
+        for (let i = 0; i < Math.min(PASS_LINES, ranked.length); i++) {
+          line(`${pad(ranked[i].ms)} ms  gpu:${ranked[i].pass}  ablated`, COLOR);
+        }
+      } else {
+        line("gpu passes overlapping: perf.ablate ranks them", GREY);
+        passes.sort((a, b) => a.name < b.name ? -1 : 1);
+        for (let i = 0; i < Math.min(PASS_LINES, passes.length); i++) {
+          line(`${pad(passes[i].avg)} ms  ${passes[i].name}  overlapping`, GREY);
+        }
+      }
+    }
+    const name = world.tryResource(PerfScenario)?.name;
+    const scenario = name ? world.tryResource(PerfBudgets)?.budgets.scenarios[name] : void 0;
+    if (name && scenario) {
+      const machine = perfBudgetState(world)?.detection.machine ?? null;
+      line(`scenario ${name}${machine ? ` on ${machine}` : ""}: share of frame / budget`, HEADER);
+      for (const s of measureSlices(profiler, scenario, machine).slices) {
+        const measured = s.measuredShare === null ? "   -" : percent(s.measuredShare);
+        line(
+          `${s.track} ${measured} / ${percent(s.share)}  ${s.slice}`,
+          s.verdict === "over" ? RED : s.verdict === "unmeasured" ? GREY : COLOR
+        );
+      }
+    }
+  }
+  state = { at: now, lines, colors };
+  states.set(world, state);
+  return state;
+}
+const point = new Float32Array(3);
+function unproject(inv, width, height, px, py) {
+  const x = px / width * 2 - 1;
+  const y = 1 - py / height * 2;
+  const z = 0.5;
+  const w = inv[3] * x + inv[7] * y + inv[11] * z + inv[15];
+  point[0] = (inv[0] * x + inv[4] * y + inv[8] * z + inv[12]) / w;
+  point[1] = (inv[1] * x + inv[5] * y + inv[9] * z + inv[13]) / w;
+  point[2] = (inv[2] * x + inv[6] * y + inv[10] * z + inv[14]) / w;
+  return point;
+}
+function drawPerfOverlay(world, g, camera) {
+  if (camera === void 0) return;
+  const cam = world.resource(Cameras).get(camera);
+  if (!cam || cam.width <= 0 || cam.height <= 0) return;
+  const { lines, colors } = perfOverlayLines(world);
+  const step = LABEL_FONT.cellHeight + 4;
+  for (let i = 0; i < lines.length; i++) {
+    const text = lines[i];
+    const px = MARGIN + labelWidth(text) / 2;
+    const py = MARGIN + (i + 1) * step;
+    g.label(
+      unproject(cam.invViewProj, cam.width, cam.height, px, py),
+      text,
+      colors[i],
+      LABEL_OPTIONS
+    );
+  }
+}
+export {
+  drawPerfOverlay,
+  perfOverlayLines
+};

package/dist/picking.d.ts

@@ -12,7 +12,22 @@ export interface PickHit {
     normal: [number, number, number];
     /** Meters from the camera (from the ray origin, for raycasts). */
     distance: number;
+    /**
+     * What within the entity was hit, when something knows (0059): a tilemap gives
+     * `{ kind: 'tile', layer, x, y, tile }`, the tile named as its palette names it.
+     */
+    detail?: PickDetail;
 }
+/** Detail of a pick within an entity: `kind` says what the rest means. */
+export interface PickDetail {
+    kind: string;
+    [key: string]: unknown;
+}
+/**
+ * Turns a hit into detail about what within the entity it hit (a tile of a tilemap), or
+ * undefined when the hit isn't its kind. Runs for GPU picks and raycasts alike.
+ */
+export type PickDetailer = (world: World, hit: PickHit) => PickDetail | undefined;
 interface PickRequest {
     x: number;
     y: number;
@@ -35,6 +50,8 @@ export interface PickingState {
     pending: Map<string, PickRequest[]>;
     drawers: Map<string, PickDrawer>;
     blockers: Map<string, PickBlocker>;
+    /** Detail for hits, by who adds it (tilemaps). */
+    detailers: Map<string, PickDetailer>;
     /** Views whose pick pass skipped a draw (a pipeline still compiling): their picks wait a frame. */
     incomplete: Set<string>;
 }

package/dist/picking.js

@@ -1,9 +1,10 @@
 import { defineResource, mat4, ShardError } from "@aethervtt/shard-core";
 import { GlobalTransform } from "@aethervtt/shard-transform";
-import { Meshes } from "./assets.js";
-import { drawMaterials, ForwardStateResource, PASS_PICK } from "./forward.js";
+import { Materials, Meshes } from "./assets.js";
+import { addRenderFeatures } from "./features.js";
+import { drawMaterials, ForwardStateResource, PASS_PICK, PASS_PICK_GROUND } from "./forward.js";
 import { RenderPhase } from "./graph.js";
-import { Lod, Mesh3d } from "./instances.js";
+import { Lod, Mesh3d, MeshMaterial } from "./instances.js";
 import { DebugOverlays } from "./overlays.js";
 import { Graph, Views } from "./plugin.js";
 import { cameraOf } from "./view.js";
@@ -14,6 +15,7 @@ const Picking = defineResource("render/Picking", {
     pending: /* @__PURE__ */ new Map(),
     drawers: /* @__PURE__ */ new Map(),
     blockers: /* @__PURE__ */ new Map(),
+    detailers: /* @__PURE__ */ new Map(),
     incomplete: /* @__PURE__ */ new Set()
   })
 });
@@ -69,6 +71,8 @@ function pickNode(world) {
       drawMaterials(ctx, state, pv, cam, cam.draws, PASS_PICK);
       if (cam.deferred) drawMaterials(ctx, state, pv, cam, cam.forwardOnly, PASS_PICK);
       drawMaterials(ctx, state, pv, cam, cam.transparent, PASS_PICK);
+      drawMaterials(ctx, state, pv, cam, cam.ground, PASS_PICK_GROUND);
+      drawMaterials(ctx, state, pv, cam, cam.overlay, PASS_PICK_GROUND);
       for (const draw of picking.drawers.values()) draw(ctx, cam);
       if (ctx.gpu.pipelines.skipped > skipped) picking.incomplete.add(ctx.view.name);
     }
@@ -147,13 +151,15 @@ function pickReadbackNode(world) {
               const dx = position[0] - eye[0];
               const dy = position[1] - eye[1];
               const dz = position[2] - eye[2];
-              r.resolve({
-                entity,
-                path: w.isAlive(entity) ? name(w, entity) : void 0,
-                position,
-                normal: [n[0], n[1], n[2]],
-                distance: Math.sqrt(dx * dx + dy * dy + dz * dz)
-              });
+              r.resolve(
+                withDetail(w, {
+                  entity,
+                  path: w.isAlive(entity) ? name(w, entity) : void 0,
+                  position,
+                  normal: [n[0], n[1], n[2]],
+                  distance: Math.sqrt(dx * dx + dy * dy + dz * dz)
+                })
+              );
             });
             buffer.unmap();
             buffer.destroy();
@@ -173,6 +179,12 @@ function addPickNodes(world) {
   graph.declare({ name: "pick-id", format: "r32uint", usage });
   graph.declare({ name: "pick-normal", format: "rgba32float", usage });
   graph.declare({ name: "pick-depth", format: "depth32float" });
+  addRenderFeatures(world, {
+    name: "render/picking",
+    description: "Entity picking from id and normal targets, read back per request.",
+    nodes: ["picking", "picking/readback"],
+    baseline: { strategy: "The same targets, read back with copies" }
+  });
   graph.addNode("picking", pickNode(world));
   graph.addNode("picking/readback", pickReadbackNode(world));
 }
@@ -235,11 +247,14 @@ function worldBox(bb, m, out) {
 }
 function buildBvh(world, tick, tables) {
   const items = [];
+  const materials = world.tryResource(Materials);
   for (const table of world.query({ with: [Mesh3d, GlobalTransform, ComputedVisibility] }).tables) {
     const g = table.column(GlobalTransform, "matrix");
     const vis = table.column(ComputedVisibility, "visible");
+    const refs = table.has(MeshMaterial) ? table.column(MeshMaterial, "material") : void 0;
     for (let i = 0; i < table.count; i++) {
       if (!vis[i]) continue;
+      if (refs && materials?.get(refs[i])?.type.pickable === false) continue;
       const entity = table.entities[i];
       const mesh = meshOf(world, entity);
       if (!mesh) continue;
@@ -442,7 +457,21 @@ function raycast(world, origin, direction, options = {}) {
     }
   }
   hits.sort((a, b) => a.distance - b.distance);
-  return options.all ? hits : hits.slice(0, 1);
+  const out = options.all ? hits : hits.slice(0, 1);
+  for (const hit of out) withDetail(world, hit);
+  return out;
+}
+function withDetail(world, hit) {
+  const detailers = world.tryResource(Picking)?.detailers;
+  if (!detailers || detailers.size === 0 || !world.isAlive(hit.entity)) return hit;
+  for (const detailer of detailers.values()) {
+    const detail = detailer(world, hit);
+    if (detail) {
+      hit.detail = detail;
+      break;
+    }
+  }
+  return hit;
 }
 export {
   BvhResource,

package/dist/pixel-perfect-plugin.js

@@ -1,4 +1,5 @@
 import { definePlugin } from "@aethervtt/shard-runtime";
+import { addRenderFeatures } from "./features.js";
 import { RenderPhase } from "./graph.js";
 import { PixelPerfectPath } from "./pixel-perfect.js";
 import { Graph, Shaders } from "./plugin.js";
@@ -6,7 +7,7 @@ import { registerShaders } from "./shaders.js";
 const PIXEL_PERFECT_SHADERS = {
   "shard::post::pixel_upscale": `
 struct Upscale {
-  /** offset (xy), scale, 0. */
+  /** offset (xy), scale, the bars' alpha (0 for a camera clearing to alpha, 0052). */
   params: vec4f,
 }
 
@@ -17,7 +18,7 @@ struct Upscale {
 @fragment fn fs(@builtin(position) frag: vec4f) -> @location(0) vec4f {
   let p = (frag.xy - upscale.params.xy) / upscale.params.z;
   let size = vec2f(textureDimensions(source));
-  if (any(p < vec2f(0.0)) || any(p >= size)) { return vec4f(0.0, 0.0, 0.0, 1.0); }
+  if (any(p < vec2f(0.0)) || any(p >= size)) { return vec4f(0.0, 0.0, 0.0, upscale.params.w); }
   return textureLoad(source, vec2i(floor(p)), 0);
 }`
 };
@@ -92,6 +93,7 @@ function pixelUpscaleNode() {
       params[0] = layout.offsetX;
       params[1] = layout.offsetY;
       params[2] = layout.scale;
+      params[3] = ctx.view.data.alphaOutput === true ? 0 : 1;
       gpu.device.queue.writeBuffer(buffer, 0, params);
       const source = layout.target.texture();
       let cached = groups.get(ctx.view.name);
@@ -125,6 +127,12 @@ const pixelPerfectPlugin = definePlugin({
   },
   ready(app) {
     registerShaders(app.world.resource(Shaders), PIXEL_PERFECT_SHADERS);
+    addRenderFeatures(app.world, {
+      name: "render/pixel-perfect",
+      description: "Pixel-art cameras: low-resolution render, integer upscale.",
+      nodes: ["pixel-upscale"],
+      baseline: { strategy: "The same fragment pass" }
+    });
     app.world.resource(Graph).addNode("pixel-upscale", pixelUpscaleNode());
   }
 });

package/dist/plugin.d.ts

@@ -1,9 +1,9 @@
 import { type World } from '@aethervtt/shard-core';
-import { type GpuContext } from '@aethervtt/shard-gpu';
+import { type GpuBackendChoice, type GpuContext, type Surface, type SurfaceAlpha, type Webgl2ContextOptions } from '@aethervtt/shard-gpu';
 import { type Plugin } from '@aethervtt/shard-runtime';
 import { type ShaderBake, ShaderLibrary } from '@aethervtt/shard-shader';
 import { type CapturedBuffer, type CapturedImage, RenderGraph, type RenderView } from './graph.js';
-import { type RenderTarget } from './target.js';
+import type { RenderTarget } from './target.js';
 export declare const Gpu: import("@aethervtt/shard-core").ResourceDef<GpuContext>;
 export declare const Graph: import("@aethervtt/shard-core").ResourceDef<RenderGraph>;
 export declare const Shaders: import("@aethervtt/shard-core").ResourceDef<ShaderLibrary>;
@@ -29,16 +29,43 @@ export declare const RenderSet: {
     readonly Graph: import("@aethervtt/shard-core").SystemSetDef;
 };
 export interface RenderPluginOptions {
-    /** Render into this canvas. Omit for headless (views use offscreen targets). */
+    /**
+     * Render into this canvas: the plugin adds it as a surface of `gpu` (or of a device it makes).
+     * Omit for headless (views use offscreen targets).
+     */
     canvas?: HTMLCanvasElement | OffscreenCanvas;
-    /** An existing GPU context (e.g. Dawn in Node). Otherwise one is created in `ready`. */
+    /**
+     * With `canvas`: 'premultiplied' composites the canvas over the page, where cameras clearing to
+     * alpha 0 show what's under it (0052). Default 'opaque'.
+     */
+    alpha?: SurfaceAlpha;
+    /** Render into a surface already on `gpu` (`gpu.addSurface`). Disposing the app removes it. */
+    surface?: Surface;
+    /**
+     * An existing GPU context (e.g. Dawn in Node, or one shared with other apps). Otherwise one is
+     * created in `ready` and destroyed with the app.
+     */
     gpu?: GpuContext;
+    /** The name this app's GPU objects count under in `gpu.stats(owner)`. Default `render:<n>`. */
+    owner?: string;
     /**
      * Headless stand-in for the window: cameras without a target render here. Used by the CLI for
-     * screenshots. Ignored when there's a canvas.
+     * screenshots. Ignored when there's a canvas or surface.
      */
     target?: RenderTarget;
     features?: GPUFeatureName[];
+    /**
+     * The graphics API, when the plugin makes the device (0064). 'auto' (default): WebGPU where it
+     * works, else WebGL2 on the baseline tier. 'webgpu' or 'webgl2' insist on one.
+     */
+    backend?: GpuBackendChoice;
+    /** WebGL2 settings, for tests and tools (the 'minimum' profile, GL error checks). */
+    webgl2?: Webgl2ContextOptions;
+    /**
+     * 'baseline' runs the baseline tier even where the full one would (on WebGPU, a
+     * compatibility-mode device), when the plugin makes the device.
+     */
+    tier?: 'baseline';
     /** An existing shader library to share (e.g. a preview rendering the game's own shaders). */
     shaders?: ShaderLibrary;
     /**
@@ -57,8 +84,15 @@ export interface RenderPluginOptions {
  * so the renderer's description grows with what's installed.
  */
 export declare const RenderDescribers: import("@aethervtt/shard-core").ResourceDef<Map<string, (world: World) => unknown>>;
-export declare const RenderOptions: import("@aethervtt/shard-core").ResourceDef<Required<Pick<RenderPluginOptions, "windowView">>>;
+export interface RenderOptionsValue {
+    windowView: boolean;
+    /** What this app's GPU objects count under in `gpu.stats` (0052). */
+    owner: string;
+}
+export declare const RenderOptions: import("@aethervtt/shard-core").ResourceDef<RenderOptionsValue>;
 export declare function renderPlugin(options?: RenderPluginOptions): Plugin;
+/** The name this app's GPU objects count under in `gpu.stats` (0052). */
+export declare function renderOwner(world: World): string;
 /** A screenshot of a view (default: the window) after the next frame renders it. */
 export declare function captureView(world: World, view?: string): Promise<CapturedImage>;
 /**
@@ -67,6 +101,11 @@ export declare function captureView(world: World, view?: string): Promise<Captur
  * perspective, fog, bloom…), `depth`, G-buffer channels, effect buffers.
  */
 export declare function captureBuffer(world: World, view: string, buffer: string): Promise<CapturedBuffer>;
+/** Every buffer and texture on the device by category: the ledger's total (0055, 0074). */
+export declare function gpuMemory(world: World): {
+    bytes: number;
+    byCategory: Record<string, number>;
+};
 /** What the renderer is doing: graph order, culled nodes, views, pending pipelines. For agents. */
 export declare function describeRender(world: World): {
     order: {
@@ -100,7 +139,12 @@ export declare function describeRender(world: World): {
         taaResets: number;
         originShifts: number;
     };
-    memory: import("./stats.js").GpuMemoryData;
+    memory: {
+        textures: number;
+        textureBytes: number;
+        bytes: number;
+        byCategory: Record<string, number>;
+    };
     recentErrors: {
         code: string;
         message: string;
@@ -108,4 +152,22 @@ export declare function describeRender(world: World): {
         path?: string;
         details?: unknown[];
     }[];
+    features: {
+        name: string;
+        nodes: string[];
+        baseline: string;
+    }[];
+    health: import("./health.js").RenderHealthValue;
+    backend: import("@aethervtt/shard-gpu").GpuBackendName;
+    tier: import("@aethervtt/shard-gpu").GpuTier;
+    capabilities: import("@aethervtt/shard-gpu").GpuCapabilities;
+    shaderCache: import("@aethervtt/shard-gpu").ShaderCacheStats | undefined;
+    limits: {
+        maxTextureDimension2D: number;
+        maxColorAttachments: number;
+        maxSampledTexturesPerShaderStage: number;
+        maxInterStageShaderVariables: number;
+        maxUniformBufferBindingSize: number;
+    };
+    reasons: readonly import("@aethervtt/shard-gpu").GraphicsReason[];
 } & Record<string, unknown>;