@aura3d/rendering 1.4.0 → 1.4.2

package/src/animation/AnimationVisualQuality.ts

@@ -1,71 +0,0 @@
-import { evaluateFrameVisualQuality, type FrameVisualMetrics, type FrameVisualQualityThresholds } from "../FrameVisualMetrics.js";
-
-export interface AnimationFrameVisualInput {
-  readonly id: string;
-  readonly metrics: FrameVisualMetrics;
-  readonly characterCount?: number | undefined;
-  readonly captionOccluded?: boolean | undefined;
-  readonly routeChromeVisible?: boolean | undefined;
-  readonly debugOverlayVisible?: boolean | undefined;
-}
-
-export interface AnimationFrameVisualQuality {
-  readonly id: string;
-  readonly ok: boolean;
-  readonly failures: readonly string[];
-}
-
-export interface AnimationVisualQualityReport {
-  readonly kind: "animation-visual-quality";
-  readonly ok: boolean;
-  readonly frames: readonly AnimationFrameVisualQuality[];
-  readonly visibleCharacterCount: number;
-  readonly blockers: readonly string[];
-}
-
-export interface AnimationVisualQualityOptions {
-  readonly thresholds?: FrameVisualQualityThresholds | undefined;
-  readonly minVisibleCharacters?: number | undefined;
-}
-
-export function createAnimationVisualQualityReport(
-  frames: readonly AnimationFrameVisualInput[],
-  options: AnimationVisualQualityOptions = {}
-): AnimationVisualQualityReport {
-  const thresholds = options.thresholds ?? defaultAnimationVisualQualityThresholds;
-  const frameResults = frames.map((frame): AnimationFrameVisualQuality => {
-    const base = evaluateFrameVisualQuality(frame.metrics, thresholds);
-    const failures = [
-      ...base.failures,
-      frame.captionOccluded ? "caption occludes important action" : undefined,
-      frame.routeChromeVisible ? "route chrome is visible" : undefined,
-      frame.debugOverlayVisible ? "debug overlay is visible" : undefined
-    ].filter((failure): failure is string => Boolean(failure));
-    return { id: frame.id, ok: failures.length === 0, failures };
-  });
-  const visibleCharacterCount = Math.max(0, ...frames.map((frame) => frame.characterCount ?? 0));
-  const blockers = [
-    ...frameResults.flatMap((frame) => frame.failures.map((failure) => `${frame.id}: ${failure}`)),
-    visibleCharacterCount < (options.minVisibleCharacters ?? 2)
-      ? `visibleCharacterCount ${visibleCharacterCount} < ${options.minVisibleCharacters ?? 2}`
-      : undefined
-  ].filter((blocker): blocker is string => Boolean(blocker));
-  return {
-    kind: "animation-visual-quality",
-    ok: blockers.length === 0,
-    frames: frameResults,
-    visibleCharacterCount,
-    blockers
-  };
-}
-
-export const defaultAnimationVisualQualityThresholds: FrameVisualQualityThresholds = {
-  minNonDarkRatio: 0.08,
-  minSalientRatio: 0.035,
-  minOccupiedAreaRatio: 0.08,
-  minOccupiedQuadrants: 2,
-  minColorBuckets: 6,
-  maxDominantBucketRatio: 0.92,
-  maxFlatPixelRatio: 0.98,
-  minLocalContrastRatio: 0.002
-};

package/src/animation/applyAnimationRenderPreset.ts

@@ -1,180 +0,0 @@
-import { AnimationToonMaterial, type AnimationToonMaterialOptions } from "./AnimationToonMaterial.js";
-import type { AnimationRenderPresetEvidence } from "./AnimationRenderPreset.js";
-import type { AnimationMaterialStyle } from "./AnimationMaterialStyle.js";
-import { colorGradePixels, outlinePixels, type ColorGradeResult, type OutlineResult } from "../PostProcessPass.js";
-
-/**
- * applyAnimationRenderPreset — turns a (metadata) AnimationRenderPreset into the
- * concrete, pixel-affecting treatment it describes:
- *
- *  1. MATERIAL: builds a real `AnimationToonMaterial` (banded N·L ramp + rim) from
- *     the preset's `materialStyle`. The band count comes from `materialStyle.rampSteps`.
- *  2. OUTLINE: runs the existing Sobel `outlinePixels()` post-pass when the style
- *     requests outlines.
- *  3. COLOR GRADE: pushes a stylized, slightly-saturated, gently-contrasted grade
- *     consistent with the preset (storybook look), honoring `reducedFlash`.
- *
- * WHAT ACTUALLY AFFECTS PIXELS (honest accounting):
- *  - `material` is a fully-wired engine material. Assigning it to scene meshes and
- *    rendering with a ShaderLibrary that has the animation program registered produces
- *    banded toon shading on real fragments. THIS FUNCTION DOES NOT REASSIGN SCENE
- *    MESH MATERIALS — there is no scene-graph type imported here — it RETURNS the
- *    material so the caller (which owns the scene) can assign it. That assignment
- *    step is the one piece that is the caller's responsibility, not this function's.
- *  - `outline` (when present) is a real OutlineResult whose `.pixels` ARE modified
- *    image bytes. If you pass a frame buffer, the returned bytes are drawn pixels.
- *  - `colorGrade` (when a frame is passed) is a real ColorGradeResult — modified
- *    pixels.
- *
- * WHAT IS NOT WIRED:
- *  - Lights / shadows from the preset are reflected in the returned `lighting`
- *    descriptor and fed into the toon material's single key-light uniforms, but the
- *    multi-light rig (`preset.lights`) is descriptive — the toon program consumes one
- *    directional key light, not the full named rig.
- *  - Bloom/fog from the preset are NOT applied here (they belong to the HDR pipeline);
- *    only outline + color grade run as post-passes in this function.
- */
-
-export interface ApplyAnimationRenderPresetFrame {
-  /** RGBA8 pixel buffer (length === width * height * 4). */
-  readonly pixels: Uint8Array;
-  readonly width: number;
-  readonly height: number;
-}
-
-export interface AnimationRenderPresetLightingDescriptor {
-  readonly keyLightDirection: readonly [number, number, number];
-  readonly keyLightColor: readonly [number, number, number];
-  readonly softShadows: boolean;
-  readonly contactShadows: boolean;
-  /** The full named rig from the preset (descriptive — not all consumed by the toon program). */
-  readonly namedRig: readonly string[];
-}
-
-export interface ApplyAnimationRenderPresetOptions {
-  /** Optional explicit base color override for the toon material. */
-  readonly baseColor?: readonly [number, number, number, number] | undefined;
-  /** Optional toon material override knobs (light direction/colors/rim). */
-  readonly material?: Partial<AnimationToonMaterialOptions> | undefined;
-  /** Optional frame to run the outline + color-grade post-passes against. */
-  readonly frame?: ApplyAnimationRenderPresetFrame | undefined;
-}
-
-export interface ApplyAnimationRenderPresetResult {
-  readonly kind: "animation-render-preset-application";
-  /** Real engine material — assign to scene meshes to get banded toon pixels. */
-  readonly material: AnimationToonMaterial;
-  readonly materialStyle: AnimationMaterialStyle;
-  /** Key-light descriptor derived from the preset, also baked into the material. */
-  readonly lighting: AnimationRenderPresetLightingDescriptor;
-  /** True when the Sobel outline pass is enabled for this preset. */
-  readonly outlineEnabled: boolean;
-  /** Present only when a frame was supplied AND outlines are enabled. Real modified pixels. */
-  readonly outline?: OutlineResult | undefined;
-  /** Present only when a frame was supplied. Real modified pixels. */
-  readonly colorGrade?: ColorGradeResult | undefined;
-  /** Honest per-stage record of what touched pixels. */
-  readonly appliedToPixels: {
-    readonly toonMaterial: "returned-for-caller-assignment";
-    readonly outline: boolean;
-    readonly colorGrade: boolean;
-  };
-}
-
-const DEFAULT_KEY_LIGHT_DIRECTION: readonly [number, number, number] = [0.3, 0.8, 0.5];
-
-/**
- * Map a AnimationMaterialStyle.treatment to a shadow-floor that keeps the chosen
- * look readable: flatter treatments use a higher floor (less contrast between bands).
- */
-function shadowFloorForTreatment(style: AnimationMaterialStyle): number {
-  switch (style.treatment) {
-    case "flat-readable":
-      return 0.6;
-    case "soft-toon":
-      return 0.45;
-    case "cel":
-      return 0.3;
-    case "preserve-pbr":
-    default:
-      return 0.4;
-  }
-}
-
-export function applyAnimationRenderPreset(
-  preset: AnimationRenderPresetEvidence,
-  options: ApplyAnimationRenderPresetOptions = {}
-): ApplyAnimationRenderPresetResult {
-  const style = preset.materialStyle;
-
-  const keyLightDirection = options.material?.lightDirection ?? DEFAULT_KEY_LIGHT_DIRECTION;
-  const keyLightColor = options.material?.lightColor ?? [1, 0.97, 0.9];
-
-  // 1. MATERIAL — band count comes straight from the style's rampSteps (clamped to
-  // the toon material's supported [2, 16] range).
-  const bands = Math.max(2, Math.min(16, Math.round(style.rampSteps)));
-  const material = new AnimationToonMaterial({
-    name: `${preset.name}-toon`,
-    baseColor: options.baseColor ?? options.material?.baseColor ?? [0.92, 0.58, 0.16, 1],
-    bands,
-    shadowFloor: options.material?.shadowFloor ?? shadowFloorForTreatment(style),
-    lightDirection: keyLightDirection,
-    lightColor: keyLightColor as readonly [number, number, number],
-    rimColor: options.material?.rimColor ?? [0.6, 0.72, 1],
-    rimPower: options.material?.rimPower ?? 3,
-    // Cel treatment leans on a stronger rim for graphic edges.
-    rimIntensity: options.material?.rimIntensity ?? (style.treatment === "cel" ? 0.6 : 0.4)
-  });
-
-  const lighting: AnimationRenderPresetLightingDescriptor = {
-    keyLightDirection,
-    keyLightColor: keyLightColor as readonly [number, number, number],
-    softShadows: preset.shadows.soft,
-    contactShadows: preset.shadows.contact,
-    namedRig: preset.lights
-  };
-
-  const outlineEnabled = style.outline;
-
-  let outline: OutlineResult | undefined;
-  let colorGrade: ColorGradeResult | undefined;
-
-  if (options.frame) {
-    const { pixels, width, height } = options.frame;
-    // 2. OUTLINE — real Sobel edge pass over the supplied frame.
-    let working = pixels;
-    if (outlineEnabled) {
-      outline = outlinePixels(working, width, height, {
-        // Warm storybook ink that reads against the night palette.
-        color: [24, 18, 12, 255],
-        width: 1,
-        threshold: 0.22,
-        opacity: 0.85
-      });
-      working = outline.pixels;
-    }
-    // 3. COLOR GRADE — stylized grade; reducedFlash trims saturation/contrast.
-    const punch = preset.reducedFlash ? 1 : 1.05;
-    colorGrade = colorGradePixels(working, width, height, {
-      contrast: punch,
-      saturation: 1 + style.saturationBoost,
-      vibrance: preset.reducedFlash ? 0.05 : 0.12,
-      vignette: 0.18
-    });
-  }
-
-  return {
-    kind: "animation-render-preset-application",
-    material,
-    materialStyle: style,
-    lighting,
-    outlineEnabled,
-    outline,
-    colorGrade,
-    appliedToPixels: {
-      toonMaterial: "returned-for-caller-assignment",
-      outline: outline !== undefined,
-      colorGrade: colorGrade !== undefined
-    }
-  };
-}

package/src/animation/index.ts

@@ -1,5 +0,0 @@
-export * from "./AnimationMaterialStyle.js";
-export * from "./AnimationRenderPreset.js";
-export * from "./AnimationVisualQuality.js";
-export * from "./AnimationToonMaterial.js";
-export * from "./applyAnimationRenderPreset.js";

package/src/cinematic/BloomPass.ts

@@ -1,26 +0,0 @@
-import { createRendererOwnedEvidenceFlag, type CinematicRendererEvidenceFlag } from "./CinematicEvidence";
-
-export interface CinematicBloomPass {
-  readonly name: "bloom";
-  readonly threshold: number;
-  readonly intensity: number;
-  readonly radius: number;
-  readonly rendererOwnedEvidence: CinematicRendererEvidenceFlag;
-}
-
-export function createCinematicBloomPass(options: Partial<Omit<CinematicBloomPass, "name" | "rendererOwnedEvidence">> = {}): CinematicBloomPass {
-  return {
-    name: "bloom",
-    threshold: options.threshold ?? 0.72,
-    intensity: options.intensity ?? 0.28,
-    radius: options.radius ?? 1.35,
-    rendererOwnedEvidence: createRendererOwnedEvidenceFlag({
-      id: "postprocess:bloom",
-      feature: "postprocess",
-      label: "Bloom/glow pass",
-      source: "renderer-postprocess",
-      sceneContent: false,
-      diagnostics: ["Bloom is a renderer postprocess pass over emissive scene content."]
-    })
-  };
-}

package/src/cinematic/CinematicDepthComposition.ts

@@ -1,30 +0,0 @@
-import { createRendererOwnedEvidenceFlag, type CinematicRendererEvidenceFlag } from "./CinematicEvidence";
-
-export interface CinematicDepthCompositionPlan {
-  readonly mode: "depth-aware" | "camera-sorted";
-  readonly depthTextureRequired: boolean;
-  readonly fallback: "camera-sorted-transparent-cards";
-  readonly rendererOwnedEvidence: CinematicRendererEvidenceFlag;
-  readonly diagnostics: readonly string[];
-}
-
-export function createCinematicDepthCompositionPlan(options: { readonly depthTextureAvailable?: boolean } = {}): CinematicDepthCompositionPlan {
-  const depthTextureAvailable = options.depthTextureAvailable === true;
-  return {
-    mode: depthTextureAvailable ? "depth-aware" : "camera-sorted",
-    depthTextureRequired: depthTextureAvailable,
-    fallback: "camera-sorted-transparent-cards",
-    rendererOwnedEvidence: createRendererOwnedEvidenceFlag({
-      id: "vfx:depth-composition",
-      feature: "vfx",
-      label: "Depth-aware VFX composition",
-      source: "renderer-vfx",
-      diagnostics: [depthTextureAvailable ? "VFX can sample renderer-owned depth." : "VFX falls back to camera-sorted renderer cards/particles."]
-    }),
-    diagnostics: [
-      depthTextureAvailable
-        ? "Depth texture is available for VFX composition."
-        : "Depth texture is not declared; composition remains renderer-owned but uses camera-sorted approximations."
-    ]
-  };
-}

package/src/cinematic/CinematicEvidence.ts

@@ -1,123 +0,0 @@
-export type CinematicEvidenceFeature =
-  | "material"
-  | "lighting"
-  | "vfx"
-  | "postprocess"
-  | "camera"
-  | "timeline"
-  | "blocking"
-  | "asset"
-  | "environment";
-
-export type CinematicEvidenceSource =
-  | "renderer-scene"
-  | "renderer-material"
-  | "renderer-light"
-  | "renderer-vfx"
-  | "renderer-postprocess"
-  | "renderer-camera"
-  | "renderer-timeline"
-  | "dom-overlay"
-  | "css-overlay";
-
-export interface CinematicRendererEvidenceFlag {
-  readonly id: string;
-  readonly feature: CinematicEvidenceFeature;
-  readonly label: string;
-  readonly source: CinematicEvidenceSource;
-  readonly rendererOwned: boolean;
-  readonly sceneContent: boolean;
-  readonly domOverlay: boolean;
-  readonly satisfiesPublicCinematicGate: boolean;
-  readonly diagnostics: readonly string[];
-}
-
-export interface CinematicDomOverlayRejection {
-  readonly ok: false;
-  readonly code: "AURA_CINEMATIC_DOM_OVERLAY_EVIDENCE_REJECTED";
-  readonly missingRendererOwnedFeatures: readonly CinematicEvidenceFeature[];
-  readonly overlayOnlyFeatures: readonly CinematicEvidenceFeature[];
-  readonly diagnostics: readonly string[];
-}
-
-export interface CinematicRendererEvidenceAccepted {
-  readonly ok: true;
-  readonly rendererOwnedFeatures: readonly CinematicEvidenceFeature[];
-  readonly diagnostics: readonly string[];
-}
-
-export type CinematicRendererEvidenceValidation = CinematicRendererEvidenceAccepted | CinematicDomOverlayRejection;
-
-export function createRendererOwnedEvidenceFlag(input: {
-  readonly id: string;
-  readonly feature: CinematicEvidenceFeature;
-  readonly label: string;
-  readonly source?: Exclude<CinematicEvidenceSource, "dom-overlay" | "css-overlay">;
-  readonly sceneContent?: boolean;
-  readonly diagnostics?: readonly string[];
-}): CinematicRendererEvidenceFlag {
-  return {
-    id: input.id,
-    feature: input.feature,
-    label: input.label,
-    source: input.source ?? "renderer-scene",
-    rendererOwned: true,
-    sceneContent: input.sceneContent ?? true,
-    domOverlay: false,
-    satisfiesPublicCinematicGate: true,
-    diagnostics: input.diagnostics ?? []
-  };
-}
-
-export function createDomOverlayEvidenceFlag(input: {
-  readonly id: string;
-  readonly feature: CinematicEvidenceFeature;
-  readonly label: string;
-  readonly source?: "dom-overlay" | "css-overlay";
-  readonly diagnostics?: readonly string[];
-}): CinematicRendererEvidenceFlag {
-  return {
-    id: input.id,
-    feature: input.feature,
-    label: input.label,
-    source: input.source ?? "dom-overlay",
-    rendererOwned: false,
-    sceneContent: false,
-    domOverlay: true,
-    satisfiesPublicCinematicGate: false,
-    diagnostics: input.diagnostics ?? ["DOM/CSS overlays are diagnostic UI only and do not satisfy public cinematic scene evidence."]
-  };
-}
-
-export function validateRendererOwnedCinematicEvidence(
-  flags: readonly CinematicRendererEvidenceFlag[],
-  requiredFeatures: readonly CinematicEvidenceFeature[]
-): CinematicRendererEvidenceValidation {
-  const rendererOwnedFeatures = unique(flags.filter((flag) => flag.rendererOwned && flag.satisfiesPublicCinematicGate).map((flag) => flag.feature));
-  const overlayOnlyFeatures = requiredFeatures.filter((feature) => {
-    const featureFlags = flags.filter((flag) => flag.feature === feature);
-    return featureFlags.length > 0 && featureFlags.every((flag) => flag.domOverlay || !flag.rendererOwned);
-  });
-  const missingRendererOwnedFeatures = requiredFeatures.filter((feature) => !rendererOwnedFeatures.includes(feature));
-  if (missingRendererOwnedFeatures.length > 0 || overlayOnlyFeatures.length > 0) {
-    return {
-      ok: false,
-      code: "AURA_CINEMATIC_DOM_OVERLAY_EVIDENCE_REJECTED",
-      missingRendererOwnedFeatures,
-      overlayOnlyFeatures,
-      diagnostics: [
-        "Required cinematic proof must come from renderer-owned scene, material, lighting, VFX, postprocess, camera, timeline, or blocking data.",
-        ...overlayOnlyFeatures.map((feature) => `${feature} was represented only by DOM/CSS overlay evidence.`)
-      ]
-    };
-  }
-  return {
-    ok: true,
-    rendererOwnedFeatures,
-    diagnostics: ["All required cinematic evidence features are renderer-owned."]
-  };
-}
-
-function unique<T>(values: readonly T[]): readonly T[] {
-  return [...new Set(values)];
-}

package/src/cinematic/CinematicLightingRig.ts

@@ -1,144 +0,0 @@
-import type { EnvironmentLightingOptions } from "../ForwardPass";
-import { createRendererOwnedEvidenceFlag, type CinematicRendererEvidenceFlag } from "./CinematicEvidence";
-
-export type CinematicLightingRigId =
-  | "soft-key-fill-rim"
-  | "moody-alley"
-  | "studio-product"
-  | "warm-sunrise"
-  | "cool-moonlit";
-
-export type CinematicLightRole = "key" | "fill" | "rim" | "practical" | "ambient";
-export type CinematicLightType = "directional" | "point" | "spot" | "ambient";
-
-export interface CinematicRuntimeLight {
-  readonly id: string;
-  readonly role: CinematicLightRole;
-  readonly type: CinematicLightType;
-  readonly color: readonly [number, number, number];
-  readonly intensity: number;
-  readonly position?: readonly [number, number, number];
-  readonly direction?: readonly [number, number, number];
-  readonly castsShadow: boolean;
-}
-
-export interface CinematicLightingRig {
-  readonly id: CinematicLightingRigId;
-  readonly label: string;
-  readonly exposure: number;
-  readonly toneMap: {
-    readonly operator: "filmic" | "aces" | "reinhard";
-    readonly whitePoint: number;
-  };
-  readonly environmentLighting: EnvironmentLightingOptions;
-  readonly lights: readonly CinematicRuntimeLight[];
-  readonly rendererOwnedEvidence: CinematicRendererEvidenceFlag;
-  readonly diagnostics: readonly string[];
-}
-
-export function createCinematicLightingRig(id: CinematicLightingRigId): CinematicLightingRig {
-  const rig = rigWithoutEvidence(id);
-  return {
-    ...rig,
-    rendererOwnedEvidence: createRendererOwnedEvidenceFlag({
-      id: `lighting:${id}`,
-      feature: "lighting",
-      label: rig.label,
-      source: "renderer-light",
-      diagnostics: rig.diagnostics
-    })
-  };
-}
-
-export function listCinematicLightingRigs(): readonly CinematicLightingRig[] {
-  const ids: readonly CinematicLightingRigId[] = ["soft-key-fill-rim", "moody-alley", "studio-product", "warm-sunrise", "cool-moonlit"];
-  return ids.map(createCinematicLightingRig);
-}
-
-export function selectCinematicLightingRig(tags: readonly string[]): CinematicLightingRigId {
-  const lower = tags.map((tag) => tag.toLowerCase());
-  if (lower.some((tag) => tag.includes("alley") || tag.includes("neon") || tag.includes("rain"))) return "moody-alley";
-  if (lower.some((tag) => tag.includes("studio") || tag.includes("product"))) return "studio-product";
-  if (lower.some((tag) => tag.includes("sunrise") || tag.includes("warm") || tag.includes("golden"))) return "warm-sunrise";
-  if (lower.some((tag) => tag.includes("moon") || tag.includes("night") || tag.includes("cool"))) return "cool-moonlit";
-  return "soft-key-fill-rim";
-}
-
-function rigWithoutEvidence(id: CinematicLightingRigId): Omit<CinematicLightingRig, "rendererOwnedEvidence"> {
-  switch (id) {
-    case "moody-alley":
-      return makeRig(id, "Moody alley", 1.24, [0.035, 0.045, 0.07], 0.34, [
-        light("alley-key", "key", "spot", [0.42, 0.58, 1], 2.2, [-2.4, 3.6, 2.2], [0.45, -0.72, -0.52], true),
-        light("alley-rim", "rim", "point", [0.04, 0.86, 1], 3.4, [1.8, 1.2, -1.4], undefined, true),
-        light("alley-practical-neon", "practical", "point", [1, 0.08, 0.62], 2.8, [-1.6, 1.7, -2.1], undefined, false)
-      ], ["Moody alley rig includes key, rim, and practical light metadata compiled for the renderer."]);
-    case "studio-product":
-      return makeRig(id, "Studio product", 1.08, [0.78, 0.8, 0.84], 0.54, [
-        light("studio-key", "key", "directional", [1, 0.95, 0.88], 1.8, undefined, [0.4, -0.7, -0.58], true),
-        light("studio-fill", "fill", "directional", [0.62, 0.72, 1], 0.7, undefined, [-0.5, -0.35, -0.8], false),
-        light("studio-rim", "rim", "directional", [1, 1, 1], 0.9, undefined, [0.12, -0.2, 0.97], false)
-      ], ["Studio product rig uses renderer light records, not CSS panel highlights."]);
-    case "warm-sunrise":
-      return makeRig(id, "Warm sunrise", 1.16, [0.9, 0.58, 0.32], 0.48, [
-        light("sunrise-key", "key", "directional", [1, 0.58, 0.28], 2.05, undefined, [0.62, -0.52, -0.58], true),
-        light("sunrise-fill", "fill", "ambient", [0.28, 0.36, 0.55], 0.32, undefined, undefined, false),
-        light("sunrise-rim", "rim", "directional", [1, 0.86, 0.52], 0.78, undefined, [-0.12, -0.28, 0.95], false)
-      ], ["Warm sunrise is an analytic renderer lighting preset."]);
-    case "cool-moonlit":
-      return makeRig(id, "Cool moonlit", 1.32, [0.2, 0.28, 0.48], 0.38, [
-        light("moon-key", "key", "directional", [0.48, 0.62, 1], 1.35, undefined, [0.24, -0.62, -0.74], true),
-        light("moon-fill", "fill", "ambient", [0.08, 0.12, 0.2], 0.24, undefined, undefined, false),
-        light("moon-rim", "rim", "directional", [0.62, 0.86, 1], 0.92, undefined, [-0.22, -0.14, 0.96], false)
-      ], ["Cool moonlit rig remains renderer-owned lighting evidence."]);
-    case "soft-key-fill-rim":
-      return makeRig(id, "Soft key fill rim", 1.12, [0.52, 0.58, 0.66], 0.45, [
-        light("soft-key", "key", "directional", [1, 0.92, 0.82], 1.55, undefined, [0.42, -0.62, -0.66], true),
-        light("soft-fill", "fill", "directional", [0.46, 0.58, 0.82], 0.46, undefined, [-0.46, -0.28, -0.84], false),
-        light("soft-rim", "rim", "directional", [0.7, 0.88, 1], 0.72, undefined, [0.08, -0.28, 0.96], false)
-      ], ["Soft three-point rig supplies key/fill/rim renderer lights."]);
-  }
-}
-
-function makeRig(
-  id: CinematicLightingRigId,
-  label: string,
-  exposure: number,
-  color: readonly [number, number, number],
-  intensity: number,
-  lights: readonly CinematicRuntimeLight[],
-  diagnostics: readonly string[]
-): Omit<CinematicLightingRig, "rendererOwnedEvidence"> {
-  return {
-    id,
-    label,
-    exposure,
-    toneMap: { operator: "filmic", whitePoint: id === "cool-moonlit" ? 1.05 : 1.22 },
-    environmentLighting: {
-      color,
-      intensity,
-      proceduralMap: {
-        skyColor: [color[0] * 0.9, color[1] * 0.95, Math.min(1, color[2] * 1.15)],
-        horizonColor: [Math.min(1, color[0] * 1.2), Math.min(1, color[1] * 1.1), color[2]],
-        groundColor: [0.04, 0.045, 0.05],
-        specularColor: [1, 0.95, 0.86],
-        intensity,
-        specularIntensity: Math.min(1, intensity + 0.28)
-      }
-    },
-    lights,
-    diagnostics
-  };
-}
-
-function light(
-  id: string,
-  role: CinematicLightRole,
-  type: CinematicLightType,
-  color: readonly [number, number, number],
-  intensity: number,
-  position: readonly [number, number, number] | undefined,
-  direction: readonly [number, number, number] | undefined,
-  castsShadow: boolean
-): CinematicRuntimeLight {
-  return { id, role, type, color, intensity, position, direction, castsShadow };
-}