@forgeax/engine-render 0.1.19 → 0.1.20

package/src/device/gpu-residency.ts

@@ -60,6 +60,7 @@ import {
   type AssetError,
   countExtraUvSets,
   type DecodedImage,
+  deriveTextureLayout,
   type EquirectAsset,
   type Handle,
   handleSlot,
@@ -72,6 +73,7 @@ import {
   type SamplerAsset,
   type Submesh,
   type TextureAsset,
+  type TextureShape,
   type MeshAsset as TypesMeshAsset,
   toShared,
 } from '@forgeax/engine-types';
@@ -98,7 +100,6 @@ import {
 import type { RhiErrorListenerRegistry } from '../lifecycle';
 import {
   type CubeRenderData,
-  deriveMipUploadLayout,
   deriveRenderDataCubemap,
   deriveRenderDataMesh,
   deriveRenderDataTexture,
@@ -281,10 +282,25 @@ type RegisterCube = (
 // not destroyable on their own; their lifetime is bound to the parent
 // GpuTexture, which the wrapper owns. destroyAll() walks the GpuResource
 // fields and forwards .destroy() to the RHI shim.
-interface TextureGpuEntry {
+export interface TextureResidencyReceipt {
+  readonly shape: TextureShape;
+  readonly format: GPUTextureFormat;
+  readonly extent: {
+    readonly width: number;
+    readonly height: number;
+    readonly depthOrArrayLayers: number;
+  };
+  readonly bytes: number;
+  readonly view: '2d' | '2d-array' | '3d';
+  readonly generation: number;
+  readonly deviceEpoch: number;
+}
+
+export interface TextureGpuEntry {
   readonly texture: GpuTexture;
   /** Opaque RHI view handle; lifetime is bound to the parent texture. */
   readonly view: TextureView;
+  readonly receipt: TextureResidencyReceipt;
 }
 
 // feat-20260630-equirect-kind-internalized-ibl-declarative-skyligh M2 / w11
@@ -388,6 +404,8 @@ export class GpuResidencyCache {
   // Hardware-probe caps injected at `configureGpuDevice`; guards the HDR cubemap
   // path (_uploadCubemapFromEquirect) when `rgba16floatRenderable` is false.
   private caps: RhiCaps | undefined = undefined;
+  private deviceEpoch = 0;
+  private textureGeneration = 0;
 
   private readonly textureGpuHandles: Map<string | number, TextureGpuEntry> = new Map();
   private readonly samplerGpuHandles: Map<string | number, Sampler> = new Map();
@@ -432,6 +450,12 @@ export class GpuResidencyCache {
     registerCube: RegisterCube,
     caps: RhiCaps,
   ): void {
+    for (const entry of this.textureGpuHandles.values()) {
+      if (!entry.texture.isDestroyed) entry.texture.destroy();
+    }
+    if (this.textureGpuHandles.size > 0) this.materialResourceEpoch += 1;
+    this.textureGpuHandles.clear();
+    this.deviceEpoch += 1;
     this.meshResidencyEpoch += 1;
     this.gpuDevice = device;
     this.asyncCreateShaderModule = asyncCreateShaderModule;
@@ -997,7 +1021,7 @@ export class GpuResidencyCache {
     const cacheKey = this.worldKey(handleSlot(handle), worldId);
     if (gpuTexture === undefined) return ok(undefined);
 
-    if (!projected.value.compressed && decoded.mipmap === true && levels > 1) {
+    if (!projected.value.compressed && tex.mips.kind === 'generate' && levels > 1) {
       const factory = this.asyncCreateShaderModule;
       if (factory === undefined) {
         return err(
@@ -1020,8 +1044,8 @@ export class GpuResidencyCache {
       }
       const blitRes = blitMipmapsSync(device, gpuTexture, {
         format: tex.format,
-        width: tex.width,
-        height: tex.height,
+        width: tex.shape.extent.width,
+        height: tex.shape.extent.height,
         levels,
       });
       if (!blitRes.ok) return blitRes as Result<void, RhiError>;
@@ -1029,13 +1053,14 @@ export class GpuResidencyCache {
 
     const viewRes = device.createTextureView(gpuTexture, {
       label: `texture-view-${cacheKey}`,
-      dimension: '2d',
+      dimension: projected.value.shape.viewDimension,
     });
     if (!viewRes.ok) return viewRes;
     const previous = this.textureGpuHandles.get(cacheKey);
-    const next = {
+    const next: TextureGpuEntry = {
       texture: this.wrapTex(gpuTexture),
       view: viewRes.value,
+      receipt: this.textureReceipt(pod, projected.value),
     };
     this.textureGpuHandles.set(cacheKey, next);
     this.materialResourceEpoch += 1;
@@ -1077,11 +1102,11 @@ export class GpuResidencyCache {
     const { tex, levels, gpuTexture } = prepared.value;
     const cacheKey = this.worldKey(handleSlot(handle), worldId);
 
-    if (!renderData.compressed && decoded.mipmap === true && levels > 1) {
+    if (!renderData.compressed && tex.mips.kind === 'generate' && levels > 1) {
       const blitRes = blitMipmapsSync(device, gpuTexture, {
         format: tex.format,
-        width: tex.width,
-        height: tex.height,
+        width: tex.shape.extent.width,
+        height: tex.shape.extent.height,
         levels,
       });
       if (!blitRes.ok) return blitRes as Result<TextureGpuEntry, RhiError>;
@@ -1089,10 +1114,14 @@ export class GpuResidencyCache {
 
     const viewRes = device.createTextureView(gpuTexture, {
       label: `texture-view-${cacheKey}`,
-      dimension: '2d',
+      dimension: renderData.shape.viewDimension,
     });
     if (!viewRes.ok) return viewRes;
-    const entry: TextureGpuEntry = { texture: this.wrapTex(gpuTexture), view: viewRes.value };
+    const entry: TextureGpuEntry = {
+      texture: this.wrapTex(gpuTexture),
+      view: viewRes.value,
+      receipt: this.textureReceipt(pod, renderData),
+    };
     const previous = this.textureGpuHandles.get(cacheKey);
     this.textureGpuHandles.set(cacheKey, entry);
     this.materialResourceEpoch += 1;
@@ -1106,6 +1135,25 @@ export class GpuResidencyCache {
     return ok(entry);
   }
 
+  private textureReceipt(
+    pod: TextureAsset,
+    renderData: TextureRenderData,
+  ): TextureResidencyReceipt {
+    return {
+      shape: pod.shape,
+      format: renderData.format,
+      extent: {
+        width: renderData.physicalExtent.width,
+        height: renderData.physicalExtent.height,
+        depthOrArrayLayers: renderData.depthOrArrayLayers,
+      },
+      bytes: pod.data.byteLength,
+      view: renderData.shape.viewDimension,
+      generation: ++this.textureGeneration,
+      deviceEpoch: this.deviceEpoch,
+    };
+  }
+
   /**
    * Shared texture-upload prelude: format / colorSpace consistency assertion,
    * GPU texture allocation + writeTexture. Returns `gpuTexture: undefined`
@@ -1155,13 +1203,21 @@ export class GpuResidencyCache {
     // upload before allocating a handle; binding a texture that the backend
     // accepted syntactically but cannot use later surfaces only as a generic
     // invalid-bind-group submit error.
-    const maxDimension = device.limits.maxTextureDimension2D;
-    if (tex.width > maxDimension || tex.height > maxDimension) {
+    const maxDimension =
+      tex.shape.viewDimension === '3d'
+        ? device.limits.maxTextureDimension3D
+        : device.limits.maxTextureDimension2D;
+    const width = tex.shape.extent.width;
+    const height = tex.shape.extent.height;
+    const layers = renderData.depthOrArrayLayers;
+    const exceedsLayerLimit =
+      tex.shape.viewDimension === '2d-array' && layers > device.limits.maxTextureArrayLayers;
+    if (width > maxDimension || height > maxDimension || exceedsLayerLimit) {
       return err(
         makeImageError({
           code: 'image-dimension-out-of-bounds',
-          requested: { width: tex.width, height: tex.height },
-          limit: maxDimension,
+          requested: { width, height },
+          limit: exceedsLayerLimit ? device.limits.maxTextureArrayLayers : maxDimension,
         }),
       );
     }
@@ -1171,11 +1227,11 @@ export class GpuResidencyCache {
       size: {
         width: renderData.physicalExtent.width,
         height: renderData.physicalExtent.height,
-        depthOrArrayLayers: 1,
+        depthOrArrayLayers: renderData.depthOrArrayLayers,
       },
       mipLevelCount: levels,
       sampleCount: 1,
-      dimension: '2d',
+      dimension: tex.shape.viewDimension === '3d' ? '3d' : '2d',
       format: renderData.format,
       usage: renderData.usage,
       viewFormats: [],
@@ -1193,28 +1249,77 @@ export class GpuResidencyCache {
       // block math). Full-subresource copies retain their logical size, including
       // non-block-aligned dimensions. queue.writeTexture avoids the 256 B
       // copyBufferToTexture alignment trap.
-      const layout = deriveMipUploadLayout(renderData.format, tex.width, tex.height, levels);
-      for (const lvl of layout) {
-        const slice = decoded.bytes.subarray(lvl.byteOffset, lvl.byteOffset + lvl.byteLength);
-        const writeRes = queue.writeTexture(
-          { texture: gpuTexture, mipLevel: lvl.level, origin: { x: 0, y: 0, z: 0 } },
-          slice,
-          { offset: 0, bytesPerRow: lvl.bytesPerRow, rowsPerImage: lvl.rowsPerImage },
-          { width: lvl.copyWidth, height: lvl.copyHeight, depthOrArrayLayers: 1 },
+      const layout = deriveTextureLayout({
+        shape: tex.shape,
+        format: renderData.format,
+        mips: tex.mips,
+      });
+      if (!layout.ok) {
+        return err(
+          makeAssetError({
+            code: 'invalid-source-format',
+            expected: layout.error.expected,
+            hint: layout.error.hint,
+          }),
         );
-        if (!writeRes.ok) return writeRes;
+      }
+      for (const level of layout.value.levels) {
+        for (let image = 0; image < level.imagesPerMip; image++) {
+          const imageBytes = level.bytesPerRow * level.rowsPerImage;
+          const offset = level.byteOffset + image * imageBytes;
+          const slice = decoded.bytes.subarray(offset, offset + imageBytes);
+          const writeRes = queue.writeTexture(
+            {
+              texture: gpuTexture,
+              mipLevel: level.level,
+              origin: { x: 0, y: 0, z: image },
+            },
+            slice,
+            { offset: 0, bytesPerRow: level.bytesPerRow, rowsPerImage: level.rowsPerImage },
+            {
+              width: level.physicalWidth,
+              height: level.physicalHeight,
+              depthOrArrayLayers: 1,
+            },
+          );
+          if (!writeRes.ok) return writeRes;
+        }
       }
       return ok({ id, tex, levels, gpuTexture });
     }
 
     // Uncompressed base-mip write; higher mips (when mipmap) are GPU-generated by
     // the caller's blit pass. rowsPerImage is the pixel height for linear RGBA.
-    const bytesPerRow = renderData.bytesPerRow;
+    const textureLayout = deriveTextureLayout({
+      shape: tex.shape,
+      format: renderData.format,
+      mips: tex.mips,
+    });
+    if (!textureLayout.ok) {
+      return err(
+        makeAssetError({
+          code: 'invalid-source-format',
+          expected: textureLayout.error.expected,
+          hint: textureLayout.error.hint,
+        }),
+      );
+    }
+    const baseLevel = textureLayout.value.levels[0];
+    if (baseLevel === undefined) {
+      return err(
+        makeAssetError({
+          code: 'invalid-source-format',
+          expected: 'texture layout contains a base mip level',
+          hint: ASSET_ERROR_HINTS['invalid-source-format'],
+        }),
+      );
+    }
+    const bytesPerRow = baseLevel.bytesPerRow;
     const writeTextureRes = queue.writeTexture(
       { texture: gpuTexture, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } },
       decoded.bytes,
-      { offset: 0, bytesPerRow, rowsPerImage: tex.height },
-      { width: tex.width, height: tex.height, depthOrArrayLayers: 1 },
+      { offset: 0, bytesPerRow, rowsPerImage: height },
+      { width, height, depthOrArrayLayers: renderData.depthOrArrayLayers },
     );
     if (!writeTextureRes.ok) return writeTextureRes;
 
@@ -1333,14 +1438,21 @@ export class GpuResidencyCache {
     // / format / data / colorSpace) but has no CPU mip chain, so the derived
     // texture view declares `mipmap:false` (the IBL prefilter mip chain is a
     // GPU-side pass, not a CPU-authored level set).
+    const sourceData =
+      sourcePod.data instanceof Uint8ClampedArray
+        ? new Uint8Array(
+            sourcePod.data.buffer,
+            sourcePod.data.byteOffset,
+            sourcePod.data.byteLength,
+          )
+        : sourcePod.data;
     const sourceTex: TextureAsset = {
       kind: 'texture',
-      width: sourcePod.width,
-      height: sourcePod.height,
+      shape: { viewDimension: '2d', extent: { width: sourcePod.width, height: sourcePod.height } },
       format: sourcePod.format,
-      data: sourcePod.data,
+      data: sourceData,
       colorSpace: sourcePod.colorSpace,
-      mipmap: false,
+      mips: { kind: 'none' },
     };
 
     // Project the equirect source POD into the cubemap descriptor (D-5): the
@@ -1365,20 +1477,11 @@ export class GpuResidencyCache {
     const tex: TextureAsset = projected.needsHalfConversion
       ? {
           kind: 'texture',
-          width: sourceTex.width,
-          height: sourceTex.height,
+          shape: sourceTex.shape,
           format: projected.outputFormat,
-          data: halfFloat.f32ToF16Bytes(
-            sourceTex.data instanceof Uint8ClampedArray
-              ? new Uint8Array(
-                  sourceTex.data.buffer,
-                  sourceTex.data.byteOffset,
-                  sourceTex.data.byteLength,
-                )
-              : sourceTex.data,
-          ),
+          data: halfFloat.f32ToF16Bytes(sourceTex.data),
           colorSpace: 'linear',
-          mipmap: false,
+          mips: { kind: 'none' },
         }
       : sourceTex;
 
@@ -1503,7 +1606,11 @@ export class GpuResidencyCache {
 
     const equirectTextureResult = device.createTexture({
       label: `equirect-${sourceId}`,
-      size: { width: tex.width, height: tex.height, depthOrArrayLayers: 1 },
+      size: {
+        width: tex.shape.extent.width,
+        height: tex.shape.extent.height,
+        depthOrArrayLayers: 1,
+      },
       mipLevelCount: 1,
       sampleCount: 1,
       dimension: '2d',
@@ -1526,8 +1633,15 @@ export class GpuResidencyCache {
     const equirectWriteResult = device.queue.writeTexture(
       { texture: equirectGpuTex },
       tex.data,
-      { bytesPerRow: tex.width * bytesPerPixel, rowsPerImage: tex.height },
-      { width: tex.width, height: tex.height, depthOrArrayLayers: 1 },
+      {
+        bytesPerRow: tex.shape.extent.width * bytesPerPixel,
+        rowsPerImage: tex.shape.extent.height,
+      },
+      {
+        width: tex.shape.extent.width,
+        height: tex.shape.extent.height,
+        depthOrArrayLayers: 1,
+      },
     );
     if (!equirectWriteResult.ok) return recordFailed(equirectWriteResult.error);
 
@@ -1803,20 +1917,16 @@ export class GpuResidencyCache {
 /**
  * Synthesize the `DecodedImage` view the texture-upload prelude consumes from
  * a `TextureAsset` POD (the record-stage pull path holds only the POD). The
- * POD's `data` is the pixel bytes; `colorSpace` + `mipmap` drive the
+ * POD's `data` is the pixel bytes; `colorSpace` + `mips` drive the
  * consistency assertion + mip count.
  */
 function decodedFromTexture(tex: TextureAsset): DecodedImage {
-  const bytes =
-    tex.data instanceof Uint8ClampedArray
-      ? new Uint8Array(tex.data.buffer, tex.data.byteOffset, tex.data.byteLength)
-      : tex.data;
   return {
-    bytes,
-    width: tex.width,
-    height: tex.height,
+    bytes: tex.data,
+    width: tex.shape.extent.width,
+    height: tex.shape.extent.height,
     mime: 'image/png',
     colorSpace: tex.colorSpace,
-    mipmap: tex.mipmap,
+    mipmap: tex.mips.kind === 'generate',
   };
 }

package/src/errors/render.ts

@@ -116,6 +116,23 @@ export function createRenderSurfaceError(
   return new RenderSurfaceError(`surface-${kind}-failed` as SurfaceFailureCode, detail);
 }
 
+export interface TemporalFrameSubmitDetail {
+  readonly reason: 'queue-submit-failed';
+}
+
+export class TemporalFrameSubmitError extends Error {
+  readonly code = 'temporal-frame-submit-rejected' as const;
+  readonly expected = 'the staged frame is accepted by queue.submit before temporal facts advance';
+  readonly hint = 'inspect the queue submission and retry the frame after the device is available';
+  readonly detail: TemporalFrameSubmitDetail;
+
+  constructor(reason: 'queue-submit-failed') {
+    super(`temporal-frame-submit-rejected: ${reason}`);
+    this.name = 'TemporalFrameSubmitError';
+    this.detail = { reason };
+  }
+}
+
 // ── ShadowInvalidConfigError ──────────────────────────────────────────────
 
 /**
@@ -1514,6 +1531,105 @@ export class PointsLinesPrepareFailedError extends Error {
   }
 }
 
+export interface VolumeOwnerConflictDetail {
+  readonly ownerCount: number;
+}
+
+export class VolumeOwnerConflictError extends Error {
+  readonly code = 'volume-owner-conflict' as const;
+  readonly expected = 'exactly one global VolumetricFog owner is authored';
+  readonly hint = 'remove additional VolumetricFog owners and retry extraction';
+  readonly detail: VolumeOwnerConflictDetail;
+
+  constructor(ownerCount: number) {
+    super(`volume-owner-conflict: received ${ownerCount} owners`);
+    this.name = 'VolumeOwnerConflictError';
+    this.detail = { ownerCount };
+  }
+}
+
+export interface VolumeDensityShapeMismatchDetail {
+  readonly guid: string;
+  readonly viewDimension: string;
+}
+
+export class VolumeDensityShapeMismatchError extends Error {
+  readonly code = 'volume-density-shape-mismatch' as const;
+  readonly expected = 'density is a linear 3D TextureAsset';
+  readonly hint = 'bind a verified linear texture with viewDimension 3d';
+  readonly detail: VolumeDensityShapeMismatchDetail;
+
+  constructor(guid: string, viewDimension: string) {
+    super(`volume-density-shape-mismatch: ${viewDimension} density is not 3d`);
+    this.name = 'VolumeDensityShapeMismatchError';
+    this.detail = { guid, viewDimension };
+  }
+}
+
+export interface VolumeInvalidBoundsDetail {
+  readonly min: readonly [number, number, number];
+  readonly max: readonly [number, number, number];
+}
+
+export class VolumeInvalidBoundsError extends Error {
+  readonly code = 'volume-invalid-bounds' as const;
+  readonly expected = 'bounds are finite and max is greater than min on every axis';
+  readonly hint = 'set finite non-degenerate volume bounds';
+  readonly detail: VolumeInvalidBoundsDetail;
+
+  constructor(bounds: VolumeInvalidBoundsDetail) {
+    super('volume-invalid-bounds: bounds must be finite and non-degenerate');
+    this.name = 'VolumeInvalidBoundsError';
+    this.detail = bounds;
+  }
+}
+
+export interface VolumeInvalidParametersDetail {
+  readonly field: string;
+  readonly value: unknown;
+}
+
+export class VolumeInvalidParametersError extends Error {
+  readonly code = 'volume-invalid-parameters' as const;
+  readonly expected = 'volume parameters remain finite and inside their closed ranges';
+  readonly hint = 'repair extinction, albedo, emission, anisotropy, or maxDistance';
+  readonly detail: VolumeInvalidParametersDetail;
+
+  constructor(input: { readonly maxDistance?: number; readonly anisotropy?: number }) {
+    const field =
+      input.maxDistance !== undefined && input.maxDistance <= 0 ? 'maxDistance' : 'parameters';
+    const value = field === 'maxDistance' ? input.maxDistance : input.anisotropy;
+    super(`volume-invalid-parameters: ${field} is outside the authored range`);
+    this.name = 'VolumeInvalidParametersError';
+    this.detail = { field, value };
+  }
+}
+
+export type VolumeError =
+  | VolumeOwnerConflictError
+  | VolumeDensityShapeMismatchError
+  | VolumeInvalidBoundsError
+  | VolumeInvalidParametersError;
+
+export interface ProjectorBindingDetail {
+  readonly guid: string;
+  readonly status: 'pending' | 'invalid' | 'bind-failed';
+}
+
+export class ProjectorBindingError extends Error {
+  readonly code = 'projector-binding-failed' as const;
+  readonly expected = 'authored projector is accepted and bound for both surface and volume';
+  readonly hint =
+    'inspect the projector Meta/Pack receipt, repair the source, and retry with the same GUID';
+  readonly detail: ProjectorBindingDetail;
+
+  constructor(guid: string, status: ProjectorBindingDetail['status']) {
+    super(`projector binding failed for ${guid}: ${status}`);
+    this.name = 'ProjectorBindingError';
+    this.detail = { guid, status };
+  }
+}
+
 // -- RenderErrorCode / RenderError closed unions --------------------------------
 
 /**
@@ -1566,4 +1682,6 @@ export type RenderError =
   | PointsLinesStyleUnsupportedError
   | PointsLinesMaterialUnsupportedError
   | PointsLinesBudgetExceededError
-  | PointsLinesPrepareFailedError;
+  | PointsLinesPrepareFailedError
+  | ProjectorBindingError
+  | VolumeError;

package/src/gpu-usage.ts

@@ -12,3 +12,5 @@ export const GPU_BUFFER_USAGE_UNIFORM = 0x40;
 export const GPU_BUFFER_USAGE_STORAGE = 0x80;
 export const GPU_BUFFER_USAGE_INDIRECT = 0x100;
 export const GPU_BUFFER_USAGE_MAP_READ = 0x01;
+/** GPUBufferUsage.QUERY_RESOLVE, used by optional timestamp captures. */
+export const GPU_BUFFER_USAGE_QUERY_RESOLVE = 0x200;

package/src/index.ts

@@ -67,6 +67,7 @@ export {
 } from './components/skybox-background';
 export { Skylight } from './components/skylight';
 export { SortKey } from './components/sort-key';
+export type { SpotLightAuthoring, SpotLightProjector } from './components/spot-light';
 export { SpotLight } from './components/spot-light';
 export {
   Visibility,
@@ -139,7 +140,11 @@ export type {
 export { Materials, MaterialTransmissionContractError } from './materials';
 // The host-facing default is a stable profile value; implementation-only
 // pipeline helpers remain behind the package boundary.
-export { DEFAULT_STANDARD_PROFILE } from './pipeline/standard-profile';
+export {
+  DEFAULT_STANDARD_PROFILE,
+  type StandardVolumetricFogProfile,
+  type StandardVolumetricFogQuality,
+} from './pipeline/standard-profile';
 export { renderComponentsPlugin } from './plugin';
 export {
   admitPointsLines,
@@ -170,6 +175,10 @@ export type {
   RenderWorldLease,
 } from './render-contract';
 export { RENDER_PHASE_CATALOG } from './render-contract';
+export type {
+  TemporalInspectionInput,
+  TemporalInspectionStatus,
+} from './renderer-inspect';
 export type { TemporalInspection, TemporalResourceInspection } from './temporal/inspection';
 export {
   SCENE_DATA_TEMPORAL_V1_DESCRIPTOR,
@@ -187,3 +196,31 @@ export {
   type SceneDataInspection,
 } from './temporal/scene-data-catalog';
 export type { TemporalView } from './temporal/view';
+export {
+  hasVolumetricFogCapability,
+  type IntegratedVolumeResource,
+  resolveIntegratedVolumeConsumer,
+  resolveSelectedVolumetricLight,
+  resolveVolumetricFogLightPair,
+  type VolumeConsumer,
+  type VolumetricFogLightKind,
+  type VolumetricFogLightPairResolution,
+  type VolumetricFogLightResolution,
+} from './volume/capability';
+export {
+  type ValidatedVolumetricFog,
+  type VolumeBounds,
+  type VolumeDensityBinding,
+  VolumetricFog,
+  type VolumetricFogAuthoring,
+  type VolumetricFogLightSelection,
+  validateVolumetricFog,
+} from './volume/component';
+export { extractVolumetricFog, type VolumetricFogExtract } from './volume/extract';
+export {
+  inspectVolumetricFog,
+  type VolumetricFogInspection,
+  type VolumetricFogInspectionInput,
+  type VolumetricFogInspectionStatus,
+  type VolumetricFogResourceStage,
+} from './volume/inspection';