@aethervtt/shard-render 0.0.1

package/dist/material-pipelines.d.ts

@@ -0,0 +1,46 @@
+import { type World } from '@aethervtt/shard-core';
+import type { GpuContext } from '@aethervtt/shard-gpu';
+import type { ShaderLibrary } from '@aethervtt/shard-shader';
+import type { MaterialAsset } from './assets.js';
+import { type BlendMode, type MaterialType } from './materials.js';
+/** A small stable number per material type, for sorting and pipeline keys. */
+export declare function typeOrdinal(type: MaterialType): number;
+/** What distinguishes a pipeline within a pass: blend mode and culling. */
+export declare function materialVariant(material: MaterialAsset): number;
+export declare function variantBlend(variant: number): BlendMode;
+export declare function variantCull(variant: number): GPUCullMode;
+/** Color blend state for a blend mode (HDR target). */
+export declare function blendState(blend: BlendMode): GPUBlendState | undefined;
+/**
+ * Makes sure a type's generated module is in the library at its current version, with `noise` (its
+ * noise slots' wrappers and their key) when it has any.
+ */
+export declare function registerMaterialModule(library: ShaderLibrary, type: MaterialType, noise?: {
+    source: string;
+    key: string;
+}): void;
+/**
+ * Shader modules and pipelines per material type, looked up per draw without allocating: modules
+ * resolve once per (type, root, defines) per frame, pipelines are cached under a numeric key.
+ */
+export declare class MaterialPipelines {
+    private frame;
+    private readonly modules;
+    private readonly pipelines;
+    beginFrame(frame: number): void;
+    /**
+     * The module for a type linked from `root` with its shader's overrides. `slot` distinguishes
+     * roots and define sets (a small integer chosen by the caller).
+     */
+    module(world: World, gpu: GpuContext, type: MaterialType, slot: number, root: string, defines: Readonly<Record<string, boolean>> | undefined): GPUShaderModule | undefined;
+    /** A compiled pipeline under `key` (unique per pass, type, and variant), if there is one. */
+    cached(key: number): GPURenderPipeline | undefined;
+    /** The last pipeline that compiled under each key, with the layout it was made for. */
+    private readonly previous;
+    /**
+     * Asks the cache for a pipeline on a miss; compiled ones are kept for the rest of the frame.
+     * While a replacement compiles (an edited shader or noise graph), draws keep the previous one
+     * for the key if its layout is the same object (the bind groups still fit), instead of vanishing.
+     */
+    create(gpu: GpuContext, key: number, descriptor: GPURenderPipelineDescriptor): GPURenderPipeline | undefined;
+}

package/dist/material-pipelines.js

@@ -0,0 +1,166 @@
+import { assetServer } from "@aethervtt/shard-assets";
+import { ShardError } from "@aethervtt/shard-core";
+import { LogResource } from "@aethervtt/shard-runtime";
+import { MaterialNoise } from "./material-noise.js";
+import { allMaterialTypes, BLEND_MODES } from "./materials.js";
+import { Shaders } from "./plugin.js";
+const ordinals = /* @__PURE__ */ new WeakMap();
+let nextOrdinal = 0;
+function typeOrdinal(type) {
+  let n = ordinals.get(type);
+  if (n === void 0) {
+    n = nextOrdinal++;
+    ordinals.set(type, n);
+  }
+  return n;
+}
+function materialVariant(material) {
+  const blend = material.type.blendOf(material.value);
+  const cull = material.value.doubleSided ? 1 : 0;
+  return BLEND_MODES.indexOf(blend) * 2 + cull;
+}
+function variantBlend(variant) {
+  return BLEND_MODES[variant >> 1];
+}
+function variantCull(variant) {
+  return variant & 1 ? "none" : "back";
+}
+function blendState(blend) {
+  switch (blend) {
+    case "alpha":
+      return {
+        color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha" },
+        alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" }
+      };
+    case "premultiplied":
+      return {
+        color: { srcFactor: "one", dstFactor: "one-minus-src-alpha" },
+        alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" }
+      };
+    case "additive":
+      return {
+        color: { srcFactor: "src-alpha", dstFactor: "one" },
+        alpha: { srcFactor: "zero", dstFactor: "one" }
+      };
+    default:
+      return void 0;
+  }
+}
+const registered = /* @__PURE__ */ new WeakMap();
+function registerMaterialModule(library, type, noise) {
+  let list = registered.get(type);
+  if (!list) {
+    list = [];
+    registered.set(type, list);
+  }
+  const entry = list.find((r) => r.library === library);
+  const key = noise?.key ?? "";
+  if (entry && entry.version === type.version && entry.noise === key) return;
+  library.register(type.modulePath, type.moduleSource(noise?.source), `material:${type.name}`);
+  if (entry) {
+    entry.version = type.version;
+    entry.noise = key;
+  } else list.push({ version: type.version, noise: key, library });
+}
+const watching = /* @__PURE__ */ new WeakSet();
+function watchNoiseGraphs(world, library) {
+  if (watching.has(world)) return;
+  watching.add(world);
+  assetServer(world).onEvent((event) => {
+    if (event.kind !== "modified" && event.kind !== "loaded") return;
+    const support = world.tryResource(MaterialNoise);
+    if (!support) return;
+    for (const type of allMaterialTypes()) {
+      if (!type.noise.some((slot) => slot.path === event.path)) continue;
+      const noise = support.wrappers(world, library, type);
+      if (noise) registerMaterialModule(library, type, noise);
+    }
+  });
+}
+const missingNoise = /* @__PURE__ */ new WeakSet();
+class MaterialPipelines {
+  frame = -1;
+  modules = /* @__PURE__ */ new Map();
+  pipelines = /* @__PURE__ */ new Map();
+  beginFrame(frame) {
+    if (frame === this.frame) return;
+    this.frame = frame;
+    this.modules.clear();
+    this.pipelines.clear();
+  }
+  /**
+   * The module for a type linked from `root` with its shader's overrides. `slot` distinguishes
+   * roots and define sets (a small integer chosen by the caller).
+   */
+  module(world, gpu, type, slot, root, defines) {
+    const key = typeOrdinal(type) * 64 + slot;
+    if (this.modules.has(key)) return this.modules.get(key);
+    const library = world.resource(Shaders);
+    let noise;
+    if (type.noise.length > 0) {
+      const support = world.tryResource(MaterialNoise);
+      if (!support) {
+        if (!missingNoise.has(type)) {
+          missingNoise.add(type);
+          world.tryResource(LogResource)?.error(
+            new ShardError(
+              "render/feature-missing",
+              `Material ${type.name} has noise slots, but materialNoisePlugin isn't installed`,
+              { hint: "Add materialNoisePlugin from '@aethervtt/shard-render/noise'." }
+            )
+          );
+        }
+        this.modules.set(key, void 0);
+        return void 0;
+      }
+      watchNoiseGraphs(world, library);
+      noise = support.wrappers(world, library, type);
+      if (!noise) {
+        this.modules.set(key, void 0);
+        return void 0;
+      }
+    }
+    registerMaterialModule(library, type, noise);
+    const module = library.module(gpu, {
+      root,
+      defines,
+      overrides: type.shader ? [type.shader] : void 0,
+      label: type.name === "render/StandardMaterial" ? void 0 : `material ${type.name}`
+    });
+    this.modules.set(key, module);
+    return module;
+  }
+  /** A compiled pipeline under `key` (unique per pass, type, and variant), if there is one. */
+  cached(key) {
+    return this.pipelines.get(key);
+  }
+  /** The last pipeline that compiled under each key, with the layout it was made for. */
+  previous = /* @__PURE__ */ new Map();
+  /**
+   * Asks the cache for a pipeline on a miss; compiled ones are kept for the rest of the frame.
+   * While a replacement compiles (an edited shader or noise graph), draws keep the previous one
+   * for the key if its layout is the same object (the bind groups still fit), instead of vanishing.
+   */
+  create(gpu, key, descriptor) {
+    const pipeline = gpu.pipelines.render(descriptor);
+    if (pipeline) {
+      this.pipelines.set(key, pipeline);
+      this.previous.set(key, { pipeline, layout: descriptor.layout, generation: gpu.generation });
+      return pipeline;
+    }
+    const last = this.previous.get(key);
+    if (last && last.layout === descriptor.layout && last.generation === gpu.generation) {
+      return last.pipeline;
+    }
+    return void 0;
+  }
+}
+export {
+  MaterialPipelines,
+  blendState,
+  materialVariant,
+  registerMaterialModule,
+  typeOrdinal,
+  variantBlend,
+  variantCull
+};

package/dist/materials.d.ts

@@ -0,0 +1,108 @@
+import { type AnyField, type ComponentDef, type Fields } from '@aethervtt/shard-core';
+import type { GpuContext } from '@aethervtt/shard-gpu';
+import { type WgslLayout } from '@aethervtt/shard-shader';
+export declare const BLEND_MODES: readonly ['opaque', 'mask', 'alpha', 'additive', 'premultiplied'];
+export type BlendMode = (typeof BLEND_MODES)[number];
+/** Blend modes drawn after opaque geometry, sorted back to front, without depth writes. */
+export declare const isTransparent: (blend: BlendMode) => blend is "additive" | "alpha" | "premultiplied";
+export interface MaterialTypeOptions<F extends Fields> {
+    /**
+     * 'standard' keeps every StandardMaterial field and its lighting; hooks change the surface.
+     * 'none' starts from nothing: a `shade` hook computes the final color, and it renders forward.
+     */
+    extends?: 'standard' | 'none';
+    /** The type's own parameters. Texture handles (`t.handle('Texture')`) become bindings. */
+    fields?: F;
+    /** Fixed blend mode. Omitted, standard extensions follow the material's `alphaMode`. */
+    blend?: BlendMode;
+    /** The shader module with the hook overrides, e.g. `project::lava` (`shaders/lava.wesl`). */
+    shader?: string;
+    /**
+     * Noise graphs the shader calls, by name: `{ detail: 'assets/noise/rock.noise.json' }` makes
+     * `noise_detail(p: vec3f, seed: u32) -> f32` available in `material::<name>`. The graph is
+     * code, so it's chosen per type; editing the file relinks the material.
+     */
+    noise?: Readonly<Record<string, string>>;
+    /**
+     * Texture fields bound as `texture_2d_array<f32>` (a `*.texarray.json`, or any texture as one
+     * layer). Arrays of color textures sample through the sRGB view.
+     */
+    arrays?: readonly string[];
+    /**
+     * Standard extensions only: false leaves the standard material's five texture slots (and their
+     * samplers) out of the layout, for types that build their own surface and need the room (a stage
+     * holds 16 sampled textures). Its shader must then not call `standard_input`.
+     */
+    standardTextures?: boolean;
+    description?: string;
+}
+/** A material type's noise slot: `noise_<name>` calls the graph at `path`. */
+export interface MaterialNoiseSlot {
+    readonly name: string;
+    readonly path: string;
+}
+/** A PascalName's shader module path: `my-game/Lava` → `material::lava`. */
+export declare function materialModulePath(name: string): string;
+/**
+ * A material type: a schema (validation, JSON Schema, inspector data) and, from it, a generated
+ * WGSL module with the uniform struct and texture bindings. Its shader overrides hooks.
+ */
+export declare class MaterialType {
+    readonly name: string;
+    extends: 'standard' | 'none';
+    /** Binds the standard texture slots (standard extensions; see MaterialTypeOptions). */
+    standardTextures: boolean;
+    /** Every field of the material asset (standard fields too, for standard extensions). */
+    schema: ComponentDef;
+    /** The type's own numeric fields, packed into its uniform. Undefined if it has none. */
+    layout: WgslLayout<Fields> | undefined;
+    /** The type's own texture fields, in binding order. */
+    textures: string[];
+    /** Texture fields bound as 2D arrays. */
+    arrays: Set<string>;
+    blend: BlendMode | undefined;
+    shader: string | undefined;
+    /** Noise graphs the module wraps as `noise_<name>`. */
+    noise: MaterialNoiseSlot[];
+    description: string;
+    /** Increments on every redefinition, so GPU state and pipelines rebuild. */
+    version: number;
+    readonly modulePath: string;
+    /** WGSL identifier of the uniform (the PascalName). */
+    readonly varName: string;
+    private layouts;
+    constructor(name: string, options: MaterialTypeOptions<Fields>, schema: ComponentDef);
+    /** (Re)applies a definition: redefinitions keep the object, so assets keep pointing at it. */
+    assign(options: MaterialTypeOptions<Fields>, schema: ComponentDef): void;
+    get standard(): boolean;
+    /** First group-1 binding of the type's own data. */
+    get bindingBase(): number;
+    /** The blend mode for a material of this type. */
+    blendOf(value: {
+        alphaMode?: string;
+    }): BlendMode;
+    /** Deferred shading only takes standard lighting, and never transparency. */
+    deferrable(value: {
+        alphaMode?: string;
+    }): boolean;
+    /**
+     * The generated `material::<name>` module: uniform struct and bindings, then `noise` (the noise
+     * slots' wrappers, once their graphs load).
+     */
+    moduleSource(noise?: string): string;
+    /** The group-1 bind group layout: standard bindings (if extended), own uniform, own textures. */
+    bindGroupLayout(gpu: GpuContext, standard: GPUBindGroupLayoutEntry[]): GPUBindGroupLayout;
+}
+/**
+ * Declares a material type. Engine types use their package namespace; project code uses
+ * `project.material(name, ...)`, which namespaces it. Defining an existing name again (hot reload)
+ * updates the type in place: existing assets revalidate and gain new fields' defaults.
+ */
+export declare function defineMaterial<const F extends Fields>(name: string, options: MaterialTypeOptions<F>, standardFields?: Fields): MaterialType;
+export declare function findMaterialType(name: string): MaterialType | undefined;
+export declare function allMaterialTypes(): MaterialType[];
+/** Called with a type whenever it's redefined. Returns an unsubscribe function. */
+export declare function onMaterialTypeChange(fn: (type: MaterialType) => void): () => void;
+/** Registers a type as the standard one (it keeps `render/StandardMaterial`'s schema). */
+export declare function registerStandardType(schema: ComponentDef): MaterialType;
+export type { AnyField };

package/dist/materials.js

@@ -0,0 +1,219 @@
+import {
+  defineComponent,
+  defineSchema,
+  ShardError
+} from "@aethervtt/shard-core";
+import { wgslLayout } from "@aethervtt/shard-shader";
+import { STANDARD_FIELDS } from "./standard-fields.js";
+const BLEND_MODES = ["opaque", "mask", "alpha", "additive", "premultiplied"];
+const isTransparent = (blend) => blend === "alpha" || blend === "additive" || blend === "premultiplied";
+const STANDARD_BINDINGS = 12;
+function isTextureHandle(field) {
+  if (field.kind !== "handle") return false;
+  const schema = field.jsonSchema();
+  return schema.anyOf?.some((s) => s["x-asset-type"] === "Texture") ?? false;
+}
+function materialModulePath(name) {
+  const pascal = name.slice(name.indexOf("/") + 1);
+  return `material::${pascal.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase()}`;
+}
+class MaterialType {
+  name;
+  extends;
+  /** Binds the standard texture slots (standard extensions; see MaterialTypeOptions). */
+  standardTextures = true;
+  /** Every field of the material asset (standard fields too, for standard extensions). */
+  schema;
+  /** The type's own numeric fields, packed into its uniform. Undefined if it has none. */
+  layout;
+  /** The type's own texture fields, in binding order. */
+  textures;
+  /** Texture fields bound as 2D arrays. */
+  arrays;
+  blend;
+  shader;
+  /** Noise graphs the module wraps as `noise_<name>`. */
+  noise;
+  description;
+  /** Increments on every redefinition, so GPU state and pipelines rebuild. */
+  version = 0;
+  modulePath;
+  /** WGSL identifier of the uniform (the PascalName). */
+  varName;
+  layouts = /* @__PURE__ */ new WeakMap();
+  constructor(name, options, schema) {
+    this.name = name;
+    this.modulePath = materialModulePath(name);
+    this.varName = name.slice(name.indexOf("/") + 1);
+    this.extends = options.extends ?? "standard";
+    this.schema = schema;
+    this.layout = void 0;
+    this.textures = [];
+    this.arrays = /* @__PURE__ */ new Set();
+    this.blend = options.blend;
+    this.shader = options.shader;
+    this.noise = [];
+    this.description = options.description ?? "";
+    this.assign(options, schema);
+  }
+  /** (Re)applies a definition: redefinitions keep the object, so assets keep pointing at it. */
+  assign(options, schema) {
+    const fields = options.fields ?? {};
+    const numeric = {};
+    const textures = [];
+    for (const [key, field] of Object.entries(fields)) {
+      if (isTextureHandle(field)) textures.push(key);
+      else if (field.storage !== "object") numeric[key] = field;
+    }
+    this.extends = options.extends ?? "standard";
+    this.standardTextures = options.standardTextures ?? true;
+    this.schema = schema;
+    this.textures = textures;
+    this.arrays = new Set(options.arrays ?? []);
+    this.blend = options.blend;
+    this.shader = options.shader;
+    this.noise = Object.entries(options.noise ?? {}).map(([name, path]) => {
+      if (!/^[a-z_][a-z0-9_]*$/.test(name)) {
+        throw new ShardError(
+          "render/material-noise-name",
+          `Noise slot "${name}" of ${this.name} isn't a WGSL name`,
+          {
+            hint: 'Use lowercase letters, digits, and underscores: { detail: "assets/noise/rock.noise.json" }.'
+          }
+        );
+      }
+      return { name, path };
+    });
+    this.description = options.description ?? "";
+    this.layout = Object.keys(numeric).length > 0 ? wgslLayout(defineSchema(`${this.name}Params`, numeric)) : void 0;
+    this.version++;
+    this.layouts = /* @__PURE__ */ new WeakMap();
+  }
+  get standard() {
+    return this.extends === "standard";
+  }
+  /** First group-1 binding of the type's own data. */
+  get bindingBase() {
+    return this.standard ? STANDARD_BINDINGS : 0;
+  }
+  /** The blend mode for a material of this type. */
+  blendOf(value) {
+    if (this.blend) return this.blend;
+    const mode = value.alphaMode;
+    return mode === "mask" || mode === "alpha" || mode === "premultiplied" || mode === "additive" ? mode : "opaque";
+  }
+  /** Deferred shading only takes standard lighting, and never transparency. */
+  deferrable(value) {
+    return this.standard && !isTransparent(this.blendOf(value));
+  }
+  /**
+   * The generated `material::<name>` module: uniform struct and bindings, then `noise` (the noise
+   * slots' wrappers, once their graphs load).
+   */
+  moduleSource(noise = "") {
+    const lines = [];
+    let binding = this.bindingBase;
+    if (this.layout) {
+      lines.push(this.layout.wgsl);
+      lines.push(
+        `@group(1) @binding(${binding++}) var<uniform> ${this.varName}: ${this.layout.structName};`
+      );
+    } else {
+      binding++;
+    }
+    for (const tex of this.textures) {
+      const kind = this.arrays.has(tex) ? "texture_2d_array<f32>" : "texture_2d<f32>";
+      lines.push(`@group(1) @binding(${binding++}) var ${this.varName}_${tex}: ${kind};`);
+      lines.push(`@group(1) @binding(${binding++}) var ${this.varName}_${tex}_sampler: sampler;`);
+    }
+    if (!this.layout && this.textures.length === 0) {
+      lines.push(`const ${this.varName}_fields: u32 = 0u;`);
+    }
+    if (noise) lines.push(noise);
+    return `// Generated from the ${this.name} schema. Don't edit: change the material definition.
+${lines.join("\n")}
+`;
+  }
+  /** The group-1 bind group layout: standard bindings (if extended), own uniform, own textures. */
+  bindGroupLayout(gpu, standard) {
+    const cached = this.layouts.get(gpu);
+    if (cached && cached.generation === gpu.generation) return cached.layout;
+    const visibility = GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT;
+    const entries = !this.standard ? [] : this.standardTextures ? [...standard] : standard.filter((e) => e.binding < 2);
+    let binding = this.bindingBase;
+    if (this.layout) entries.push({ binding, visibility, buffer: { type: "uniform" } });
+    binding++;
+    for (const tex of this.textures) {
+      entries.push({
+        binding: binding++,
+        visibility,
+        texture: {
+          sampleType: "float",
+          viewDimension: this.arrays.has(tex) ? "2d-array" : "2d"
+        }
+      });
+      entries.push({ binding: binding++, visibility, sampler: { type: "filtering" } });
+    }
+    const layout = gpu.layouts.bindGroupLayout({ label: `material/${this.name}`, entries });
+    this.layouts.set(gpu, { generation: gpu.generation, layout });
+    return layout;
+  }
+}
+const types = /* @__PURE__ */ new Map();
+const listeners = /* @__PURE__ */ new Set();
+function defineMaterial(name, options, standardFields) {
+  const ext = options.extends ?? "standard";
+  const standard = standardFields ?? STANDARD_FIELDS;
+  for (const key of Object.keys(options.fields ?? {})) {
+    if (ext === "standard" && standard[key]) {
+      throw new ShardError(
+        "render/material-field-clash",
+        `Material ${name} redefines the standard field "${key}"`,
+        { hint: 'Give the field another name, or use extends: "none".' }
+      );
+    }
+  }
+  const fields = {
+    ...ext === "standard" ? standard : {},
+    ...options.fields ?? {}
+  };
+  const existing = types.get(name);
+  const schema = defineComponent(name, fields, {
+    description: options.description ?? `Material type ${name}${ext === "standard" ? " (extends the standard material)" : ""}.`,
+    serialize: true
+  });
+  if (existing) {
+    existing.assign(options, schema);
+    for (const listener of listeners) listener(existing);
+    return existing;
+  }
+  const type = new MaterialType(name, options, schema);
+  types.set(name, type);
+  return type;
+}
+function findMaterialType(name) {
+  return types.get(name);
+}
+function allMaterialTypes() {
+  return [...types.values()];
+}
+function onMaterialTypeChange(fn) {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+function registerStandardType(schema) {
+  const type = new MaterialType("render/StandardMaterial", { extends: "standard" }, schema);
+  types.set(type.name, type);
+  return type;
+}
+export {
+  BLEND_MODES,
+  MaterialType,
+  allMaterialTypes,
+  defineMaterial,
+  findMaterialType,
+  isTransparent,
+  materialModulePath,
+  onMaterialTypeChange,
+  registerStandardType
+};

package/dist/noise.d.ts

@@ -0,0 +1,76 @@
+import { type World } from '@aethervtt/shard-core';
+import { type GpuContext } from '@aethervtt/shard-gpu';
+import { type GridParams, type NoiseGraph, type SpherePatch } from '@aethervtt/shard-noise';
+import type { ShaderLibrary } from '@aethervtt/shard-shader';
+import type { NodeDescriptor } from './graph.js';
+import type { MaterialType } from './materials.js';
+/**
+ * The WGSL a material type's noise slots add to its module: `noise_<slot>(p, seed)` for each,
+ * calling its graph's function. Registers each graph's module (a changed graph relinks the
+ * material). Undefined while a graph is still loading; this starts the load.
+ */
+export declare function materialNoise(world: World, library: ShaderLibrary, type: MaterialType): {
+    source: string;
+    key: string;
+} | undefined;
+export type NoiseComputeDomain = 'grid2d' | 'sphere-patch';
+export interface NoiseComputeRequest {
+    readonly seed: number;
+    /** The grid (grid2d) or cube-sphere patch (sphere-patch) to fill. */
+    readonly area: GridParams | SpherePatch;
+    /** Receives one f32 per sample, row by row (the same order as `sampleGrid2d` and `sampleSpherePatch`). */
+    readonly out: GPUBuffer;
+}
+/**
+ * Fills a storage buffer with a graph's values over a grid or a cube-sphere patch, on the GPU,
+ * with origin-offset sampling: the CPU computes the origin records in f64 (and, for sphere patches,
+ * the same local points `sampleSpherePatch` uses), so the values match the CPU kernel within its
+ * tolerance at any planet size. 0043 dispatches one per terrain chunk.
+ */
+export declare class NoiseCompute {
+    readonly gpu: GpuContext;
+    readonly domain: NoiseComputeDomain;
+    graph: NoiseGraph;
+    private readonly params;
+    private readonly origins;
+    private readonly points;
+    private readonly scratch;
+    private readonly f32;
+    private readonly u32;
+    private local;
+    private records;
+    private readonly origin64;
+    private bindGroups;
+    constructor(gpu: GpuContext, graph: NoiseGraph, domain: NoiseComputeDomain);
+    /** The root module path of this domain's compute shader for the graph. */
+    get modulePath(): string;
+    /** The compute shader: one invocation per sample, calling `noise_<name>_at`. */
+    shaderSource(): string;
+    private pipeline;
+    /**
+     * Writes this request's parameters and records a dispatch into `pass`. Returns false while the
+     * shader compiles (nothing is recorded).
+     */
+    encode(library: ShaderLibrary, pass: GPUComputePassEncoder, request: NoiseComputeRequest): boolean;
+    private bindGroup;
+    destroy(): void;
+}
+export interface NoiseComputeNodeOptions {
+    readonly graph: NoiseGraph;
+    readonly domain: NoiseComputeDomain;
+    /** What to fill this frame, or undefined for nothing. Called once per frame. */
+    next(): NoiseComputeRequest | undefined;
+    /** Called after the frame's commands are submitted with the request that ran. */
+    done?(request: NoiseComputeRequest): void;
+}
+/**
+ * A render graph node (setup phase, once per frame) that fills a storage buffer from a noise graph
+ * on the GPU whenever `next` returns a request. Add it with `world.resource(Graph).addNode(name, …)`.
+ */
+export declare function noiseComputeNode(options: NoiseComputeNodeOptions): NodeDescriptor;
+/**
+ * Noise slots in materials: `noise: { detail: 'assets/noise/rock.noise.json' }` makes
+ * `noise_detail(p, seed)` callable from the material's shader (spec 0041). Separate from core render
+ * so apps without such materials carry no noise code.
+ */
+export declare const materialNoisePlugin: import("@aethervtt/shard-runtime").Plugin;