@aethervtt/shard-render 0.0.1 → 0.2.0

package/dist/plugin.js

@@ -1,20 +1,39 @@
+import { AssetServerResource } from "@aethervtt/shard-assets";
 import {
   defineEvent,
   defineResource,
   defineSystem,
   defineSystemSet,
   Last,
+  ProfilerResource,
   ShardError
 } from "@aethervtt/shard-core";
-import { createGpuContext } from "@aethervtt/shard-gpu";
-import { definePlugin, LogResource } from "@aethervtt/shard-runtime";
+import {
+  createGpuContext
+} from "@aethervtt/shard-gpu";
+import {
+  definePlugin,
+  FrameDemand,
+  LOADING_DEMAND,
+  LogResource,
+  PerfProviders
+} from "@aethervtt/shard-runtime";
 import { ShaderLibrary } from "@aethervtt/shard-shader";
+import { PassCosts } from "./ablation.js";
+import { loadDataTextures, releaseDataStores } from "./data-store.js";
+import { checkUnsupportedFeatures, describeFeatures, RenderFeatures } from "./features.js";
 import { RenderGraph } from "./graph.js";
+import {
+  healthSystem,
+  RenderHealth,
+  RenderHealthChanged,
+  RenderHealthReports,
+  raiseHealthIssue
+} from "./health.js";
 import { registerEngineShaders } from "./shaders.js";
 import { GpuMemory, RenderCounters, RenderStats } from "./stats.js";
-import { WindowTarget } from "./target.js";
 const Gpu = defineResource("render/Gpu", {
-  description: "The GPU device, caches, and canvas."
+  description: "The GPU device, its surfaces (canvases), and caches. Apps can share one."
 });
 const Graph = defineResource("render/Graph", {
   description: "Render graph nodes, run for every view each frame."
@@ -26,7 +45,7 @@ const Views = defineResource("render/Views", {
   description: "Views to render this frame. Rebuilt every frame by extract systems."
 });
 const Window = defineResource("render/Window", {
-  description: "Where cameras without a target render: the canvas swapchain, or an offscreen target when headless."
+  description: "Where cameras without a target render: the app's surface (canvas), or an offscreen target when headless."
 });
 const GpuDeviceLost = defineEvent(
   "render/GpuDeviceLost",
@@ -51,12 +70,37 @@ const begin = defineSystem({
     world.resource(Gpu).pipelines.skipped = 0;
   }
 });
+const markMissing = defineSystem({
+  name: "render/mark-missing",
+  description: "Puts MissingAsset on entities that reference an asset showing a fallback.",
+  run: (_, world) => world.tryResource(AssetServerResource)?.markMissing()
+});
+const checkUnsupported = defineSystem({
+  name: "render/check-unsupported",
+  description: "On the baseline tier: reports render features the scene uses that it can't run (render/feature-unsupported), and WebGL2 shaders translated at load (render/shader-cache-miss).",
+  setup: () => ({ misses: 0 }),
+  run: (state, world) => {
+    const gpu = world.tryResource(Gpu);
+    if (gpu?.tier !== "baseline") return;
+    checkUnsupportedFeatures(world);
+    const cache = gpu.shaderCache();
+    if (!cache || cache.misses.length === state.misses) return;
+    state.misses = cache.misses.length;
+    let ms = 0;
+    for (const m of cache.misses) ms += m.ms;
+    const load = cache.nagaLoadMs === void 0 ? "" : `, ${cache.nagaLoadMs.toFixed(0)} ms to load it`;
+    raiseHealthIssue(world, {
+      code: "render/shader-cache-miss",
+      severity: "info",
+      message: `${state.misses} shader stage${state.misses === 1 ? "" : "s"} translated to GLSL at load (${ms.toFixed(0)} ms in naga${load}): \`shard shaders bake\` ships them translated`
+    });
+  }
+});
 const execute = defineSystem({
   name: "render/execute-graph",
   description: "Runs the render graph for every view and submits.",
-  setup: () => ({ recovering: { value: false } }),
-  run: ({ recovering }, world) => {
-    if (recovering.value) return;
+  run: (_, world) => {
+    if (world.resource(Gpu).status !== "ok") return;
     const views = world.resource(Views).list;
     const window = world.tryResource(Window);
     const options = world.resource(RenderOptions);
@@ -65,13 +109,35 @@ const execute = defineSystem({
     }
     if (views.length === 0) return;
     world.resource(Graph).execute(world, views);
+    world.tryResource(RenderStats)?.endFrame(world.resource(Gpu).uploads(options.owner));
+    const gpu = world.resource(Gpu);
+    anyPending = gpu.pipelines.skipped > 0 || gpu.pipelines.pending > 0;
+    if (!anyPending) world.tryResource(RenderStats)?.forEach(notePending);
+    world.tryResource(FrameDemand)?.set(LOADING_DEMAND, anyPending);
   }
 });
+let anyPending = false;
+function notePending(stats) {
+  if (stats.pending > 0) anyPending = true;
+}
 const RenderDescribers = defineResource(
   "render/Describers",
   { description: "Sections plugins add to render.describe.", init: () => /* @__PURE__ */ new Map() }
 );
-const RenderOptions = defineResource("render/Options");
+const RenderOptions = defineResource("render/Options", {
+  description: "The render plugin's settings: the fallback window view, and the app's GPU owner."
+});
+const renderApps = /* @__PURE__ */ new WeakMap();
+let nextOwner = 1;
+function nextRefresh() {
+  return new Promise((resolve) => requestAnimationFrame(resolve));
+}
+function presentOn(state) {
+  return () => {
+    const done = state.gpu.device.queue.onSubmittedWorkDone();
+    return typeof requestAnimationFrame === "function" ? done.then(nextRefresh) : done.then(() => void 0);
+  };
+}
 function renderPlugin(options = {}) {
   return definePlugin({
     name: "render",
@@ -79,8 +145,13 @@ function renderPlugin(options = {}) {
       // graph and device
       Gpu,
       GpuDeviceLost,
+      PassCosts,
       Graph,
       RenderDescribers,
+      RenderFeatures,
+      RenderHealth,
+      RenderHealthChanged,
+      RenderHealthReports,
       RenderOptions,
       Shaders,
       Views,
@@ -88,40 +159,130 @@ function renderPlugin(options = {}) {
     ],
     dependencies: ["core/time"],
     build(app) {
-      app.insertResource(Views, { list: [] }).insertResource(RenderOptions, { windowView: options.windowView ?? true }).configureSets(
+      const state = {
+        owner: options.owner ?? `render:${nextOwner++}`,
+        gpu: void 0,
+        ownsDevice: false,
+        surface: void 0,
+        saved: [],
+        unsubscribe: []
+      };
+      renderApps.set(app, state);
+      app.addScope({
+        enter() {
+          const gpu = state.gpu;
+          state.saved.push(gpu?.owner);
+          if (gpu) gpu.owner = state.owner;
+        },
+        exit() {
+          const previous = state.saved.pop();
+          if (state.gpu && previous !== void 0) state.gpu.owner = previous;
+        }
+      });
+      app.insertResource(Views, { list: [] }).insertResource(RenderOptions, {
+        windowView: options.windowView ?? true,
+        owner: state.owner
+      }).configureSets(
         Last,
         RenderSet.Extract.after(RenderSet.Begin),
         RenderSet.Prepare.after(RenderSet.Extract),
         RenderSet.Queue.after(RenderSet.Prepare),
         RenderSet.Upload.after(RenderSet.Queue),
         RenderSet.Graph.after(RenderSet.Upload)
-      ).addSystems(Last, begin.inSet(RenderSet.Begin), execute.inSet(RenderSet.Graph));
+      ).addSystems(
+        Last,
+        begin.inSet(RenderSet.Begin),
+        markMissing.inSet(RenderSet.Begin).after(begin),
+        checkUnsupported.inSet(RenderSet.Begin).after(begin),
+        execute.inSet(RenderSet.Graph),
+        healthSystem({ status: () => state.gpu?.status ?? "ok" }).inSet(RenderSet.Graph).after(execute)
+      );
     },
     async ready(app) {
-      const gpu = options.gpu ?? await createGpuContext({ canvas: options.canvas, features: options.features });
-      app.insertResource(Gpu, gpu);
-      app.insertResource(Graph, new RenderGraph(gpu));
+      const state = renderApps.get(app);
+      const given = options.gpu ?? options.surface?.gpu;
+      if (options.surface && options.gpu && options.surface.gpu !== options.gpu) {
+        throw new ShardError("render/surface-device", "The surface belongs to another GpuContext", {
+          hint: "Pass the GpuContext the surface was added to (surface.gpu), or omit gpu."
+        });
+      }
+      const gpu = given ?? await createGpuContext({
+        features: options.features,
+        backend: options.backend,
+        webgl2: options.webgl2,
+        tier: options.tier,
+        canvas: options.canvas,
+        alpha: options.alpha
+      });
+      state.gpu = gpu;
+      state.ownsDevice = !given;
+      if (gpu.tier === "baseline") await loadDataTextures();
+      gpu.withOwner(state.owner, () => {
+        app.insertResource(Gpu, gpu);
+        app.insertResource(Graph, new RenderGraph(gpu));
+      });
+      const providers = app.world.initResource(PerfProviders);
+      providers.gpuMemory = gpuMemory;
+      providers.adapter = adapterIdentity;
+      const profiler = app.world.tryResource(ProfilerResource);
+      if (profiler) {
+        profiler.gpu.status = gpu.features.has("timestamp-query") ? "available" : "unavailable";
+      }
+      app.setPresenter(presentOn(state));
       const shaders = options.shaders ?? new ShaderLibrary();
       if (!options.shaders) registerEngineShaders(shaders);
       if (options.shaderBake) shaders.preload(options.shaderBake);
       app.insertResource(Shaders, shaders);
-      if (gpu.context) app.insertResource(Window, new WindowTarget(gpu));
-      else if (options.target) app.insertResource(Window, options.target);
+      const surface = options.surface ?? (options.canvas ? gpu.surfaces.find((s) => s.canvas === options.canvas) ?? gpu.addSurface(options.canvas, { alpha: options.alpha }) : void 0);
+      state.surface = surface;
+      if (surface) {
+        app.insertResource(Window, surface);
+        state.unsubscribe.push(surface.onResize(() => app.disposed || app.requestFrame()));
+      } else if (options.target) app.insertResource(Window, options.target);
       const log = app.world.tryResource(LogResource);
-      if (log) gpu.onError((error) => log.error(error));
-      gpu.onDeviceLost((info) => {
-        app.world.send(GpuDeviceLost, info);
-        void gpu.recreate();
-      });
+      if (log) state.unsubscribe.push(gpu.onError((error) => log.error(error)));
+      state.unsubscribe.push(
+        gpu.onDeviceLost((info) => {
+          app.world.send(GpuDeviceLost, info);
+          gpu.recreate().then(
+            () => app.disposed || app.requestFrame(),
+            () => app.disposed || app.requestFrame()
+          );
+        })
+      );
+    },
+    beforeDispose(app) {
+      const gpu = renderApps.get(app)?.gpu;
+      if (gpu?.status === "ok") return gpu.device.queue.onSubmittedWorkDone();
+    },
+    dispose(app) {
+      const state = renderApps.get(app);
+      if (!state) return;
+      renderApps.delete(app);
+      for (const off of state.unsubscribe.splice(0)) off();
+      app.world.tryResource(Graph)?.dispose();
+      state.surface?.remove();
+      const gpu = state.gpu;
+      if (!gpu) return;
+      releaseDataStores(gpu, state.owner);
+      gpu.release(state.owner);
+      if (state.ownsDevice) gpu.destroy();
     }
   });
 }
+function renderOwner(world) {
+  return world.resource(RenderOptions).owner;
+}
 function captureView(world, view = WINDOW_VIEW) {
-  return world.resource(Graph).capture(view);
+  const shot = world.resource(Graph).capture(view);
+  world.wake();
+  return shot;
 }
 async function captureBuffer(world, view, buffer) {
   const graph = world.resource(Graph);
-  const result = await graph.capture(view, buffer);
+  const pending = graph.capture(view, buffer);
+  world.wake();
+  const result = await pending;
   if (!("format" in result)) {
     const data = new Float32Array(result.data.length);
     for (let i = 0; i < data.length; i++) data[i] = result.data[i] / 255;
@@ -136,6 +297,20 @@ async function captureBuffer(world, view, buffer) {
   }
   return result;
 }
+function adapterIdentity(world) {
+  const info = world.tryResource(Gpu)?.adapter?.info;
+  if (!info) return void 0;
+  return {
+    vendor: info.vendor,
+    architecture: info.architecture,
+    device: info.device,
+    description: info.description
+  };
+}
+function gpuMemory(world) {
+  const memory = world.tryResource(Gpu)?.memory();
+  return memory ? { bytes: memory.bytes, byCategory: { ...memory.byCategory } } : { bytes: 0, byCategory: {} };
+}
 function describeRender(world) {
   const graph = world.tryResource(Graph);
   const gpu = world.tryResource(Gpu);
@@ -158,8 +333,29 @@ function describeRender(world) {
     gpuTimings: gpu.features.has("timestamp-query"),
     stats: Object.fromEntries(world.tryResource(RenderStats) ?? []),
     counters: { ...world.tryResource(RenderCounters) ?? { taaResets: 0, originShifts: 0 } },
-    memory: world.tryResource(GpuMemory) ?? { textures: 0, textureBytes: 0 },
-    recentErrors: gpu.errors.slice(-5).map((e) => e.toJSON())
+    // The ledger's total, so it agrees with perf.describe and perf records; and the textures the
+    // forward renderer uploaded, as before.
+    memory: {
+      ...gpuMemory(world),
+      ...world.tryResource(GpuMemory) ?? { textures: 0, textureBytes: 0 }
+    },
+    recentErrors: gpu.errors.slice(-5).map((e) => e.toJSON()),
+    features: describeFeatures(world),
+    health: world.tryResource(RenderHealth) ?? { state: "ok", issues: [] },
+    // The API and tier the device runs (0064), what it can do, and why a better option was skipped.
+    backend: gpu.backend,
+    tier: gpu.tier,
+    capabilities: gpu.capabilities,
+    // WebGL2: where shader translations came from, and what naga translated this session.
+    shaderCache: gpu.shaderCache(),
+    limits: {
+      maxTextureDimension2D: gpu.device.limits.maxTextureDimension2D,
+      maxColorAttachments: gpu.device.limits.maxColorAttachments,
+      maxSampledTexturesPerShaderStage: gpu.device.limits.maxSampledTexturesPerShaderStage,
+      maxInterStageShaderVariables: gpu.device.limits.maxInterStageShaderVariables,
+      maxUniformBufferBindingSize: gpu.device.limits.maxUniformBufferBindingSize
+    },
+    reasons: gpu.reasons
   };
   const sections = {};
   for (const [name, fn] of world.tryResource(RenderDescribers) ?? []) sections[name] = fn(world);
@@ -178,5 +374,7 @@ export {
   captureBuffer,
   captureView,
   describeRender,
+  gpuMemory,
+  renderOwner,
   renderPlugin
 };

package/dist/post-common.d.ts

@@ -1,6 +1,6 @@
 import { GpuBuffer, type GpuContext } from '@aethervtt/shard-gpu';
 import { type ViewGpu } from './forward.js';
-import type { NodeContext } from './graph.js';
+import type { NodeContext, RenderView } from './graph.js';
 import { type CameraData } from './view.js';
 export declare function idOf(o: object): number;
 export declare const F: () => number;
@@ -11,6 +11,8 @@ export declare const tex: (binding: number, sampleType?: GPUTextureSampleType) =
         sampleType: GPUTextureSampleType;
     };
 };
+/** Depth read without comparison, in the fragment stage (a float texture on baseline, 0064). */
+export declare const depthTex: (gpu: GpuContext, binding: number) => GPUBindGroupLayoutEntry;
 export declare const uniform: (binding: number, visibility?: number) => {
     binding: number;
     visibility: number;
@@ -35,7 +37,7 @@ export declare class PostCache {
     check(gpu: GpuContext): void;
     /** A fullscreen render pipeline: `shard::fullscreen` vertex stage and `root`'s `entry`. */
     render(ctx: NodeContext, key: string, root: string, entry: string, layouts: GPUBindGroupLayout[], targets: GPUColorTargetState[], defines?: Record<string, boolean>): GPURenderPipeline | undefined;
-    compute(ctx: NodeContext, key: string, root: string, entry: string, layouts: GPUBindGroupLayout[]): GPUComputePipeline | undefined;
+    compute(ctx: NodeContext, key: string, root: string, entry: string, layouts: GPUBindGroupLayout[], defines?: Record<string, boolean>): GPUComputePipeline | undefined;
     /** A bind group, rebuilt when `key` (the ids of what it binds) changes. */
     group(gpu: GpuContext, slot: string, key: string, layout: GPUBindGroupLayout, entries: () => GPUBindGroupEntry[]): GPUBindGroup;
     buffer(gpu: GpuContext, name: string, size: number): GpuBuffer;
@@ -48,4 +50,22 @@ export declare function forwardView(ctx: NodeContext): {
 /** A fullscreen pass the node begins itself (raw nodes with several passes). */
 export declare function beginPass(ctx: NodeContext, name: string, view: GPUTextureView, load?: boolean): GPURenderPassEncoder;
 export declare const HDR: GPUColorTargetState[];
+/** Color targets for a post pass that writes `texture`: the chain's format, per view. */
+export declare function targetsFor(texture: GPUTexture): GPUColorTargetState[];
+/**
+ * The format of the post chain's full-resolution ping-pong (post-a, post-b) for a view:
+ * rg11b10ufloat, half the bytes of rgba16float, where the device renders it, the view has no alpha
+ * to carry (0052's transparent views), and the device's rounding is known (`rg11Truncates`);
+ * rgba16float otherwise, and until then.
+ */
+export declare function postFormat(gpu: GpuContext, view: RenderView): GPUTextureFormat;
+/** Whether a pass writing `texture` rounds its output in the shader (the RG11_ROUND define). */
+export declare function roundsRg11(gpu: GpuContext, texture: GPUTexture): boolean;
+/**
+ * Whether the device truncates when it stores rg11b10ufloat (Metal does; the format leaves the
+ * rounding to the device). Post passes writing it then round in the shader (`rg11_round`, the
+ * RG11_ROUND define). Probed once per device, rendering 1 + 0.75 of a step and reading it back;
+ * undefined until the answer lands.
+ */
+export declare function rg11Truncates(gpu: GpuContext): boolean | undefined;
 export declare const scratch: Float32Array<ArrayBuffer>;

package/dist/post-common.js

@@ -1,6 +1,7 @@
 import { GpuBuffer } from "@aethervtt/shard-gpu";
 import { ForwardStateResource } from "./forward.js";
 import { Shaders } from "./plugin.js";
+import { depthReadEntry } from "./tier.js";
 import { cameraOf } from "./view.js";
 const textureIds = /* @__PURE__ */ new WeakMap();
 let nextId = 1;
@@ -18,6 +19,7 @@ const tex = (binding, sampleType = "float") => ({
   visibility: F(),
   texture: { sampleType }
 });
+const depthTex = (gpu, binding) => depthReadEntry(gpu, binding, F());
 const uniform = (binding, visibility = F()) => ({
   binding,
   visibility,
@@ -64,12 +66,12 @@ class PostCache {
     if (pipeline) this.pipelines.set(key, pipeline);
     return pipeline;
   }
-  compute(ctx, key, root, entry, layouts) {
+  compute(ctx, key, root, entry, layouts, defines) {
     const gpu = ctx.gpu;
     this.check(gpu);
     const cached = this.pipelines.get(key);
     if (cached) return cached;
-    const module = ctx.world.resource(Shaders).module(gpu, { root });
+    const module = ctx.world.resource(Shaders).module(gpu, defines ? { root, defines } : { root });
     if (!module) {
       gpu.pipelines.skipped++;
       return void 0;
@@ -133,16 +135,94 @@ function beginPass(ctx, name, view, load = false) {
   });
 }
 const HDR = [{ format: "rgba16float" }];
+const RG11 = [{ format: "rg11b10ufloat" }];
+function targetsFor(texture) {
+  return texture.format === "rg11b10ufloat" ? RG11 : HDR;
+}
+function postFormat(gpu, view) {
+  const cam = cameraOf(view);
+  if (!gpu.features.has("rg11b10ufloat-renderable") || cam === void 0 || cam.alphaOutput)
+    return "rgba16float";
+  return rg11Truncates(gpu) === void 0 ? "rgba16float" : "rg11b10ufloat";
+}
+function roundsRg11(gpu, texture) {
+  return texture.format === "rg11b10ufloat" && rg11Truncates(gpu) === true;
+}
+const truncates = /* @__PURE__ */ new WeakMap();
+function rg11Truncates(gpu) {
+  const device = gpu.device;
+  const known = truncates.get(device);
+  if (known === "probing") return void 0;
+  if (known !== void 0) return known;
+  truncates.set(device, "probing");
+  probeRg11(device).then(
+    (v) => truncates.set(device, v),
+    // A lost device or a failed map: assume truncation, the safe side (rounding then is exact).
+    () => truncates.set(device, true)
+  );
+  return void 0;
+}
+async function probeRg11(device) {
+  const texture = device.createTexture({
+    label: "post/rg11-probe",
+    size: [1, 1],
+    format: "rg11b10ufloat",
+    usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC
+  });
+  const buffer = device.createBuffer({
+    label: "post/rg11-probe",
+    size: 4,
+    usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+  });
+  const module = device.createShaderModule({
+    label: "post/rg11-probe",
+    code: `
+@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f {
+  let xy = vec2f(f32((i << 1u) & 2u), f32(i & 2u));
+  return vec4f(xy * 2.0 - 1.0, 0.0, 1.0);
+}
+@fragment fn fs() -> @location(0) vec4f { return vec4f(1.0 + 0.75 / 64.0, 0.0, 0.0, 1.0); }`
+  });
+  const pipeline = await device.createRenderPipelineAsync({
+    label: "post/rg11-probe",
+    layout: "auto",
+    vertex: { module, entryPoint: "vs" },
+    fragment: { module, entryPoint: "fs", targets: [{ format: "rg11b10ufloat" }] }
+  });
+  const encoder = device.createCommandEncoder({ label: "post/rg11-probe" });
+  const pass = encoder.beginRenderPass({
+    colorAttachments: [{ view: texture.createView(), loadOp: "clear", storeOp: "store" }]
+  });
+  pass.setPipeline(pipeline);
+  pass.draw(3);
+  pass.end();
+  encoder.copyTextureToBuffer({ texture }, { buffer, bytesPerRow: 256 }, [1, 1]);
+  device.queue.submit([encoder.finish()]);
+  try {
+    await buffer.mapAsync(GPUMapMode.READ);
+    const red = new Uint32Array(buffer.getMappedRange())[0] & 2047;
+    buffer.unmap();
+    return red === 15 << 6;
+  } finally {
+    texture.destroy();
+    buffer.destroy();
+  }
+}
 const scratch = new Float32Array(64);
 export {
   F,
   HDR,
   PostCache,
   beginPass,
+  depthTex,
   forwardView,
   idOf,
+  postFormat,
+  rg11Truncates,
+  roundsRg11,
   sampler,
   scratch,
+  targetsFor,
   tex,
   uniform
 };

package/dist/post-nodes.d.ts

@@ -2,6 +2,11 @@ import { type World } from '@aethervtt/shard-core';
 import { type CameraData } from './view.js';
 /** Mip levels of a view's bloom chain: `radius` spreads it from 3 levels to the whole view. */
 export declare function bloomLevels(cam: CameraData): number;
+/**
+ * Bloom's glow parameters for what composites it (the tonemap) and what meters it: intensity, the
+ * chain's level count (one mip per level), mix (1, no threshold) or add (0). Zeros without bloom.
+ */
+export declare function bloomGlow(cam: CameraData, chain: GPUTexture | undefined, out: Float32Array, at: number): void;
 /** Metered EV100 per camera (from the GPU histogram, a frame or two late) and the adapted EV. */
 export interface ExposureState {
     metered: number | undefined;
@@ -32,7 +37,8 @@ export declare const adaptExposure: import("@aethervtt/shard-core").SystemDef<{
 /** Graph node names of the post chain, in order (for describe and tests). */
 export declare const POST_NODES: readonly [readonly ['post/fog', 1], readonly ['post/taa', 2], readonly ['post/motion-blur', 4], readonly ['post/dof', 8], readonly ['post/bloom', 16], readonly ['post/exposure', 32], readonly ['post/fxaa', 64]];
 /** Adds the prepass, SSAO, and the post chain to the graph. */
-export declare function addPostNodes(world: World): void;
+/** The post chain's nodes. `baseline`: the baseline tier's exposure meter (0064), when on one. */
+export declare function addPostNodes(world: World, baseline?: typeof import('./baseline/exposure.js')): void;
 /** The post section of `render.describe`: per view, active effects in order with GPU time. */
 export declare function describePost(world: World): {
     views: Record<string, unknown>;