@laplace.live/persona-sdk 1.8.1 → 1.9.0

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export * from './values/model-info.ts';
 export * from './values/scene-transition.ts';
 export * from './values/stage-info.ts';
 export * from './values/terms.ts';
+export * from './values/volumetric-lighting.ts';
 export * from './values/vrm-bindings.ts';
 export * from './wire/envelope.ts';
 export * from './wire/errors.ts';

package/dist/index.js

@@ -21,6 +21,7 @@ export * from "./values/model-info.js";
 export * from "./values/scene-transition.js";
 export * from "./values/stage-info.js";
 export * from "./values/terms.js";
+export * from "./values/volumetric-lighting.js";
 export * from "./values/vrm-bindings.js";
 export * from "./wire/envelope.js";
 export * from "./wire/errors.js";

package/dist/values/controller.d.ts

@@ -75,6 +75,11 @@ export interface ControllerMovementConfig {
     /** Turn a VRM avatar toward its movement direction. */
     faceMovement: boolean;
 }
+export declare const CONTROLLER_MOVE_SPEED_MAX = 10;
+export declare const CONTROLLER_TURN_SPEED_MAX = 720;
+export declare const CONTROLLER_MOVEMENT_SMOOTHING_MAX = 0.5;
+export declare const CONTROLLER_WALK_SPEED_MIN = 0.1;
+export declare const CONTROLLER_WALK_SPEED_MAX = 10;
 export declare const DEFAULT_CONTROLLER_MOVEMENT: Readonly<ControllerMovementConfig>;
 /** Heal saved movement or a merged API patch using the same limits as the controls. */
 export declare function healControllerMovement(raw: unknown): ControllerMovementConfig;

package/dist/values/controller.js

@@ -114,9 +114,11 @@ export function controllerSlot(full) {
         ? parts.slot
         : null;
 }
-const CONTROLLER_MOVE_SPEED_MAX = 10;
-const CONTROLLER_TURN_SPEED_MAX = 720;
-const CONTROLLER_MOVEMENT_SMOOTHING_MAX = 0.5;
+export const CONTROLLER_MOVE_SPEED_MAX = 10;
+export const CONTROLLER_TURN_SPEED_MAX = 720;
+export const CONTROLLER_MOVEMENT_SMOOTHING_MAX = 0.5;
+export const CONTROLLER_WALK_SPEED_MIN = 0.1;
+export const CONTROLLER_WALK_SPEED_MAX = 10;
 export const DEFAULT_CONTROLLER_MOVEMENT = {
     enabled: false,
     slot: 1,
@@ -140,7 +142,7 @@ export function healControllerMovement(raw) {
         smoothing: clamp(finiteOr(r.smoothing, d.smoothing), 0, CONTROLLER_MOVEMENT_SMOOTHING_MAX),
         walkEnabled: typeof r.walkEnabled === 'boolean' ? r.walkEnabled : d.walkEnabled,
         walkClip: nonEmptyString(r.walkClip),
-        walkSpeed: clamp(finiteOr(r.walkSpeed, d.walkSpeed), 0.1, 10),
+        walkSpeed: clamp(finiteOr(r.walkSpeed, d.walkSpeed), CONTROLLER_WALK_SPEED_MIN, CONTROLLER_WALK_SPEED_MAX),
         faceMovement: typeof r.faceMovement === 'boolean' ? r.faceMovement : d.faceMovement,
     };
 }

package/dist/values/gltf-extensions.d.ts

@@ -4,7 +4,7 @@ export type GltfLoadPath = 'vrm' | 'gltf';
 export declare const LAPLACE_OUTFIT = "LAPLACE_outfit";
 /** The app's room extension, read on props and sets — `renderer/vrm/gltf-extension.ts`. */
 export declare const LAPLACE_ENVIRONMENT = "LAPLACE_environment";
-/** `GLTFLoader` extensions that throw at parse without a decoder — and the app sets none. */
+/** `GLTFLoader` extensions needing a decoder the app doesn't set. */
 export declare const DECODER_EXTENSIONS: string[];
 /** Per loader; the app's own extensions ride with the loader that reads them. */
 export declare const SUPPORTED_EXTENSIONS: Record<GltfLoadPath, ReadonlySet<string>>;

package/dist/values/gltf-extensions.js

@@ -15,16 +15,12 @@ const VRM_EXTENSIONS = [
     'VRMC_materials_mtoon',
     'VRMC_materials_hdr_emissiveMultiplier',
 ];
-/** `GLTFLoader` extensions that throw at parse without a decoder — and the app sets none. */
-export const DECODER_EXTENSIONS = [
-    'KHR_draco_mesh_compression',
-    'KHR_texture_basisu',
-    'EXT_meshopt_compression',
-    'KHR_meshopt_compression',
-];
+/** `GLTFLoader` extensions needing a decoder the app doesn't set. */
+export const DECODER_EXTENSIONS = ['KHR_texture_basisu'];
 /** The rest of `GLTFLoader`'s own `EXTENSIONS` table, which either loader renders as authored. */
 const RENDERABLE = [
     'KHR_binary_glTF',
+    'KHR_draco_mesh_compression',
     'KHR_lights_punctual',
     'KHR_materials_clearcoat',
     'KHR_materials_dispersion',
@@ -42,6 +38,8 @@ const RENDERABLE = [
     'EXT_materials_bump',
     'EXT_texture_webp',
     'EXT_texture_avif',
+    'EXT_meshopt_compression',
+    'KHR_meshopt_compression',
     'EXT_mesh_gpu_instancing',
 ];
 /** Per loader; the app's own extensions ride with the loader that reads them. */

package/dist/values/limits.d.ts

@@ -6,7 +6,7 @@ export declare function clamp01(v: number): number;
 export declare function wrapAngle(a: number): number;
 export declare const DEFAULT_LIVE2D_PLACEMENT: ScreenPlacement;
 export declare const DEFAULT_VRM_PLACEMENT: VrmPlacement;
-/** Scene colors heal to 6-digit hex. */
+/** Scene colors heal to 6-digit hex; both cases are spelled out because JSON Schema patterns carry no flags. */
 export declare const SCENE_COLOR_RE: RegExp;
 /** The value when it is a 6-digit hex color, else `fallback` — validated, never clamped. */
 export declare function hexColorOr(v: unknown, fallback: string): string;
@@ -14,13 +14,24 @@ export declare function hexColorOr(v: unknown, fallback: string): string;
 export declare function opaqueHex(hex: string): string;
 export declare const SCENE_LIGHT_INTENSITY_MAX = 2;
 /**
- * Point lights decay physically (1/d²), so reach rides on power the way Blender's
- * does: 20 stays visible to ~10 m where 2 self-extinguishes by ~5. The other
- * types have no falloff to overcome — 20 would just blow the stage out.
+ * Point lights need headroom against inverse-square decay; directional and ambient
+ * lights have no falloff and would wash out the stage at the same intensity.
  */
 export declare const SCENE_LIGHT_POINT_INTENSITY_MAX = 20;
-/** Intensity ceiling for a light of `type` — one source for the slider and scene healing. */
+export declare const SCENE_LIGHT_AREA_SIZE_MIN = 0.01;
+export declare const SCENE_LIGHT_AREA_SIZE_MAX = 20;
+export declare const DEFAULT_AREA_LIGHT_SIZE = 1;
+export declare const SCENE_LIGHT_SPOT_ANGLE_MIN = 1;
+/** A 90° half-angle would make the spot shadow camera's 180° projection singular. */
+export declare const SCENE_LIGHT_SPOT_ANGLE_MAX = 89;
+export declare const DEFAULT_SPOT_ANGLE_DEG = 30;
+export declare const DEFAULT_SPOT_PENUMBRA = 0.3;
+/** Positional lights need falloff headroom; the slider and scene healing share this ceiling. */
 export declare function sceneLightIntensityMax(type: SceneLightType): number;
+/** Whether a light of `type` aims with azimuth/elevation. */
+export declare function sceneLightIsAimed(type: SceneLightType): boolean;
+/** Whether a light of `type` can cast shadows; ambient and area lights never do. */
+export declare function sceneLightCastsShadows(type: SceneLightType): boolean;
 export declare const LIVE2D_SCALE_MIN = 0.1;
 export declare const LIVE2D_SCALE_MAX = 24;
 export declare const VRM_SCALE_MIN = 0.05;
@@ -30,6 +41,8 @@ export declare const SCENE_LIGHT_RANGE_MAX = 20;
 export declare const SCENE_LIGHT_SHADOW_RADIUS_MAX = 16;
 /** The point disk's 32 fixed taps stay dense across a far wider penumbra than 5 dithered ones. */
 export declare const SCENE_LIGHT_POINT_SHADOW_RADIUS_MAX = 32;
+export declare const SCENE_LIGHT_SHADOW_SOURCE_SIZE_MAX = 10;
+export declare const DEFAULT_LIGHT_SHADOW_SOURCE_SIZE = 0.1;
 /** Shadow softness (PCF disk radius, in shadow-map texels) ceiling for a light of `type`. */
 export declare function sceneLightShadowRadiusMax(type: SceneLightType): number;
 /**
@@ -107,8 +120,9 @@ export declare function environmentLookIsUntouched(env: SceneEnvironment, refere
  *
  * {@link SceneEnvironment.iblAssetId} and {@link SceneEnvironment.modelAssetId} are a
  * single slot — a scene wears an equirect map or a 3D set — so this clears whichever
- * the pick is not. `bakeFromModel` goes with the set: it outlives the id it names, and
- * it wins over a picked map, so a stale one would leave a fresh map lighting nothing.
+ * the pick is not. `bakeFromModel` goes with the set: on for a set arriving where none was,
+ * kept across a swap, dropped otherwise — it wins over a picked map, so a stale one would
+ * leave a fresh map lighting nothing.
  * Light overrides index the set's own lamps, so a different set — or none — drops them.
  * `modelLook` stays put: the stage replaces it as the next set parses, and the desktop
  * reads the outgoing one as what the scene wears now when deciding to adopt the next.

package/dist/values/limits.js

@@ -18,8 +18,8 @@ export function wrapAngle(a) {
 }
 export const DEFAULT_LIVE2D_PLACEMENT = { x: 0, y: 0, scale: 1, rotation: 0 };
 export const DEFAULT_VRM_PLACEMENT = { x: 0, y: 0, z: 0, rotX: 0, rotY: 0, rotZ: 0, scale: 1 };
-/** Scene colors heal to 6-digit hex. */
-export const SCENE_COLOR_RE = /^#[0-9a-f]{6}$/i;
+/** Scene colors heal to 6-digit hex; both cases are spelled out because JSON Schema patterns carry no flags. */
+export const SCENE_COLOR_RE = /^#[0-9a-fA-F]{6}$/;
 /** The value when it is a 6-digit hex color, else `fallback` — validated, never clamped. */
 export function hexColorOr(v, fallback) {
     return typeof v === 'string' && SCENE_COLOR_RE.test(v) ? v : fallback;
@@ -30,14 +30,29 @@ export function opaqueHex(hex) {
 }
 export const SCENE_LIGHT_INTENSITY_MAX = 2;
 /**
- * Point lights decay physically (1/d²), so reach rides on power the way Blender's
- * does: 20 stays visible to ~10 m where 2 self-extinguishes by ~5. The other
- * types have no falloff to overcome — 20 would just blow the stage out.
+ * Point lights need headroom against inverse-square decay; directional and ambient
+ * lights have no falloff and would wash out the stage at the same intensity.
  */
 export const SCENE_LIGHT_POINT_INTENSITY_MAX = 20;
-/** Intensity ceiling for a light of `type` — one source for the slider and scene healing. */
+export const SCENE_LIGHT_AREA_SIZE_MIN = 0.01;
+export const SCENE_LIGHT_AREA_SIZE_MAX = 20;
+export const DEFAULT_AREA_LIGHT_SIZE = 1;
+export const SCENE_LIGHT_SPOT_ANGLE_MIN = 1;
+/** A 90° half-angle would make the spot shadow camera's 180° projection singular. */
+export const SCENE_LIGHT_SPOT_ANGLE_MAX = 89;
+export const DEFAULT_SPOT_ANGLE_DEG = 30;
+export const DEFAULT_SPOT_PENUMBRA = 0.3;
+/** Positional lights need falloff headroom; the slider and scene healing share this ceiling. */
 export function sceneLightIntensityMax(type) {
-    return type === 'point' ? SCENE_LIGHT_POINT_INTENSITY_MAX : SCENE_LIGHT_INTENSITY_MAX;
+    return type === 'directional' || type === 'ambient' ? SCENE_LIGHT_INTENSITY_MAX : SCENE_LIGHT_POINT_INTENSITY_MAX;
+}
+/** Whether a light of `type` aims with azimuth/elevation. */
+export function sceneLightIsAimed(type) {
+    return type === 'directional' || type === 'spot' || type === 'area';
+}
+/** Whether a light of `type` can cast shadows; ambient and area lights never do. */
+export function sceneLightCastsShadows(type) {
+    return type !== 'ambient' && type !== 'area';
 }
 // Live2D bounds are the zoom clamp (zoom.ts re-exports these); VRM scales a world-space root.
 export const LIVE2D_SCALE_MIN = 0.1;
@@ -51,6 +66,8 @@ export const SCENE_LIGHT_RANGE_MAX = 20;
 export const SCENE_LIGHT_SHADOW_RADIUS_MAX = 16;
 /** The point disk's 32 fixed taps stay dense across a far wider penumbra than 5 dithered ones. */
 export const SCENE_LIGHT_POINT_SHADOW_RADIUS_MAX = 32;
+export const SCENE_LIGHT_SHADOW_SOURCE_SIZE_MAX = 10;
+export const DEFAULT_LIGHT_SHADOW_SOURCE_SIZE = 0.1;
 /** Shadow softness (PCF disk radius, in shadow-map texels) ceiling for a light of `type`. */
 export function sceneLightShadowRadiusMax(type) {
     return type === 'point' ? SCENE_LIGHT_POINT_SHADOW_RADIUS_MAX : SCENE_LIGHT_SHADOW_RADIUS_MAX;
@@ -116,16 +133,23 @@ export function defaultSceneLightOf(type) {
         color: '#ffffff',
         // Ambient is a flat albedo floor with no shading — 1.0 alone washes the model out.
         intensity: type === 'ambient' ? 0.4 : 1,
-        azimuth: DEFAULT_LIGHT_AZIMUTH_DEG,
-        elevation: DEFAULT_LIGHT_ELEVATION_DEG,
+        azimuth: type === 'area' || type === 'spot' ? 0 : DEFAULT_LIGHT_AZIMUTH_DEG,
+        elevation: type === 'area' || type === 'spot' ? 0 : DEFAULT_LIGHT_ELEVATION_DEG,
         x: 0,
         y: 1.4,
         z: 1,
         range: 10,
+        angle: DEFAULT_SPOT_ANGLE_DEG,
+        penumbra: DEFAULT_SPOT_PENUMBRA,
+        width: DEFAULT_AREA_LIGHT_SIZE,
+        height: DEFAULT_AREA_LIGHT_SIZE,
+        roll: 0,
         // A point light shadow is six cube faces, so it stays opt-in where a
         // directional light's single depth pass can be on by default.
         shadowQuality: type === 'directional' ? 'high' : 'off',
         shadowRadius: 6,
+        shadowFilter: 'pcf',
+        shadowSourceSize: DEFAULT_LIGHT_SHADOW_SOURCE_SIZE,
     };
 }
 /**
@@ -190,8 +214,9 @@ export function environmentLookIsUntouched(env, reference) {
  *
  * {@link SceneEnvironment.iblAssetId} and {@link SceneEnvironment.modelAssetId} are a
  * single slot — a scene wears an equirect map or a 3D set — so this clears whichever
- * the pick is not. `bakeFromModel` goes with the set: it outlives the id it names, and
- * it wins over a picked map, so a stale one would leave a fresh map lighting nothing.
+ * the pick is not. `bakeFromModel` goes with the set: on for a set arriving where none was,
+ * kept across a swap, dropped otherwise — it wins over a picked map, so a stale one would
+ * leave a fresh map lighting nothing.
  * Light overrides index the set's own lamps, so a different set — or none — drops them.
  * `modelLook` stays put: the stage replaces it as the next set parses, and the desktop
  * reads the outgoing one as what the scene wears now when deciding to adopt the next.
@@ -204,7 +229,7 @@ export function environmentWithAsset(env, asset) {
         ...env,
         iblAssetId: asset !== null && !isSet ? asset.id : null,
         modelAssetId,
-        bakeFromModel: isSet && env.bakeFromModel,
+        bakeFromModel: isSet && (env.modelAssetId === null || env.bakeFromModel),
         modelLightOverrides: modelAssetId === env.modelAssetId ? env.modelLightOverrides : {},
     };
 }

package/dist/values/volumetric-lighting.d.ts

@@ -0,0 +1,42 @@
+import { type SceneEnvironment, type SceneVolumetricLighting } from '../wire/types.ts';
+/** Slider and healing metadata for the haze's numeric settings. */
+export declare const SCENE_VOLUMETRIC_LIGHTING_SPECS: {
+    readonly density: {
+        readonly default: 1;
+        readonly min: 0;
+        readonly max: 10;
+        readonly step: 0.05;
+        readonly digits: 2;
+    };
+    readonly intensity: {
+        readonly default: 1;
+        readonly min: 0;
+        readonly max: 10;
+        readonly step: 0.05;
+        readonly digits: 2;
+    };
+    readonly range: {
+        readonly default: 20;
+        readonly min: 1;
+        readonly max: 100;
+        readonly step: 1;
+        readonly digits: 0;
+    };
+    readonly speed: {
+        readonly default: 0.2;
+        readonly min: 0;
+        readonly max: 5;
+        readonly step: 0.05;
+        readonly digits: 2;
+    };
+};
+/** Existing scenes retain clear air until volumetric lighting is enabled. */
+export declare function defaultSceneVolumetricLighting(): SceneVolumetricLighting;
+/** Restore saved haze settings and clamp them to the shared editor bounds. */
+export declare function healSceneVolumetricLighting(raw: unknown): SceneVolumetricLighting;
+/** An environment edit whose haze settings arrive as leaves, so queued edits never replace one another. */
+export type EnvironmentPatch = Omit<Partial<SceneEnvironment>, 'volumetricLighting'> & {
+    volumetricLighting?: Partial<SceneVolumetricLighting>;
+};
+/** Merge `patch` into `target` in place; haze leaves land in the settings object `target` already holds. */
+export declare function mergeEnvironmentPatch(target: EnvironmentPatch, { volumetricLighting, ...fields }: EnvironmentPatch): void;

package/dist/values/volumetric-lighting.js

@@ -0,0 +1,43 @@
+import { EFFECTS_QUALITY_LEVELS } from "../wire/types.js";
+import { finiteOr, isOneOf, isRecord } from "./guards.js";
+import { clamp } from "./limits.js";
+/** Slider and healing metadata for the haze's numeric settings. */
+export const SCENE_VOLUMETRIC_LIGHTING_SPECS = {
+    density: { default: 1, min: 0, max: 10, step: 0.05, digits: 2 },
+    intensity: { default: 1, min: 0, max: 10, step: 0.05, digits: 2 },
+    range: { default: 20, min: 1, max: 100, step: 1, digits: 0 },
+    speed: { default: 0.2, min: 0, max: 5, step: 0.05, digits: 2 },
+};
+/** Existing scenes retain clear air until volumetric lighting is enabled. */
+export function defaultSceneVolumetricLighting() {
+    const specs = SCENE_VOLUMETRIC_LIGHTING_SPECS;
+    return {
+        enabled: false,
+        density: specs.density.default,
+        intensity: specs.intensity.default,
+        range: specs.range.default,
+        quality: 'medium',
+        speed: specs.speed.default,
+    };
+}
+/** Restore saved haze settings and clamp them to the shared editor bounds. */
+export function healSceneVolumetricLighting(raw) {
+    const d = defaultSceneVolumetricLighting();
+    if (!isRecord(raw))
+        return d;
+    const specs = SCENE_VOLUMETRIC_LIGHTING_SPECS;
+    return {
+        enabled: typeof raw.enabled === 'boolean' ? raw.enabled : d.enabled,
+        density: clamp(finiteOr(raw.density, d.density), specs.density.min, specs.density.max),
+        intensity: clamp(finiteOr(raw.intensity, d.intensity), specs.intensity.min, specs.intensity.max),
+        range: clamp(finiteOr(raw.range, d.range), specs.range.min, specs.range.max),
+        quality: isOneOf(raw.quality, EFFECTS_QUALITY_LEVELS) ? raw.quality : d.quality,
+        speed: clamp(finiteOr(raw.speed, d.speed), specs.speed.min, specs.speed.max),
+    };
+}
+/** Merge `patch` into `target` in place; haze leaves land in the settings object `target` already holds. */
+export function mergeEnvironmentPatch(target, { volumetricLighting, ...fields }) {
+    Object.assign(target, fields);
+    if (volumetricLighting)
+        target.volumetricLighting = Object.assign(target.volumetricLighting ?? {}, volumetricLighting);
+}

package/dist/wire/types.d.ts

@@ -330,7 +330,8 @@ export interface SceneCamera {
  * the clip: applying a pose leaves whatever camera motion the scene has running.
  */
 export type CameraPose = Pick<SceneCamera, 'orbit' | 'fov' | 'roll' | 'projection'>;
-export type SceneLightType = 'directional' | 'point' | 'ambient';
+export declare const SCENE_LIGHT_TYPES: readonly ["directional", "point", "ambient", "area", "spot"];
+export type SceneLightType = (typeof SCENE_LIGHT_TYPES)[number];
 /**
  * Per-light shadow tier. `off` is the old `castShadow: false`; the rest raise
  * shadow-map resolution. A point light pays 6 cube faces for the same tier a
@@ -338,11 +339,15 @@ export type SceneLightType = 'directional' | 'point' | 'ambient';
  */
 export declare const SHADOW_QUALITY_LEVELS: readonly ["off", "low", "medium", "high", "ultra"];
 export type ShadowQuality = (typeof SHADOW_QUALITY_LEVELS)[number];
+export declare const SHADOW_FILTERS: readonly ["pcf", "pcss"];
+export type ShadowFilter = (typeof SHADOW_FILTERS)[number];
 /**
  * One scene light. Angles are degrees. Directional lights aim with
  * azimuth/elevation and sit at x/y/z (which moves their handle and shadow
  * coverage, not their parallel shading), point lights use x/y/z + range,
- * ambient uses none — all fields stay so a type switch keeps them.
+ * spot adds azimuth/elevation, angle and penumbra to point's fields;
+ * area uses x/y/z, azimuth/elevation/roll and width/height; ambient uses none.
+ * All fields stay so a type switch keeps them. Area lights affect PBR and MToon materials.
  */
 export interface SceneLight {
     id: string;
@@ -357,10 +362,23 @@ export interface SceneLight {
     y: number;
     z: number;
     range: number;
-    /** Ambient light is directionless, so it never casts whatever this says. */
+    /** Spot cone half-angle in degrees, 1–89; omitted values default to 30. */
+    angle?: number;
+    /** Spot cone edge softness, 0–1; omitted values default to 0.3. */
+    penumbra?: number;
+    /** Rectangular area light dimensions in metres; omitted values default to 1. */
+    width?: number;
+    height?: number;
+    /** Area light rotation in its rectangle's plane, in degrees; defaults to 0. */
+    roll?: number;
+    /** Ambient and area lights never cast shadows. */
     shadowQuality: ShadowQuality;
-    /** Penumbra width in shadow-map texels — a stylistic dial; the filter widens the edge uniformly. */
+    /** PCF disk radius in shadow-map texels; retained while PCSS is selected. */
     shadowRadius: number;
+    /** Per-light filter; defaults to PCF. Gate editing on the `shadow-filters` app capability. */
+    shadowFilter?: ShadowFilter;
+    /** PCSS source diameter: degrees for directional lights, metres for point/spot; 0–10, default 0.1. */
+    shadowSourceSize?: number;
 }
 /** Distance haze. Only geometry fogs — empty space keeps the window's transparency. */
 export interface SceneFog {
@@ -369,6 +387,16 @@ export interface SceneFog {
     /** Exponential-squared falloff; the useful band is well under 1 at avatar scale. */
     density: number;
 }
+/** Illuminated haze in the 3D stage; rendered only by perspective cameras. */
+export interface SceneVolumetricLighting {
+    enabled: boolean;
+    density: number;
+    intensity: number;
+    /** Distance from the camera in scene units. */
+    range: number;
+    quality: EffectsQuality;
+    speed: number;
+}
 /** Display transform applied after the scene renders. `none` keeps colors exactly as authored. */
 export type SceneToneMapping = 'none' | 'neutral' | 'aces' | 'agx';
 /** Highlight glow in normal, streak, or star mode; color selection applies only to layer effects. */
@@ -849,6 +877,10 @@ export interface SceneEnvironment {
     /** The set's suggested look, captured when the model was picked; null when it carries none. */
     modelLook: EnvironmentLook | null;
     fog: SceneFog;
+    /** Omitted by hosts without volumetric lighting support. */
+    volumetricLighting?: SceneVolumetricLighting;
+    /** Optimize unshadowed point lights on supported renderers; omitted by older hosts. */
+    clusteredLighting?: boolean;
     effects: SceneEffects;
     /**
      * Built-in effects added as layers, in registry order — one keeps its row and tuning while
@@ -908,7 +940,7 @@ export interface ScenePatch {
  * App-level features a client gates on (never version-sniff): `hello` and
  * `app.info` report them — the per-app mirror of {@link InstanceRuntime.capabilities}.
  */
-export declare const APP_CAPABILITIES: readonly ["storage", "speech", "automations", "controllers", "model-editing", "asset-inspection", "layer-effects", "scene-transitions"];
+export declare const APP_CAPABILITIES: readonly ["storage", "speech", "automations", "controllers", "model-editing", "asset-inspection", "layer-effects", "scene-transitions", "area-lights", "spot-lights", "shadow-filters"];
 export type AppCapability = (typeof APP_CAPABILITIES)[number];
 export declare function isAppCapability(v: unknown): v is AppCapability;
 /** What a loaded model instance can do; absent capabilities answer `unsupported-for-format`. */

package/dist/wire/types.js

@@ -18,12 +18,14 @@ export function isAssetKind(v) {
 }
 // ---- Objects -------------------------------------------------------------------
 export const OBJECT_SPACES = ['2d', '3d'];
+export const SCENE_LIGHT_TYPES = ['directional', 'point', 'ambient', 'area', 'spot'];
 /**
  * Per-light shadow tier. `off` is the old `castShadow: false`; the rest raise
  * shadow-map resolution. A point light pays 6 cube faces for the same tier a
  * directional light covers with one map, so it gets the smaller of the pair.
  */
 export const SHADOW_QUALITY_LEVELS = ['off', 'low', 'medium', 'high', 'ultra'];
+export const SHADOW_FILTERS = ['pcf', 'pcss'];
 // ---- Runtime state -------------------------------------------------------------
 /**
  * App-level features a client gates on (never version-sniff): `hello` and
@@ -38,6 +40,9 @@ export const APP_CAPABILITIES = [
     'asset-inspection',
     'layer-effects',
     'scene-transitions',
+    'area-lights',
+    'spot-lights',
+    'shadow-filters',
 ];
 export function isAppCapability(v) {
     return isOneOf(v, APP_CAPABILITIES);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laplace.live/persona-sdk",
-  "version": "1.8.1",
+  "version": "1.9.0",
   "description": "TypeScript SDK and wire schema for the LAPLACE Persona plugin API",
   "license": "MIT",
   "type": "module",