@forgeax/engine-render 0.1.20 → 0.1.23

package/src/scene/visibility/types.ts

@@ -0,0 +1,50 @@
+/** Closed view roles used by the renderer-owned visibility facet. */
+export type VisibilityViewRole = 'main' | 'shadow' | 'reflection' | 'probe';
+
+export interface ViewKey {
+  readonly attachmentId: string;
+  readonly cameraEntity: number;
+  readonly viewRole: VisibilityViewRole;
+  readonly viewGeneration: number;
+}
+
+export interface PrimitiveKey {
+  readonly attachmentId: string;
+  readonly worldGeneration: number;
+  readonly primitiveSlot: number;
+  readonly slotGeneration: number;
+}
+
+export interface VisibilityCandidate {
+  readonly level: number;
+  readonly confidence: number;
+}
+
+export interface VisibilityFacetInspection {
+  readonly owner: 'persistent-render-scene';
+  readonly activeViews: number;
+  readonly facetRows: number;
+}
+
+export interface VisibilityFacetInput {
+  readonly view: ViewKey;
+  readonly primitive: PrimitiveKey;
+  readonly epoch: number;
+  readonly candidate: VisibilityCandidate;
+}
+
+export function viewKeyId(key: ViewKey): string {
+  return `${key.attachmentId}:${key.cameraEntity}:${key.viewRole}:${key.viewGeneration}`;
+}
+
+export function primitiveKeyId(key: PrimitiveKey): string {
+  return `${key.attachmentId}:${key.worldGeneration}:${key.primitiveSlot}:${key.slotGeneration}`;
+}
+
+export function viewKey(input: ViewKey): ViewKey {
+  return Object.freeze({ ...input });
+}
+
+export function primitiveKey(input: PrimitiveKey): PrimitiveKey {
+  return Object.freeze({ ...input });
+}

package/src/shadow-atlas.ts

@@ -3,8 +3,8 @@
 // feat-20260612-point-light-shadows-urp-hdrp M3 / T-M3-1 (plan-strategy §D-1).
 //
 // Lazy-allocated `texture_depth_cube_array` (depth32float) + per-face 2D
-// TextureView cache. One layer per shadow-casting PointLight (cap = 4 enforced
-// by the PointLightShadow ECS component cardinality). Total texel footprint at
+// TextureView cache. One layer per admitted shadow-casting PointLight; the
+// renderer owns the bounded atlas admission policy. Total texel footprint at
 // the 512x512 default = 4 layers x 6 faces x 512 x 512 x 4 B = 24 MiB.
 //
 // Why a separate module (vs inlining into createRenderer / pipelineState):
@@ -53,19 +53,19 @@ import { GPU_TEXTURE_USAGE_RENDER_ATTACHMENT_AND_TEXTURE_BINDING } from './gpu-t
 export interface ShadowAtlasOptions {
   /** Per-face square size in pixels. Default 512 (PointLightShadow.mapSize default). */
   readonly faceSize?: number;
-  /** Number of cube layers. Default 4 (= PointLightShadow cardinality cap). */
+  /** Number of cube layers. Default is the renderer atlas admission capacity. */
   readonly layers?: number;
 }
 
 /** Default per-face square size in pixels. Mirrors PointLightShadow.mapSize default. */
 export const SHADOW_ATLAS_DEFAULT_FACE_SIZE = 512;
-/** Default cube layer count. Mirrors PointLightShadow cardinality cap. */
+/** Default cube layer count. Renderer-owned point-shadow admission capacity. */
 export const SHADOW_ATLAS_DEFAULT_LAYERS = 4;
 
 /**
  * Cube-array depth atlas for point-light shadows.
  *
- * Shape: `texture_depth_cube_array` (depth32float) with `layers = 4` and per-
+ * Shape: `texture_depth_cube_array` (depth32float) with `layers` and per-
  * face size `faceSize x faceSize`. The cube_array sampling view feeds
  * `@group(0) @binding(5)` in URP shaders; the per-face 2D view feeds the
  * shadow-caster render pass attachment for one (layer, face) at a time

package/src/ssao-buffers.ts

@@ -106,6 +106,7 @@ export const SSAO_UNIFORM_BYTES = UNIFORM_BYTES;
 // recompile across enable/disable.
 
 interface SsaoFallbackResources {
+  readonly device: RenderSystemRuntime['device'];
   readonly texture: Texture;
   readonly view: TextureView;
   readonly sampler: Sampler;
@@ -126,7 +127,8 @@ export function getOrCreateSsaoFallbackTexture(
   runtime: RenderSystemRuntime,
 ): SsaoFallbackResources | null {
   const cached = fallbackCache.get(runtime);
-  if (cached !== undefined) return cached;
+  if (cached !== undefined && cached.device === runtime.device) return cached;
+  if (cached !== undefined) fallbackCache.delete(runtime);
 
   const device = runtime.device;
   const texRes = device.createTexture({
@@ -191,6 +193,7 @@ export function getOrCreateSsaoFallbackTexture(
   }
 
   const resources: SsaoFallbackResources = {
+    device,
     texture: texRes.value,
     view: viewRes.value,
     sampler: samplerRes.value,
@@ -205,6 +208,8 @@ export function getOrCreateSsaoFallbackTexture(
  * Fields are readonly per charter P5: one resource, one owner.
  */
 export interface SsaoBuffers {
+  /** Device identity that owns every handle in this bundle. */
+  readonly device: RenderSystemRuntime['device'];
   /** 64 padded vec4 uniform buffer for hemisphere samples. */
   readonly kernelBuffer: Buffer;
   readonly kernelBytes: number;
@@ -229,7 +234,8 @@ const cache = new WeakMap<RenderSystemRuntime, SsaoBuffers>();
  */
 export function getOrCreateSsaoBuffers(runtime: RenderSystemRuntime): SsaoBuffers | null {
   const cached = cache.get(runtime);
-  if (cached !== undefined) return cached;
+  if (cached !== undefined && cached.device === runtime.device) return cached;
+  if (cached !== undefined) cache.delete(runtime);
 
   const device = runtime.device;
 
@@ -322,6 +328,7 @@ export function getOrCreateSsaoBuffers(runtime: RenderSystemRuntime): SsaoBuffer
   }
 
   const buffers: SsaoBuffers = {
+    device,
     kernelBuffer: kernelBufferRes.value,
     kernelBytes: SSAO_KERNEL_SAMPLE_COUNT * BYTES_PER_KERNEL_ELEMENT,
     noiseTexture: noiseTexRes.value,

package/src/ssr/admission.ts

@@ -0,0 +1,451 @@
+/**
+ * Consumer-only SSR M0 admission.
+ *
+ * This module consumes detached producer receipts. It owns no capture,
+ * device, graph, or recovery handle and therefore cannot repair a missing
+ * producer. A complete receipt set is the only route to an admitted result.
+ */
+
+import {
+  type RhiTextureFormatCapabilityReceipt,
+  validateR32FloatReceipt,
+} from '@forgeax/engine-rhi';
+import type { ReflectionFallbackReceipt } from '../inspection-types';
+import type { SsrOwnerRecoveryAction } from './errors';
+import type { SsrAdmissionIdentity } from './identity';
+
+export const SSR_FORMAT_PROFILE = 'r32float-mip-sampled-storage' as const;
+
+export const SSR_FORMAT_STAGES = Object.freeze([
+  'texture-create',
+  'mip-view',
+  'sampled-storage-bind-group',
+  'pipeline-bind',
+  'finish',
+  'submit',
+  'completion',
+  'readback',
+] as const);
+
+export type { SsrAdmissionIdentity } from './identity';
+
+export type SsrFormatStage = (typeof SSR_FORMAT_STAGES)[number];
+
+/**
+ * The admission input is the real renderer owner receipt plus the one
+ * integration identity supplied by the host. It deliberately does not
+ * recreate submitted/source/LKG boolean flags.
+ */
+export type SsrReflectionFallbackReceipt = ReflectionFallbackReceipt & {
+  readonly identity: SsrAdmissionIdentity;
+};
+
+/** RHI capability receipt with the same host-supplied integration identity. */
+export type SsrFormatReceipt = RhiTextureFormatCapabilityReceipt & {
+  readonly identity: SsrAdmissionIdentity;
+};
+
+export interface SsrTemporalReceipt {
+  readonly identity: SsrAdmissionIdentity;
+  readonly successfulSubmit: true;
+  readonly generation: number;
+}
+
+export interface SsrAdmissionWork {
+  readonly attachmentCount: number;
+  readonly passCount: number;
+  readonly bindingCount: number;
+  readonly resourceCount: number;
+  readonly historyCount: 0;
+  readonly temporalDemand: 0;
+}
+
+export interface SsrAdmissionBudget {
+  readonly probeExecutions: 0 | 1;
+  readonly resetCount: 0;
+  readonly rebuildCount: 0;
+}
+
+export interface SsrAdmissionFailure {
+  readonly code:
+    | 'ssr-not-requested'
+    | 'ssr-reflection-fallback-unavailable'
+    | 'ssr-format-unavailable'
+    | 'ssr-temporal-unavailable'
+    | 'ssr-receipt-identity-mismatch'
+    | 'ssr-receipt-stale';
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: Readonly<{
+    readonly owner: 'producer' | 'format' | 'temporal' | 'consumer';
+    /** Owner-directed action an AI consumer can take without parsing hint text. */
+    readonly action: SsrOwnerRecoveryAction;
+    readonly generation?: number;
+    readonly identityField?: keyof SsrAdmissionIdentity;
+  }>;
+}
+
+export type SsrAdmissionResult =
+  | {
+      readonly status: 'admitted';
+      readonly identity: SsrAdmissionIdentity | undefined;
+      readonly generation: number;
+      readonly work: SsrAdmissionWork;
+      readonly budget: SsrAdmissionBudget;
+      readonly failure?: undefined;
+    }
+  | {
+      readonly status: 'fallback-only';
+      readonly identity: SsrAdmissionIdentity | undefined;
+      readonly generation: number;
+      readonly work: SsrAdmissionWork;
+      readonly budget: SsrAdmissionBudget;
+      readonly failure: SsrAdmissionFailure;
+    };
+
+export interface SsrAdmissionInput {
+  readonly requested: boolean;
+  readonly identity: SsrAdmissionIdentity;
+  readonly reflectionFallback?: SsrReflectionFallbackReceipt;
+  readonly format?: SsrFormatReceipt;
+  readonly temporal?: SsrTemporalReceipt;
+  readonly previousGeneration?: number;
+}
+
+/** Public renderer projection consumed by the parent SSR feature. */
+export interface SsrDependenciesInspection {
+  readonly status: 'admitted' | 'fallback-only';
+  /** Absent until the host binds an exact source/tree/lock/build identity. */
+  readonly identity: SsrAdmissionIdentity | undefined;
+  readonly requested: boolean;
+  readonly reflectionFallback: ReflectionFallbackReceipt | undefined;
+  readonly format: SsrFormatReceipt | undefined;
+  readonly temporal: SsrTemporalReceipt | undefined;
+  readonly admission: SsrAdmissionResult;
+  readonly work: SsrAdmissionWork;
+  readonly budget: SsrAdmissionBudget;
+  readonly failure: SsrAdmissionFailure | undefined;
+}
+
+const ZERO_WORK: SsrAdmissionWork = Object.freeze({
+  attachmentCount: 0,
+  passCount: 0,
+  bindingCount: 0,
+  resourceCount: 0,
+  historyCount: 0,
+  temporalDemand: 0,
+});
+
+const ADMITTED_WORK: SsrAdmissionWork = Object.freeze({
+  attachmentCount: 1,
+  passCount: 1,
+  bindingCount: 1,
+  resourceCount: 1,
+  historyCount: 0,
+  temporalDemand: 0,
+});
+
+const ZERO_BUDGET: SsrAdmissionBudget = Object.freeze({
+  probeExecutions: 0,
+  resetCount: 0,
+  rebuildCount: 0,
+});
+
+const ADMITTED_BUDGET: SsrAdmissionBudget = Object.freeze({
+  probeExecutions: 1,
+  resetCount: 0,
+  rebuildCount: 0,
+});
+
+function identityFieldMismatch(
+  expected: SsrAdmissionIdentity,
+  actual: SsrAdmissionIdentity,
+): keyof SsrAdmissionIdentity | undefined {
+  for (const field of ['sourceHead', 'sourceTree', 'lockSha256', 'buildSha256'] as const) {
+    if (expected[field] !== actual[field]) return field;
+  }
+  return undefined;
+}
+
+function blocked(
+  identity: SsrAdmissionIdentity | undefined,
+  failure: SsrAdmissionFailure,
+  generation = 0,
+): SsrAdmissionResult {
+  return Object.freeze({
+    status: 'fallback-only',
+    identity,
+    generation,
+    work: ZERO_WORK,
+    budget: ZERO_BUDGET,
+    failure,
+  });
+}
+
+function failure(
+  code: SsrAdmissionFailure['code'],
+  owner: SsrAdmissionFailure['detail']['owner'],
+  hint: string,
+  detail: Omit<SsrAdmissionFailure['detail'], 'owner' | 'action'> = {},
+): SsrAdmissionFailure {
+  const action: SsrOwnerRecoveryAction = recoveryActionFor(code);
+  return Object.freeze({
+    code,
+    expected: 'all producer, format, and temporal receipts share one admitted identity',
+    hint,
+    detail: Object.freeze({ owner, action, ...detail }),
+  });
+}
+
+function recoveryActionFor(code: SsrAdmissionFailure['code']): SsrOwnerRecoveryAction {
+  switch (code) {
+    case 'ssr-reflection-fallback-unavailable':
+    case 'ssr-receipt-identity-mismatch':
+      return 'rebuild';
+    case 'ssr-not-requested':
+    case 'ssr-format-unavailable':
+    case 'ssr-temporal-unavailable':
+    case 'ssr-receipt-stale':
+      return 'retry';
+  }
+}
+
+function receiptFailure(
+  input: SsrAdmissionInput,
+  receipt: { readonly identity: SsrAdmissionIdentity },
+  owner: SsrAdmissionFailure['detail']['owner'],
+): SsrAdmissionResult | undefined {
+  const field = identityFieldMismatch(input.identity, receipt.identity);
+  if (field === undefined) return undefined;
+  return blocked(
+    input.identity,
+    failure('ssr-receipt-identity-mismatch', owner, 'rebuild the owner receipt for this identity', {
+      identityField: field,
+    }),
+  );
+}
+
+function validFallback(receipt: SsrReflectionFallbackReceipt | undefined): boolean {
+  return (
+    receipt !== undefined &&
+    receipt.candidateVisible === false &&
+    Number.isFinite(receipt.coverage) &&
+    receipt.coverage >= 0 &&
+    receipt.coverage <= 1 &&
+    (receipt.sourceKey === undefined || receipt.sourceKey.length > 0) &&
+    (receipt.extent === undefined ||
+      (receipt.extent.length === 3 &&
+        receipt.extent.every((value) => Number.isFinite(value) && value > 0))) &&
+    Number.isInteger(receipt.sourceGeneration) &&
+    receipt.sourceGeneration >= 0 &&
+    Number.isInteger(receipt.projectionGeneration) &&
+    receipt.projectionGeneration >= 0 &&
+    Number.isInteger(receipt.deviceGeneration) &&
+    receipt.deviceGeneration >= 0 &&
+    receipt.brdfSignature === 'standard-pbr-ibl-v1' &&
+    ((receipt.source === 'probe' && (receipt.state === 'active' || receipt.state === 'lkg')) ||
+      (receipt.source === 'skylight' && (receipt.state === 'active' || receipt.state === 'lkg')) ||
+      (receipt.source === 'neutral' && receipt.state === 'neutral'))
+  );
+}
+
+function validFormat(receipt: SsrFormatReceipt | undefined): boolean {
+  if (
+    receipt?.profile !== SSR_FORMAT_PROFILE ||
+    receipt.verdict !== 'admitted' ||
+    receipt.evidence !== 'real' ||
+    !Number.isInteger(receipt.deviceGeneration) ||
+    receipt.deviceGeneration < 0
+  ) {
+    return false;
+  }
+  if (
+    !SSR_FORMAT_STAGES.every((stage) =>
+      receipt.stages.some((entry) => entry.stage === stage && entry.verdict === 'admitted'),
+    )
+  ) {
+    return false;
+  }
+  return validateR32FloatReceipt(receipt).ok;
+}
+
+function validTemporal(receipt: SsrTemporalReceipt | undefined): boolean {
+  return (
+    receipt?.successfulSubmit === true &&
+    Number.isInteger(receipt.generation) &&
+    receipt.generation >= 0
+  );
+}
+
+export function admitSsrM0(input: SsrAdmissionInput): SsrAdmissionResult {
+  if (!input.requested) {
+    return blocked(
+      input.identity,
+      failure('ssr-not-requested', 'consumer', 'request SSR before evaluating M0 admission'),
+    );
+  }
+  if (input.reflectionFallback === undefined) {
+    return blocked(
+      input.identity,
+      failure('ssr-reflection-fallback-unavailable', 'producer', 'use LKG, Skylight, or neutral'),
+    );
+  }
+  const fallbackIdentityFailure = receiptFailure(input, input.reflectionFallback, 'producer');
+  if (fallbackIdentityFailure !== undefined) return fallbackIdentityFailure;
+  if (!validFallback(input.reflectionFallback)) {
+    return blocked(
+      input.identity,
+      failure(
+        'ssr-reflection-fallback-unavailable',
+        'producer',
+        'inspect and rebuild the producer receipt',
+      ),
+      input.reflectionFallback.projectionGeneration,
+    );
+  }
+  if (input.format === undefined) {
+    return blocked(
+      input.identity,
+      failure('ssr-format-unavailable', 'format', 'probe the exact format profile for this device'),
+      input.reflectionFallback.projectionGeneration,
+    );
+  }
+  const formatIdentityFailure = receiptFailure(input, input.format, 'format');
+  if (formatIdentityFailure !== undefined) return formatIdentityFailure;
+  if (!validFormat(input.format)) {
+    return blocked(
+      input.identity,
+      failure('ssr-format-unavailable', 'format', 'complete the full r32float profile probe'),
+      input.reflectionFallback.projectionGeneration,
+    );
+  }
+  if (input.temporal === undefined) {
+    return blocked(
+      input.identity,
+      failure(
+        'ssr-temporal-unavailable',
+        'temporal',
+        'submit the matching temporal producer receipt',
+      ),
+      input.reflectionFallback.projectionGeneration,
+    );
+  }
+  const temporalIdentityFailure = receiptFailure(input, input.temporal, 'temporal');
+  if (temporalIdentityFailure !== undefined) return temporalIdentityFailure;
+  if (!validTemporal(input.temporal)) {
+    return blocked(
+      input.identity,
+      failure('ssr-temporal-unavailable', 'temporal', 'inspect and rebuild the temporal receipt'),
+      input.reflectionFallback.projectionGeneration,
+    );
+  }
+  if (
+    input.previousGeneration !== undefined &&
+    input.previousGeneration !== input.reflectionFallback.projectionGeneration
+  ) {
+    return blocked(
+      input.identity,
+      failure(
+        'ssr-receipt-stale',
+        'consumer',
+        'discard stale completion and reinspect the owners',
+        {
+          generation: input.reflectionFallback.projectionGeneration,
+        },
+      ),
+      input.reflectionFallback.projectionGeneration,
+    );
+  }
+  return Object.freeze({
+    status: 'admitted',
+    identity: input.identity,
+    generation: input.reflectionFallback.projectionGeneration,
+    work: ADMITTED_WORK,
+    budget: ADMITTED_BUDGET,
+  });
+}
+
+/**
+ * Joins the live owner projections at the renderer boundary. The only casts
+ * here add the host identity to receipts that otherwise remain canonical RHI
+ * or ReflectionProbe PODs; no producer fact is copied or renamed.
+ */
+export function projectSsrDependencies(input: {
+  readonly requested: boolean;
+  readonly identity: SsrAdmissionIdentity | undefined;
+  readonly reflectionFallback: ReflectionFallbackReceipt | undefined;
+  readonly format: RhiTextureFormatCapabilityReceipt | undefined;
+  readonly temporal: { readonly successfulSubmit: true; readonly generation: number } | undefined;
+  readonly previousGeneration?: number;
+}): SsrDependenciesInspection {
+  const identity = input.identity;
+  const reflectionFallback =
+    identity === undefined || input.reflectionFallback?.identity === undefined
+      ? undefined
+      : (input.reflectionFallback as SsrReflectionFallbackReceipt);
+  const format =
+    identity === undefined || input.format === undefined
+      ? undefined
+      : ({ ...input.format, identity } satisfies SsrFormatReceipt);
+  const temporal =
+    identity === undefined || input.temporal === undefined
+      ? undefined
+      : ({ identity, ...input.temporal } satisfies SsrTemporalReceipt);
+  const admission =
+    identity === undefined
+      ? blocked(
+          undefined,
+          failure(
+            input.requested ? 'ssr-receipt-identity-mismatch' : 'ssr-not-requested',
+            'consumer',
+            input.requested
+              ? 'bind the exact source, tree, lock, and build identity before admission'
+              : 'request SSR before evaluating M0 admission',
+            input.requested ? { identityField: 'sourceHead' } : {},
+          ),
+        )
+      : admitSsrM0({
+          requested: input.requested,
+          identity,
+          ...(reflectionFallback === undefined ? {} : { reflectionFallback }),
+          ...(format === undefined ? {} : { format }),
+          ...(temporal === undefined ? {} : { temporal }),
+          ...(input.previousGeneration === undefined
+            ? {}
+            : { previousGeneration: input.previousGeneration }),
+        });
+  return Object.freeze({
+    status: admission.status,
+    identity,
+    requested: input.requested,
+    reflectionFallback: input.reflectionFallback,
+    format,
+    temporal,
+    admission,
+    work: admission.work,
+    budget: admission.budget,
+    failure: admission.failure,
+  });
+}
+
+export function zeroSsrAdmissionWork(): SsrAdmissionWork {
+  return ZERO_WORK;
+}
+
+/**
+ * Projects the admission decision into the existing temporal reset seam.
+ * Admission never creates temporal history; only a changed committed
+ * producer generation can request a reset through the coordinator.
+ */
+export function resolveSsrAdmissionGeneration(
+  previousGeneration: number | undefined,
+  nextGeneration: number | undefined,
+): { readonly changed: boolean; readonly generation: number | undefined } {
+  return {
+    changed:
+      previousGeneration !== undefined &&
+      nextGeneration !== undefined &&
+      previousGeneration !== nextGeneration,
+    generation: nextGeneration,
+  };
+}

package/src/ssr/composition.ts

@@ -0,0 +1,73 @@
+import { err, ok, type Result } from '@forgeax/engine-types';
+
+/** Linear HDR RGB used by the M0 composition contract. */
+export type SsrReflectionColor = readonly [number, number, number];
+
+export interface SsrCompositionInput {
+  /** Screen-hit confidence. The parent SSR consumer supplies 0..1. */
+  readonly c: number;
+  /** The Standard BRDF specular lobe before SSR replacement. */
+  readonly baseSpecular: SsrReflectionColor;
+  /** The same-source BRDF-projected screen contribution. */
+  readonly screenSpecular: SsrReflectionColor;
+  /** The committed producer-owned environment contribution. */
+  readonly fallbackSpecular: SsrReflectionColor;
+}
+
+export interface SsrCompositionInputError {
+  readonly code: 'ssr-composition-input-invalid';
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: Readonly<{
+    readonly field: 'c' | 'baseSpecular' | 'screenSpecular' | 'fallbackSpecular';
+  }>;
+}
+
+export type SsrCompositionResult = Result<SsrReflectionColor, SsrCompositionInputError>;
+
+function finiteColor(value: SsrReflectionColor): boolean {
+  return value.length === 3 && value.every(Number.isFinite);
+}
+
+function invalid(
+  field: SsrCompositionInputError['detail']['field'],
+  expected: string,
+): SsrCompositionResult {
+  return err({
+    code: 'ssr-composition-input-invalid',
+    expected,
+    hint: 'preserve linear HDR and the bounded SSR confidence before composing',
+    detail: Object.freeze({ field }),
+  });
+}
+
+/**
+ * Apply the M0 reflection replacement contract without owning an SSR pass.
+ *
+ * `c=0` returns the base Standard specular lobe. `c=1` replaces only that
+ * lobe with the same-source screen contribution, subtracting the committed
+ * environment contribution once. Hi-Z traversal, history and graph wiring
+ * remain owned by the parent SSR feature.
+ */
+export function composeSsrReflection(input: SsrCompositionInput): SsrCompositionResult {
+  if (!Number.isFinite(input.c) || input.c < 0 || input.c > 1) {
+    return invalid('c', 'a finite confidence in the inclusive range 0..1');
+  }
+  for (const [field, value] of [
+    ['baseSpecular', input.baseSpecular],
+    ['screenSpecular', input.screenSpecular],
+    ['fallbackSpecular', input.fallbackSpecular],
+  ] as const) {
+    if (!finiteColor(value)) {
+      return invalid(field, 'three finite linear HDR RGB channels');
+    }
+  }
+  const c = input.c;
+  return ok(
+    Object.freeze([
+      input.baseSpecular[0] + c * (input.screenSpecular[0] - input.fallbackSpecular[0]),
+      input.baseSpecular[1] + c * (input.screenSpecular[1] - input.fallbackSpecular[1]),
+      input.baseSpecular[2] + c * (input.screenSpecular[2] - input.fallbackSpecular[2]),
+    ]) as SsrReflectionColor,
+  );
+}