@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.1

package/node_modules/@fps-games/playable-rendering/dist/shadow-map-experiment.d.ts

@@ -0,0 +1,167 @@
+export declare const FPS_SHADOW_MAP_EXPERIMENT_PLUGIN_ID: "fps.shadow-map-experiment";
+export declare const FPS_SHADOW_MAP_EXPERIMENT_CONFIG_SCHEMA_VERSION: 1;
+export declare const FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION_V2: 2;
+export declare const FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION: 3;
+export declare const FPS_SHADOW_MAP_EXPERIMENT_SCHEMA_VERSION: 1;
+export type ShadowMapExperimentResolution = 512 | 1024 | 2048 | 4096;
+export type ShadowMapExperimentCascadeCount = 1 | 2 | 4;
+export type ShadowMapExperimentFilter = 'hard' | 'low-pcf';
+export type ShadowMapExperimentUpdateClass = 'static' | 'dynamic' | 'skinned';
+export type ShadowMapExperimentBehaviorUpdateClass = 'auto' | ShadowMapExperimentUpdateClass;
+export type ShadowMapExperimentBackendMode = 'auto' | 'split' | 'single';
+export type ShadowMapExperimentBackendFallback = 'single-map' | 'disable';
+export type ShadowMapExperimentLifecycleState = 'pending' | 'active' | 'suspended' | 'disposed';
+export type ShadowMapExperimentActivityKind = 'transform' | 'animation' | 'morph' | 'physics';
+export type ShadowMapExperimentDirtyReason = 'generator-created' | 'compositor-ready' | 'light-direction-changed' | 'light-bounds-changed' | 'quality-changed' | 'caster-added' | 'caster-removed' | 'caster-visibility-changed' | 'static-transform-changed' | 'dynamic-transform-changed' | 'static-geometry-changed' | 'material-alpha-test-changed' | 'caster-activity-started' | 'caster-activity-stopped' | 'dynamic-frame' | 'skinned-animation-frame' | 'morph-animation-frame' | 'physics-motion-frame' | 'camera-influence-region-changed' | 'caster-influence-membership-changed' | 'static-depth-invalidated' | 'dynamic-depth-invalidated' | 'empty-list-clear';
+export interface EditorShadowMapExperimentBounds {
+    readonly mode: 'fixed';
+    readonly center: readonly [number, number, number];
+    readonly extent: readonly [number, number, number];
+    readonly near: number;
+    readonly far: number;
+}
+export interface ShadowMapExperimentMapSettings {
+    readonly staticResolution: ShadowMapExperimentResolution;
+    readonly dynamicResolution: ShadowMapExperimentResolution;
+    readonly compositeResolution: ShadowMapExperimentResolution;
+}
+export interface ShadowMapExperimentBackendSettings {
+    readonly mode: ShadowMapExperimentBackendMode;
+    readonly fallback: ShadowMapExperimentBackendFallback;
+}
+export interface ShadowMapExperimentCullingSettings {
+    readonly enabled: boolean;
+    readonly guardBandRatio: number;
+}
+export interface ShadowMapExperimentDiagnosticThresholds {
+    readonly staticCasterCountWarning: number;
+    readonly dynamicCasterCountWarning: number;
+    readonly renderableCountWarning: number;
+}
+export interface ShadowMapExperimentQualityProfile {
+    readonly maps: ShadowMapExperimentMapSettings;
+    /** Compatibility-only legacy metadata; current product backends do not consume it. */
+    readonly cascadeCount?: ShadowMapExperimentCascadeCount;
+    readonly receiverFilter: ShadowMapExperimentFilter;
+    readonly bias: number;
+    readonly normalBias: number;
+    readonly darkness: number;
+    readonly bounds: EditorShadowMapExperimentBounds;
+    readonly backend: ShadowMapExperimentBackendSettings;
+    readonly culling: ShadowMapExperimentCullingSettings;
+    readonly diagnostics: ShadowMapExperimentDiagnosticThresholds;
+}
+export interface ShadowMapExperimentBehaviorProfile {
+    readonly cast: 'enabled' | 'disabled';
+    readonly receive: 'enabled' | 'disabled';
+    readonly updateClass: ShadowMapExperimentBehaviorUpdateClass;
+}
+export interface ShadowMapExperimentConfig {
+    readonly schemaVersion: typeof FPS_SHADOW_MAP_EXPERIMENT_SCHEMA_VERSION;
+    readonly enabled: boolean;
+    readonly lightRef: string;
+    readonly defaultQualityProfile: string;
+    readonly defaultBehaviorProfile: string;
+    readonly qualityProfiles: Readonly<Record<string, ShadowMapExperimentQualityProfile>>;
+    readonly behaviorProfiles: Readonly<Record<string, ShadowMapExperimentBehaviorProfile>>;
+}
+export interface EditorShadowMapExperimentSettings {
+    readonly qualityProfile?: string;
+    readonly behaviorProfile?: string;
+}
+export interface EditorShadowMapExperimentObjectOverride {
+    readonly behaviorProfile: string;
+}
+export interface ShadowMapExperimentDiagnostic {
+    readonly code: string;
+    readonly severity: 'info' | 'warning' | 'error';
+    readonly message: string;
+    readonly entityId?: string;
+    readonly renderableId?: string;
+    readonly details?: Readonly<Record<string, unknown>>;
+}
+export interface ShadowMapExperimentPlanObject {
+    readonly entityId: string;
+    readonly renderableIds: readonly string[];
+    readonly cast: boolean;
+    readonly receive: boolean;
+    readonly updateClass: ShadowMapExperimentUpdateClass;
+    readonly behaviorProfileId: string;
+}
+export interface ShadowMapExperimentBehaviorProfileCatalogEntry {
+    readonly cast: boolean;
+    readonly receive: boolean;
+    readonly updateClass: ShadowMapExperimentBehaviorUpdateClass;
+}
+interface ShadowMapExperimentPlanBase {
+    readonly revision: number;
+    readonly enabled: boolean;
+    readonly scopeId: string;
+    readonly light: {
+        readonly entityId: string;
+        readonly direction: readonly [number, number, number];
+    };
+    readonly qualityProfileId: string;
+    readonly generator: {
+        readonly maps: ShadowMapExperimentMapSettings;
+        /** Compatibility-only legacy metadata; current product backends do not consume it. */
+        readonly cascadeCount?: ShadowMapExperimentCascadeCount;
+        readonly filter: ShadowMapExperimentFilter;
+        readonly bias: number;
+        readonly normalBias: number;
+        readonly darkness: number;
+        readonly bounds: EditorShadowMapExperimentBounds;
+        readonly backend: ShadowMapExperimentBackendSettings;
+    };
+    readonly culling: ShadowMapExperimentCullingSettings;
+    readonly diagnosticThresholds: ShadowMapExperimentDiagnosticThresholds;
+    readonly objects: readonly ShadowMapExperimentPlanObject[];
+    readonly diagnostics: readonly ShadowMapExperimentDiagnostic[];
+}
+/** Legacy rendering-compatible plan. It cannot authorize profile-only runtime registration. */
+export interface ShadowMapExperimentPlanV2 extends ShadowMapExperimentPlanBase {
+    readonly schemaVersion: typeof FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION_V2;
+}
+export interface ShadowMapExperimentPlanV3 extends ShadowMapExperimentPlanBase {
+    readonly schemaVersion: typeof FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION;
+    readonly behaviorProfiles: Readonly<Record<string, ShadowMapExperimentBehaviorProfileCatalogEntry>>;
+}
+export type ShadowMapExperimentPlan = ShadowMapExperimentPlanV2 | ShadowMapExperimentPlanV3;
+export interface ResolveShadowMapExperimentPlanInput {
+    readonly revision: number;
+    readonly scopeId: string;
+    readonly config: ShadowMapExperimentConfig;
+    readonly settings?: EditorShadowMapExperimentSettings;
+    readonly lightDirection: readonly [number, number, number];
+    readonly objects: readonly {
+        readonly entityId: string;
+        readonly renderableIds: readonly string[];
+        readonly override?: EditorShadowMapExperimentObjectOverride;
+        /** Canonical authored override. When omitted, the behavior profile decides. */
+        readonly cast?: boolean;
+        /** Canonical authored override. When omitted, the behavior profile decides. */
+        readonly receive?: boolean;
+        readonly inferredUpdateClass?: ShadowMapExperimentUpdateClass;
+    }[];
+}
+export interface ShadowMapExperimentPlanDelta {
+    readonly fromRevision: number;
+    readonly toRevision: number;
+    readonly generatorChanged: boolean;
+    readonly addedCasters: readonly string[];
+    readonly removedCasters: readonly string[];
+    readonly changedCasters: readonly string[];
+    readonly changedReceivers: readonly string[];
+    readonly requiresRefresh: boolean;
+    readonly dirtyReasons: readonly ShadowMapExperimentDirtyReason[];
+}
+export declare function assertEditorShadowMapExperimentSettings(value: unknown, path?: string): asserts value is EditorShadowMapExperimentSettings;
+export declare function assertEditorShadowMapExperimentObjectOverride(value: unknown, path?: string): asserts value is EditorShadowMapExperimentObjectOverride;
+export declare function assertShadowMapExperimentConfig(value: unknown, path?: string): asserts value is ShadowMapExperimentConfig;
+export declare function createShadowMapExperimentConfigSnapshot(value: unknown): ShadowMapExperimentConfig;
+export declare function resolveShadowMapExperimentPlan(input: ResolveShadowMapExperimentPlanInput): ShadowMapExperimentPlan;
+export declare function createShadowMapExperimentPlanSnapshot(value: unknown): ShadowMapExperimentPlan;
+export declare function createShadowMapExperimentPlanFingerprint(value: unknown): string;
+export declare function diffShadowMapExperimentPlans(previous: ShadowMapExperimentPlan, next: ShadowMapExperimentPlan): ShadowMapExperimentPlanDelta;
+export {};
+//# sourceMappingURL=shadow-map-experiment.d.ts.map

package/node_modules/@fps-games/playable-rendering/dist/shadow-map-experiment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-map-experiment.d.ts","sourceRoot":"","sources":["../src/shadow-map-experiment.ts"],"names":[],"mappings":"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"}

package/node_modules/@fps-games/playable-rendering/dist/shadow-map-experiment.js

@@ -0,0 +1,484 @@
+export const FPS_SHADOW_MAP_EXPERIMENT_PLUGIN_ID = 'fps.shadow-map-experiment';
+export const FPS_SHADOW_MAP_EXPERIMENT_CONFIG_SCHEMA_VERSION = 1;
+export const FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION_V2 = 2;
+export const FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION = 3;
+export const FPS_SHADOW_MAP_EXPERIMENT_SCHEMA_VERSION = FPS_SHADOW_MAP_EXPERIMENT_CONFIG_SCHEMA_VERSION;
+export function assertEditorShadowMapExperimentSettings(value, path = '$.scene.shadowMapExperiment') {
+    const settings = record(value, path);
+    knownFields(settings, ['qualityProfile', 'behaviorProfile'], path);
+    if (settings.qualityProfile !== undefined)
+        nonEmptyString(settings.qualityProfile, `${path}.qualityProfile`);
+    if (settings.behaviorProfile !== undefined)
+        nonEmptyString(settings.behaviorProfile, `${path}.behaviorProfile`);
+}
+export function assertEditorShadowMapExperimentObjectOverride(value, path = '$.shadowMapExperiment') {
+    const override = record(value, path);
+    knownFields(override, ['behaviorProfile'], path);
+    nonEmptyString(override.behaviorProfile, `${path}.behaviorProfile`);
+}
+export function assertShadowMapExperimentConfig(value, path = '$') {
+    const config = record(value, path);
+    knownFields(config, [
+        'schemaVersion',
+        'enabled',
+        'lightRef',
+        'defaultQualityProfile',
+        'defaultBehaviorProfile',
+        'qualityProfiles',
+        'behaviorProfiles',
+    ], path);
+    if (config.schemaVersion !== 1)
+        invalid(`${path}.schemaVersion`, 'expected 1');
+    if (typeof config.enabled !== 'boolean')
+        invalid(`${path}.enabled`, 'expected boolean');
+    nonEmptyString(config.lightRef, `${path}.lightRef`);
+    const defaultQualityProfile = nonEmptyString(config.defaultQualityProfile, `${path}.defaultQualityProfile`);
+    const defaultBehaviorProfile = nonEmptyString(config.defaultBehaviorProfile, `${path}.defaultBehaviorProfile`);
+    const qualityProfiles = profileRecord(config.qualityProfiles, `${path}.qualityProfiles`);
+    const behaviorProfiles = profileRecord(config.behaviorProfiles, `${path}.behaviorProfiles`);
+    for (const [id, profile] of Object.entries(qualityProfiles))
+        assertQualityProfile(profile, `${path}.qualityProfiles.${id}`);
+    for (const [id, profile] of Object.entries(behaviorProfiles))
+        assertBehaviorProfile(profile, `${path}.behaviorProfiles.${id}`);
+    if (!Object.prototype.hasOwnProperty.call(qualityProfiles, defaultQualityProfile)) {
+        invalid(`${path}.defaultQualityProfile`, `unknown quality profile: ${defaultQualityProfile}`);
+    }
+    if (!Object.prototype.hasOwnProperty.call(behaviorProfiles, defaultBehaviorProfile)) {
+        invalid(`${path}.defaultBehaviorProfile`, `unknown behavior profile: ${defaultBehaviorProfile}`);
+    }
+}
+export function createShadowMapExperimentConfigSnapshot(value) {
+    const config = cloneJson(value, '$');
+    assertShadowMapExperimentConfig(config);
+    return deepFreeze(config);
+}
+export function resolveShadowMapExperimentPlan(input) {
+    assertShadowMapExperimentConfig(input.config);
+    if (input.settings !== undefined)
+        assertEditorShadowMapExperimentSettings(input.settings);
+    if (!Number.isInteger(input.revision) || input.revision < 0)
+        invalid('$.revision', 'expected a non-negative integer');
+    const qualityProfileId = input.settings?.qualityProfile ?? input.config.defaultQualityProfile;
+    const sceneBehaviorProfileId = input.settings?.behaviorProfile ?? input.config.defaultBehaviorProfile;
+    const qualityProfile = requireProfile(input.config.qualityProfiles, qualityProfileId, '$.settings.qualityProfile', 'quality');
+    requireProfile(input.config.behaviorProfiles, sceneBehaviorProfileId, '$.settings.behaviorProfile', 'behavior');
+    const resolvedObjects = input.objects.map((object, index) => {
+        const path = `$.objects[${index}]`;
+        if (object.override !== undefined)
+            assertEditorShadowMapExperimentObjectOverride(object.override, `${path}.override`);
+        const behaviorProfileId = object.override?.behaviorProfile ?? sceneBehaviorProfileId;
+        const behaviorProfile = requireProfile(input.config.behaviorProfiles, behaviorProfileId, `${path}.override.behaviorProfile`, 'behavior');
+        return Object.freeze({
+            entityId: nonEmptyString(object.entityId, `${path}.entityId`),
+            renderableIds: Object.freeze(uniqueStrings(object.renderableIds, `${path}.renderableIds`)),
+            cast: optionalBoolean(object.cast, `${path}.cast`) ?? behaviorProfile.cast === 'enabled',
+            receive: optionalBoolean(object.receive, `${path}.receive`) ?? behaviorProfile.receive === 'enabled',
+            updateClass: behaviorProfile.updateClass !== 'auto'
+                ? behaviorProfile.updateClass
+                : object.inferredUpdateClass ?? 'static',
+            behaviorProfileId,
+        });
+    }).sort((left, right) => left.entityId.localeCompare(right.entityId));
+    const objects = input.config.enabled ? resolvedObjects : [];
+    assertUniquePlanObjects(objects);
+    const behaviorProfiles = Object.fromEntries(Object.entries(input.config.behaviorProfiles)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([id, profile]) => [id, Object.freeze({
+            cast: profile.cast === 'enabled',
+            receive: profile.receive === 'enabled',
+            updateClass: profile.updateClass,
+        })]));
+    return deepFreeze({
+        schemaVersion: FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION,
+        revision: input.revision,
+        enabled: input.config.enabled,
+        scopeId: nonEmptyString(input.scopeId, '$.scopeId'),
+        light: {
+            entityId: input.config.lightRef,
+            direction: tuple3(input.lightDirection, '$.lightDirection'),
+        },
+        qualityProfileId,
+        generator: {
+            maps: { ...qualityProfile.maps },
+            ...(qualityProfile.cascadeCount === undefined
+                ? {}
+                : { cascadeCount: qualityProfile.cascadeCount }),
+            filter: qualityProfile.receiverFilter,
+            bias: qualityProfile.bias,
+            normalBias: qualityProfile.normalBias,
+            darkness: qualityProfile.darkness,
+            bounds: cloneBounds(qualityProfile.bounds),
+            backend: { ...qualityProfile.backend },
+        },
+        culling: { ...qualityProfile.culling },
+        diagnosticThresholds: { ...qualityProfile.diagnostics },
+        behaviorProfiles,
+        objects,
+        diagnostics: [],
+    });
+}
+function optionalBoolean(value, path) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'boolean')
+        invalid(path, 'expected a boolean');
+    return value;
+}
+export function createShadowMapExperimentPlanSnapshot(value) {
+    const plan = record(cloneJson(value, '$'), '$');
+    const schemaVersion = plan.schemaVersion;
+    if (schemaVersion !== FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION_V2
+        && schemaVersion !== FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION) {
+        invalid('$.schemaVersion', `expected ${FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION_V2} or ${FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION}`);
+    }
+    knownFields(plan, [
+        'schemaVersion',
+        'revision',
+        'enabled',
+        'scopeId',
+        'light',
+        'qualityProfileId',
+        'generator',
+        'culling',
+        'diagnosticThresholds',
+        ...(schemaVersion === FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION ? ['behaviorProfiles'] : []),
+        'objects',
+        'diagnostics',
+    ], '$');
+    if (schemaVersion === FPS_SHADOW_MAP_EXPERIMENT_PLAN_SCHEMA_VERSION) {
+        const behaviorProfiles = profileRecord(plan.behaviorProfiles, '$.behaviorProfiles');
+        for (const [id, value] of Object.entries(behaviorProfiles)) {
+            const path = `$.behaviorProfiles.${id}`;
+            const profile = record(value, path);
+            knownFields(profile, ['cast', 'receive', 'updateClass'], path);
+            if (typeof profile.cast !== 'boolean')
+                invalid(`${path}.cast`, 'expected boolean');
+            if (typeof profile.receive !== 'boolean')
+                invalid(`${path}.receive`, 'expected boolean');
+            if (!['auto', 'static', 'dynamic', 'skinned'].includes(String(profile.updateClass))) {
+                invalid(`${path}.updateClass`, 'expected auto, static, dynamic, or skinned');
+            }
+        }
+    }
+    if (!Number.isInteger(plan.revision) || plan.revision < 0)
+        invalid('$.revision', 'expected a non-negative integer');
+    if (typeof plan.enabled !== 'boolean')
+        invalid('$.enabled', 'expected boolean');
+    nonEmptyString(plan.scopeId, '$.scopeId');
+    const light = record(plan.light, '$.light');
+    knownFields(light, ['entityId', 'direction'], '$.light');
+    nonEmptyString(light.entityId, '$.light.entityId');
+    tuple3(light.direction, '$.light.direction');
+    nonEmptyString(plan.qualityProfileId, '$.qualityProfileId');
+    const generator = record(plan.generator, '$.generator');
+    knownFields(generator, ['maps', 'cascadeCount', 'filter', 'bias', 'normalBias', 'darkness', 'bounds', 'backend'], '$.generator');
+    assertMapSettings(generator.maps, '$.generator.maps');
+    if (generator.cascadeCount !== undefined)
+        assertCascadeCount(generator.cascadeCount, '$.generator.cascadeCount');
+    if (generator.filter !== 'hard' && generator.filter !== 'low-pcf')
+        invalid('$.generator.filter', 'expected hard or low-pcf');
+    finiteInRange(generator.bias, '$.generator.bias', 0, 0.1);
+    finiteInRange(generator.normalBias, '$.generator.normalBias', 0, 1);
+    finiteInRange(generator.darkness, '$.generator.darkness', 0, 1);
+    assertBounds(generator.bounds, '$.generator.bounds');
+    assertBackendSettings(generator.backend, '$.generator.backend');
+    assertCullingSettings(plan.culling, '$.culling');
+    assertDiagnosticThresholds(plan.diagnosticThresholds, '$.diagnosticThresholds');
+    const objects = array(plan.objects, '$.objects').map((value, index) => {
+        const path = `$.objects[${index}]`;
+        const object = record(value, path);
+        knownFields(object, ['entityId', 'renderableIds', 'cast', 'receive', 'updateClass', 'behaviorProfileId'], path);
+        const result = {
+            entityId: nonEmptyString(object.entityId, `${path}.entityId`),
+            renderableIds: uniqueStrings(array(object.renderableIds, `${path}.renderableIds`), `${path}.renderableIds`),
+            cast: object.cast,
+            receive: object.receive,
+            updateClass: object.updateClass,
+            behaviorProfileId: nonEmptyString(object.behaviorProfileId, `${path}.behaviorProfileId`),
+        };
+        if (typeof result.cast !== 'boolean')
+            invalid(`${path}.cast`, 'expected boolean');
+        if (typeof result.receive !== 'boolean')
+            invalid(`${path}.receive`, 'expected boolean');
+        if (!['static', 'dynamic', 'skinned'].includes(String(result.updateClass)))
+            invalid(`${path}.updateClass`, 'expected static, dynamic, or skinned');
+        return result;
+    });
+    assertUniquePlanObjects(objects);
+    array(plan.diagnostics, '$.diagnostics').forEach((entry, index) => assertDiagnostic(entry, `$.diagnostics[${index}]`));
+    return plan;
+}
+export function createShadowMapExperimentPlanFingerprint(value) {
+    const serialized = JSON.stringify(createShadowMapExperimentPlanSnapshot(value));
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < serialized.length; index += 1) {
+        hash ^= serialized.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return `fnv1a:${hash.toString(16).padStart(8, '0')}`;
+}
+export function diffShadowMapExperimentPlans(previous, next) {
+    const before = new Map(previous.objects.map(object => [object.entityId, object]));
+    const after = new Map(next.objects.map(object => [object.entityId, object]));
+    const addedCasters = [];
+    const removedCasters = [];
+    const changedCasters = [];
+    const changedReceivers = [];
+    for (const [entityId, object] of after) {
+        const old = before.get(entityId);
+        if (!old) {
+            if (object.cast)
+                addedCasters.push(entityId);
+            if (object.receive)
+                changedReceivers.push(entityId);
+            continue;
+        }
+        if (!old.cast && object.cast)
+            addedCasters.push(entityId);
+        else if (old.cast && !object.cast)
+            removedCasters.push(entityId);
+        else if (old.cast && (old.updateClass !== object.updateClass || !sameStrings(old.renderableIds, object.renderableIds)))
+            changedCasters.push(entityId);
+        if (old.receive !== object.receive || !sameStrings(old.renderableIds, object.renderableIds))
+            changedReceivers.push(entityId);
+    }
+    for (const [entityId, object] of before) {
+        if (after.has(entityId))
+            continue;
+        if (object.cast)
+            removedCasters.push(entityId);
+        if (object.receive)
+            changedReceivers.push(entityId);
+    }
+    const generatorChanged = previous.enabled !== next.enabled
+        || previous.light.entityId !== next.light.entityId
+        || !sameNumbers(previous.light.direction, next.light.direction)
+        || JSON.stringify(previous.generator) !== JSON.stringify(next.generator)
+        || JSON.stringify(previous.culling) !== JSON.stringify(next.culling);
+    const dirty = new Set();
+    if (generatorChanged)
+        dirty.add('quality-changed');
+    if (addedCasters.length)
+        dirty.add('caster-added');
+    if (removedCasters.length)
+        dirty.add('caster-removed');
+    if (changedCasters.length)
+        dirty.add('static-geometry-changed');
+    return Object.freeze({
+        fromRevision: previous.revision,
+        toRevision: next.revision,
+        generatorChanged,
+        addedCasters: Object.freeze(addedCasters.sort()),
+        removedCasters: Object.freeze(removedCasters.sort()),
+        changedCasters: Object.freeze(changedCasters.sort()),
+        changedReceivers: Object.freeze(changedReceivers.sort()),
+        requiresRefresh: generatorChanged || addedCasters.length > 0 || removedCasters.length > 0 || changedCasters.length > 0,
+        dirtyReasons: Object.freeze([...dirty]),
+    });
+}
+function assertBounds(value, path) {
+    const bounds = record(value, path);
+    knownFields(bounds, ['mode', 'center', 'extent', 'near', 'far'], path);
+    if (bounds.mode !== 'fixed')
+        invalid(`${path}.mode`, 'expected fixed');
+    tuple3(bounds.center, `${path}.center`);
+    const extent = tuple3(bounds.extent, `${path}.extent`);
+    if (extent.some(entry => entry <= 0))
+        invalid(`${path}.extent`, 'expected positive values');
+    const near = finite(bounds.near, `${path}.near`);
+    const far = finite(bounds.far, `${path}.far`);
+    if (near < 0 || far <= near)
+        invalid(path, 'expected 0 <= near < far');
+}
+function assertQualityProfile(value, path) {
+    const profile = record(value, path);
+    knownFields(profile, ['maps', 'cascadeCount', 'receiverFilter', 'bias', 'normalBias', 'darkness', 'bounds', 'backend', 'culling', 'diagnostics'], path);
+    assertMapSettings(profile.maps, `${path}.maps`);
+    if (profile.cascadeCount !== undefined)
+        assertCascadeCount(profile.cascadeCount, `${path}.cascadeCount`);
+    if (profile.receiverFilter !== 'hard' && profile.receiverFilter !== 'low-pcf')
+        invalid(`${path}.receiverFilter`, 'expected hard or low-pcf');
+    finiteInRange(profile.bias, `${path}.bias`, 0, 0.1);
+    finiteInRange(profile.normalBias, `${path}.normalBias`, 0, 1);
+    finiteInRange(profile.darkness, `${path}.darkness`, 0, 1);
+    assertBounds(profile.bounds, `${path}.bounds`);
+    assertBackendSettings(profile.backend, `${path}.backend`);
+    assertCullingSettings(profile.culling, `${path}.culling`);
+    assertDiagnosticThresholds(profile.diagnostics, `${path}.diagnostics`);
+}
+function assertBehaviorProfile(value, path) {
+    const profile = record(value, path);
+    knownFields(profile, ['cast', 'receive', 'updateClass'], path);
+    if (profile.cast !== 'enabled' && profile.cast !== 'disabled')
+        invalid(`${path}.cast`, 'expected enabled or disabled');
+    if (profile.receive !== 'enabled' && profile.receive !== 'disabled')
+        invalid(`${path}.receive`, 'expected enabled or disabled');
+    if (!['auto', 'static', 'dynamic', 'skinned'].includes(String(profile.updateClass))) {
+        invalid(`${path}.updateClass`, 'expected auto, static, dynamic, or skinned');
+    }
+}
+function assertMapSettings(value, path) {
+    const maps = record(value, path);
+    knownFields(maps, ['staticResolution', 'dynamicResolution', 'compositeResolution'], path);
+    assertResolution(maps.staticResolution, `${path}.staticResolution`);
+    assertResolution(maps.dynamicResolution, `${path}.dynamicResolution`);
+    assertResolution(maps.compositeResolution, `${path}.compositeResolution`);
+}
+function assertResolution(value, path) {
+    if (value !== 512 && value !== 1024 && value !== 2048 && value !== 4096) {
+        invalid(path, 'expected 512, 1024, 2048, or 4096');
+    }
+}
+function assertCascadeCount(value, path) {
+    if (value !== 1 && value !== 2 && value !== 4)
+        invalid(path, 'expected 1, 2, or 4');
+}
+function assertBackendSettings(value, path) {
+    const backend = record(value, path);
+    knownFields(backend, ['mode', 'fallback'], path);
+    if (!['auto', 'split', 'single'].includes(String(backend.mode)))
+        invalid(`${path}.mode`, 'expected auto, split, or single');
+    if (backend.fallback !== 'single-map' && backend.fallback !== 'disable')
+        invalid(`${path}.fallback`, 'expected single-map or disable');
+}
+function assertCullingSettings(value, path) {
+    const culling = record(value, path);
+    knownFields(culling, ['enabled', 'guardBandRatio'], path);
+    if (typeof culling.enabled !== 'boolean')
+        invalid(`${path}.enabled`, 'expected boolean');
+    finiteInRange(culling.guardBandRatio, `${path}.guardBandRatio`, 0, 4);
+}
+function assertDiagnosticThresholds(value, path) {
+    const thresholds = record(value, path);
+    knownFields(thresholds, ['staticCasterCountWarning', 'dynamicCasterCountWarning', 'renderableCountWarning'], path);
+    nonNegativeInteger(thresholds.staticCasterCountWarning, `${path}.staticCasterCountWarning`);
+    nonNegativeInteger(thresholds.dynamicCasterCountWarning, `${path}.dynamicCasterCountWarning`);
+    nonNegativeInteger(thresholds.renderableCountWarning, `${path}.renderableCountWarning`);
+}
+function assertDiagnostic(value, path) {
+    const diagnostic = record(value, path);
+    knownFields(diagnostic, ['code', 'severity', 'message', 'entityId', 'renderableId', 'details'], path);
+    nonEmptyString(diagnostic.code, `${path}.code`);
+    if (!['info', 'warning', 'error'].includes(String(diagnostic.severity)))
+        invalid(`${path}.severity`, 'expected info, warning, or error');
+    nonEmptyString(diagnostic.message, `${path}.message`);
+    if (diagnostic.entityId !== undefined)
+        nonEmptyString(diagnostic.entityId, `${path}.entityId`);
+    if (diagnostic.renderableId !== undefined)
+        nonEmptyString(diagnostic.renderableId, `${path}.renderableId`);
+    if (diagnostic.details !== undefined)
+        record(diagnostic.details, `${path}.details`);
+}
+function assertUniquePlanObjects(objects) {
+    const entities = new Set();
+    const renderables = new Set();
+    for (const object of objects) {
+        if (entities.has(object.entityId))
+            invalid('$.objects', `duplicate entity id: ${object.entityId}`);
+        entities.add(object.entityId);
+        for (const id of object.renderableIds) {
+            if (renderables.has(id))
+                invalid('$.objects', `duplicate renderable id: ${id}`);
+            renderables.add(id);
+        }
+    }
+}
+function profileRecord(value, path) {
+    const profiles = record(value, path);
+    if (Object.keys(profiles).length === 0)
+        invalid(path, 'expected at least one profile');
+    for (const id of Object.keys(profiles))
+        nonEmptyString(id, `${path} key`);
+    return profiles;
+}
+function requireProfile(profiles, profileId, path, kind) {
+    if (!Object.prototype.hasOwnProperty.call(profiles, profileId)) {
+        invalid(path, `unknown ${kind} profile: ${profileId}`);
+    }
+    return profiles[profileId];
+}
+function cloneBounds(value) {
+    return Object.freeze({ mode: 'fixed', center: tuple3(value.center, '$.bounds.center'), extent: tuple3(value.extent, '$.bounds.extent'), near: value.near, far: value.far });
+}
+function tuple3(value, path) {
+    const entries = array(value, path);
+    if (entries.length !== 3)
+        invalid(path, 'expected exactly three numbers');
+    return Object.freeze(entries.map((entry, index) => finite(entry, `${path}[${index}]`)));
+}
+function uniqueStrings(value, path) {
+    const result = value.map((entry, index) => nonEmptyString(entry, `${path}[${index}]`));
+    if (new Set(result).size !== result.length)
+        invalid(path, 'expected unique strings');
+    return result;
+}
+function finite(value, path) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        invalid(path, 'expected a finite number');
+    return value;
+}
+function finiteInRange(value, path, min, max) {
+    const result = finite(value, path);
+    if (result < min || result > max)
+        invalid(path, `expected ${min}..${max}`);
+    return result;
+}
+function nonNegativeInteger(value, path) {
+    if (!Number.isInteger(value) || value < 0)
+        invalid(path, 'expected a non-negative integer');
+    return value;
+}
+function nonEmptyString(value, path) {
+    if (typeof value !== 'string' || !value.trim() || value !== value.trim())
+        invalid(path, 'expected a trimmed non-empty string');
+    return value;
+}
+function record(value, path) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        invalid(path, 'expected an object');
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        invalid(path, 'expected a plain object');
+    return value;
+}
+function array(value, path) {
+    if (!Array.isArray(value))
+        invalid(path, 'expected an array');
+    return value;
+}
+function knownFields(value, fields, path) {
+    const allowed = new Set(fields);
+    for (const key of Object.keys(value))
+        if (!allowed.has(key))
+            invalid(`${path}.${key}`, 'unknown field');
+}
+function cloneJson(value, path) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return finite(value, path);
+    if (Array.isArray(value))
+        return Object.freeze(value.map((entry, index) => cloneJson(entry, `${path}[${index}]`)));
+    const source = record(value, path);
+    const result = Object.create(null);
+    for (const [key, entry] of Object.entries(source))
+        result[key] = cloneJson(entry, `${path}.${key}`);
+    return Object.freeze(result);
+}
+function deepFreeze(value) {
+    if (!value || typeof value !== 'object' || Object.isFrozen(value))
+        return value;
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return Object.freeze(value);
+}
+function sameStrings(left, right) {
+    return left.length === right.length && left.every((entry, index) => entry === right[index]);
+}
+function sameNumbers(left, right) {
+    return left.length === right.length && left.every((entry, index) => entry === right[index]);
+}
+function invalid(path, reason) {
+    throw new Error(`shadow_map_experiment_invalid:${path}:${reason}`);
+}
+//# sourceMappingURL=shadow-map-experiment.js.map