diff --git a/packages/timeline-state-resolver-types/src/generated/kairos.ts b/packages/timeline-state-resolver-types/src/generated/kairos.ts
index 39ee5055f..5b658d23f 100644
--- a/packages/timeline-state-resolver-types/src/generated/kairos.ts
+++ b/packages/timeline-state-resolver-types/src/generated/kairos.ts
@@ -35,6 +35,31 @@ export interface MappingKairosSceneLayer {
 	mappingType: MappingKairosType.SceneLayer
 }
 
+export interface MappingKairosSceneLayerEffect {
+	effectType:
+		| 'crop'
+		| 'transform2D'
+		| 'luminanceKey'
+		| 'chromaKey'
+		| 'yUVCorrection'
+		| 'rGBCorrection'
+		| 'lUTCorrection'
+		| 'virtualPTZ'
+		| 'toneCurveCorrection'
+		| 'matrixCorrection'
+		| 'temperatureCorrection'
+		| 'linearKey'
+		| 'position'
+		| 'pCrop'
+		| 'filmLook'
+		| 'glowEffect'
+	sceneName: string[]
+	layerName: string[]
+	effectName?: string[]
+	temporalPriority?: number
+	mappingType: MappingKairosType.SceneLayerEffect
+}
+
 export interface MappingKairosAux {
 	auxName: string
 	temporalPriority?: number
@@ -75,6 +100,7 @@ export interface MappingKairosSoundPlayer {
 export enum MappingKairosType {
 	Scene = 'scene',
 	SceneLayer = 'scene-layer',
+	SceneLayerEffect = 'scene-layer-effect',
 	Aux = 'aux',
 	Macro = 'macro',
 	ClipPlayer = 'clip-player',
@@ -83,7 +109,7 @@ export enum MappingKairosType {
 	SoundPlayer = 'sound-player',
 }
 
-export type SomeMappingKairos = MappingKairosScene | MappingKairosSceneLayer | MappingKairosAux | MappingKairosMacro | MappingKairosClipPlayer | MappingKairosRamRecPlayer | MappingKairosImageStore | MappingKairosSoundPlayer
+export type SomeMappingKairos = MappingKairosScene | MappingKairosSceneLayer | MappingKairosSceneLayerEffect | MappingKairosAux | MappingKairosMacro | MappingKairosClipPlayer | MappingKairosRamRecPlayer | MappingKairosImageStore | MappingKairosSoundPlayer
 
 export interface ListScenesPayload {
 	scenePath: string[]
diff --git a/packages/timeline-state-resolver-types/src/integrations/kairos/timeline.ts b/packages/timeline-state-resolver-types/src/integrations/kairos/timeline.ts
index f5b17f6c7..4439d175f 100644
--- a/packages/timeline-state-resolver-types/src/integrations/kairos/timeline.ts
+++ b/packages/timeline-state-resolver-types/src/integrations/kairos/timeline.ts
@@ -13,11 +13,28 @@ import type {
 	MediaImageRef,
 	DissolveMode,
 	UpdateImageStoreObject,
+	UpdateEffectChromaKeyObject,
+	UpdateEffectCropObject,
+	UpdateEffectFilmLookObject,
+	UpdateEffectGlowEffectObject,
+	UpdateEffectLinearKeyObject,
+	UpdateEffectLuminanceKeyObject,
+	UpdateEffectLUTCorrectionObject,
+	UpdateEffectMatrixCorrectionObject,
+	UpdateEffectPCropObject,
+	UpdateEffectPositionObject,
+	UpdateEffectRGBCorrectionObject,
+	UpdateEffectTemperatureCorrectionObject,
+	UpdateEffectToneCurveCorrectionObject,
+	UpdateEffectTransform2DObject,
+	UpdateEffectVirtualPTZObject,
+	UpdateEffectYUVCorrectionObject,
 } from 'kairos-lib'
 
 export enum TimelineContentTypeKairos {
 	SCENE = 'scene',
 	SCENE_LAYER = 'scene-layer',
+	SCENE_LAYER_EFFECT = 'scene-layer-effect',
 
 	// MVs? - no
 	// gfx / painter - yes, to be implemented
@@ -41,6 +58,7 @@ type PartialOrNull<T> = {
 export type TimelineContentKairosAny =
 	| TimelineContentKairosScene
 	| TimelineContentKairosSceneLayer
+	| TimelineContentKairosSceneLayerEffect
 	| TimelineContentKairosAux
 	| TimelineContentKairosMacros
 	| TimelineContentKairosClipPlayer
@@ -81,6 +99,30 @@ export interface TimelineContentKairosSceneLayer {
 		}
 	>
 }
+export interface TimelineContentKairosSceneLayerEffect {
+	deviceType: DeviceType.KAIROS
+	type: TimelineContentTypeKairos.SCENE_LAYER_EFFECT
+
+	effect: TimelineContentKairosSceneAnySceneLayerEffect
+}
+
+export type TimelineContentKairosSceneAnySceneLayerEffect =
+	| { type: 'crop'; values: Partial<UpdateEffectCropObject> }
+	| { type: 'transform2D'; values: Partial<UpdateEffectTransform2DObject> }
+	| { type: 'luminanceKey'; values: Partial<UpdateEffectLuminanceKeyObject> }
+	| { type: 'chromaKey'; values: Partial<UpdateEffectChromaKeyObject> }
+	| { type: 'yUVCorrection'; values: Partial<UpdateEffectYUVCorrectionObject> }
+	| { type: 'rGBCorrection'; values: Partial<UpdateEffectRGBCorrectionObject> }
+	| { type: 'lUTCorrection'; values: Partial<UpdateEffectLUTCorrectionObject> }
+	| { type: 'virtualPTZ'; values: Partial<UpdateEffectVirtualPTZObject> }
+	| { type: 'toneCurveCorrection'; values: Partial<UpdateEffectToneCurveCorrectionObject> }
+	| { type: 'matrixCorrection'; values: Partial<UpdateEffectMatrixCorrectionObject> }
+	| { type: 'temperatureCorrection'; values: Partial<UpdateEffectTemperatureCorrectionObject> }
+	| { type: 'linearKey'; values: Partial<UpdateEffectLinearKeyObject> }
+	| { type: 'position'; values: Partial<UpdateEffectPositionObject> }
+	| { type: 'pCrop'; values: Partial<UpdateEffectPCropObject> }
+	| { type: 'filmLook'; values: Partial<UpdateEffectFilmLookObject> }
+	| { type: 'glowEffect'; values: Partial<UpdateEffectGlowEffectObject> }
 
 export interface TimelineContentKairosAux {
 	deviceType: DeviceType.KAIROS
diff --git a/packages/timeline-state-resolver/src/integrations/kairos/$schemas/mappings.json b/packages/timeline-state-resolver/src/integrations/kairos/$schemas/mappings.json
index b2a90b027..23e1f988c 100644
--- a/packages/timeline-state-resolver/src/integrations/kairos/$schemas/mappings.json
+++ b/packages/timeline-state-resolver/src/integrations/kairos/$schemas/mappings.json
@@ -74,6 +74,87 @@
 			],
 			"additionalProperties": false
 		},
+		"scene-layer-effect": {
+			"type": "object",
+			"properties": {
+				"effectType": {
+					"type": "string",
+					"enum": [
+						"crop",
+						"transform2D",
+						"luminanceKey",
+						"chromaKey",
+						"yUVCorrection",
+						"rGBCorrection",
+						"lUTCorrection",
+						"virtualPTZ",
+						"toneCurveCorrection",
+						"matrixCorrection",
+						"temperatureCorrection",
+						"linearKey",
+						"position",
+						"pCrop",
+						"filmLook",
+						"glowEffect"
+					],
+					"ui:title": "Effect Type",
+					"ui:description": "Type of Layer Effect",
+					"ui:summaryTitle": "Effect Type",
+					"ui:displayType": "breadcrumbs",
+					"default": []
+				},
+				"sceneName": {
+					"type": "array",
+					"items": {
+						"type": "string"
+					},
+					"ui:title": "Scene",
+					"ui:description": "The Scene to use",
+					"ui:summaryTitle": "Scene",
+					"ui:displayType": "breadcrumbs",
+					"default": [
+						"Main"
+					]
+				},
+				"layerName": {
+					"type": "array",
+					"items": {
+						"type": "string"
+					},
+					"ui:title": "Layer",
+					"ui:description": "The layer in a scene to use",
+					"ui:summaryTitle": "Layer",
+					"ui:displayType": "breadcrumbs",
+					"default": [
+						"Background"
+					]
+				},
+				"effectName": {
+					"type": "array",
+					"items": {
+						"type": "string"
+					},
+					"ui:title": "Effect",
+					"ui:description": "Name of the effect (optional)",
+					"ui:summaryTitle": "Effect Name",
+					"ui:displayType": "breadcrumbs",
+					"default": []
+				},
+				"temporalPriority": {
+					"type": "integer",
+					"ui:title": "Temporal Priority",
+					"ui:description": "Set this to a higher value to make commands that affects this Scene be sent first. Set this to a negative value to ensure that other untracked things are done first. Defaults to 0.",
+					"ui:summaryTitle": "Temporal Priority",
+					"default": 0
+				}
+			},
+			"required": [
+				"effectType",
+				"sceneName",
+				"layerName"
+			],
+			"additionalProperties": false
+		},
 		"aux": {
 			"type": "object",
 			"properties": {
diff --git a/packages/timeline-state-resolver/src/integrations/kairos/__tests__/diffState.spec.ts b/packages/timeline-state-resolver/src/integrations/kairos/__tests__/diffState.spec.ts
index a173d8ff1..d12a1f553 100644
--- a/packages/timeline-state-resolver/src/integrations/kairos/__tests__/diffState.spec.ts
+++ b/packages/timeline-state-resolver/src/integrations/kairos/__tests__/diffState.spec.ts
@@ -30,6 +30,16 @@ describe('diffState', () => {
 				layerName: ['Background'],
 			},
 		},
+		mainSceneBackgroundLayerLuminance: {
+			device: DeviceType.KAIROS,
+			deviceId: 'kairos0',
+			options: {
+				mappingType: MappingKairosType.SceneLayerEffect,
+				effectType: 'luminanceKey',
+				sceneName: ['Main'],
+				layerName: ['Background'],
+			},
+		},
 		clipPlayer1: {
 			device: DeviceType.KAIROS,
 			deviceId: 'kairos0',
@@ -491,6 +501,63 @@ describe('diffState', () => {
 			compareStates(DEFAULT_MAPPINGS, oldState, newState, [])
 		})
 	})
+	test('Set LuminanceKey of SceneLayer', () => {
+		compareStates(
+			DEFAULT_MAPPINGS,
+			{ ...EMPTY_STATE, stateTime: now },
+			KairosStateBuilder.fromTimeline(
+				{
+					objects: [
+						makeDeviceTimelineStateObject({
+							enable: { start: now },
+							id: 'obj0',
+							layer: 'mainSceneBackgroundLayerLuminance',
+							content: {
+								deviceType: DeviceType.KAIROS,
+								type: TimelineContentTypeKairos.SCENE_LAYER_EFFECT,
+								effect: {
+									type: 'luminanceKey',
+									values: {
+										sourceKey: {
+											realm: 'ip-input',
+											ipInput: 23,
+										},
+									},
+								},
+							},
+						}),
+					],
+					time: now,
+				},
+				DEFAULT_MAPPINGS
+			),
+			[
+				{
+					context: expect.any(String),
+					timelineObjId: expect.any(String),
+					command: {
+						type: 'scene-layer-effect',
+						// sceneLayerId: 'SCENES.Main.Layers.Background',
+						ref: {
+							realm: 'scene-layer-effect',
+							scenePath: ['Main'],
+							layerPath: ['Background'],
+							effectPath: ['LuminanceKey'],
+						},
+						effect: {
+							type: 'luminanceKey',
+							values: {
+								sourceKey: {
+									realm: 'ip-input',
+									ipInput: 23,
+								},
+							},
+						},
+					},
+				},
+			]
+		)
+	})
 	// test('temporal order when cutting to/from a clip player before it has started/stopped playing', () => {
 
 	// })
@@ -513,6 +580,7 @@ const EMPTY_STATE: Omit<KairosDeviceState, 'stateTime'> = {
 	macros: {},
 	ramRecPlayers: {},
 	sceneLayers: {},
+	sceneLayerEffects: {},
 	sceneSnapshots: {},
 	scenes: {},
 	soundPlayers: {},
diff --git a/packages/timeline-state-resolver/src/integrations/kairos/__tests__/lib.ts b/packages/timeline-state-resolver/src/integrations/kairos/__tests__/lib.ts
index ef4d007aa..7fd6b71b7 100644
--- a/packages/timeline-state-resolver/src/integrations/kairos/__tests__/lib.ts
+++ b/packages/timeline-state-resolver/src/integrations/kairos/__tests__/lib.ts
@@ -6,6 +6,7 @@ export const EMPTY_STATE: Omit<KairosDeviceState, 'stateTime'> = {
 	macros: {},
 	ramRecPlayers: {},
 	sceneLayers: {},
+	sceneLayerEffects: {},
 	sceneSnapshots: {},
 	scenes: {},
 	soundPlayers: {},
diff --git a/packages/timeline-state-resolver/src/integrations/kairos/commands.ts b/packages/timeline-state-resolver/src/integrations/kairos/commands.ts
index a26e5f7c8..db13d46a9 100644
--- a/packages/timeline-state-resolver/src/integrations/kairos/commands.ts
+++ b/packages/timeline-state-resolver/src/integrations/kairos/commands.ts
@@ -18,6 +18,7 @@ import type { CommandWithContext } from 'timeline-state-resolver-api'
 import { isEqual } from 'underscore'
 import { assertNever } from '../../lib.js'
 import type { KairosRamLoader } from './lib/kairosRamLoader.js'
+import { SceneLayerEffectRef, TimelineContentKairosSceneAnySceneLayerEffect } from 'timeline-state-resolver-types'
 
 export type KairosCommandWithContext = CommandWithContext<KairosCommandAny, string>
 
@@ -25,6 +26,7 @@ export type KairosCommandAny =
 	| KairosSceneCommand
 	| KairosSceneRecallSnapshotCommand
 	| KairosSceneLayerCommand
+	| KairosSceneLayerEffectCommand
 	| KairosAuxCommand
 	| KairosMacroCommand
 	| KairosClipPlayerCommand
@@ -58,6 +60,13 @@ export interface KairosSceneLayerCommand {
 
 	values: Partial<UpdateSceneLayerObject>
 }
+export interface KairosSceneLayerEffectCommand {
+	type: 'scene-layer-effect'
+
+	ref: SceneLayerEffectRef
+
+	effect: TimelineContentKairosSceneAnySceneLayerEffect
+}
 
 export interface KairosAuxCommand {
 	type: 'aux'
@@ -223,6 +232,47 @@ export async function sendCommand(
 			await kairos.updateSceneLayer(command.ref, values)
 			break
 		}
+		case 'scene-layer-effect': {
+			const effect = command.effect
+			const ref = command.ref
+
+			if (effect.type === 'crop') {
+				await kairos.updateSceneLayerEffectCrop(ref, effect.values)
+			} else if (effect.type === 'transform2D') {
+				await kairos.updateSceneLayerEffectTransform2D(ref, effect.values)
+			} else if (effect.type === 'luminanceKey') {
+				await kairos.updateSceneLayerEffectLuminanceKey(ref, effect.values)
+			} else if (effect.type === 'chromaKey') {
+				await kairos.updateSceneLayerEffectChromaKey(ref, effect.values)
+			} else if (effect.type === 'yUVCorrection') {
+				await kairos.updateSceneLayerEffectYUVCorrection(ref, effect.values)
+			} else if (effect.type === 'rGBCorrection') {
+				await kairos.updateSceneLayerEffectRGBCorrection(ref, effect.values)
+			} else if (effect.type === 'lUTCorrection') {
+				await kairos.updateSceneLayerEffectLUTCorrection(ref, effect.values)
+			} else if (effect.type === 'virtualPTZ') {
+				await kairos.updateSceneLayerEffectVirtualPTZ(ref, effect.values)
+			} else if (effect.type === 'toneCurveCorrection') {
+				await kairos.updateSceneLayerEffectToneCurveCorrection(ref, effect.values)
+			} else if (effect.type === 'matrixCorrection') {
+				await kairos.updateSceneLayerEffectMatrixCorrection(ref, effect.values)
+			} else if (effect.type === 'temperatureCorrection') {
+				await kairos.updateSceneLayerEffectTemperatureCorrection(ref, effect.values)
+			} else if (effect.type === 'linearKey') {
+				await kairos.updateSceneLayerEffectLinearKey(ref, effect.values)
+			} else if (effect.type === 'position') {
+				await kairos.updateSceneLayerEffectPosition(ref, effect.values)
+			} else if (effect.type === 'pCrop') {
+				await kairos.updateSceneLayerEffectPCrop(ref, effect.values)
+			} else if (effect.type === 'filmLook') {
+				await kairos.updateSceneLayerEffectFilmLook(ref, effect.values)
+			} else if (effect.type === 'glowEffect') {
+				await kairos.updateSceneLayerEffectGlowEffect(ref, effect.values)
+			} else {
+				assertNever(effect)
+			}
+			break
+		}
 		case 'aux':
 			await kairos.updateAux(command.ref, command.values)
 			break
diff --git a/packages/timeline-state-resolver/src/integrations/kairos/diffState.ts b/packages/timeline-state-resolver/src/integrations/kairos/diffState.ts
index 3a391f8b7..16f4f3d8a 100644
--- a/packages/timeline-state-resolver/src/integrations/kairos/diffState.ts
+++ b/packages/timeline-state-resolver/src/integrations/kairos/diffState.ts
@@ -1,4 +1,8 @@
-import type { SomeMappingKairos, Mappings } from 'timeline-state-resolver-types'
+import type {
+	SomeMappingKairos,
+	Mappings,
+	TimelineContentKairosSceneAnySceneLayerEffect,
+} from 'timeline-state-resolver-types'
 import { KairosMacroActiveState } from 'timeline-state-resolver-types'
 import { UpdateSceneLayerObject, UpdateSceneObject, UpdateAuxObject } from 'kairos-connection'
 import { KairosStateBuilder, type KairosDeviceState } from './stateBuilder.js'
@@ -27,6 +31,7 @@ export function diffKairosStates(
 	commands.push(...diffSceneSnapshots(oldKairosState.sceneSnapshots, newKairosState.sceneSnapshots))
 	commands.push(...diffScenes(oldKairosState.scenes, newKairosState.scenes))
 	commands.push(...diffSceneLayers(oldKairosState.sceneLayers, newKairosState.sceneLayers))
+	commands.push(...diffSceneLayerEffects(oldKairosState.sceneLayerEffects, newKairosState.sceneLayerEffects))
 
 	commands.push(...diffAuxes(oldKairosState.aux, newKairosState.aux))
 
@@ -127,6 +132,45 @@ function diffSceneLayers(
 
 	return commands
 }
+function diffSceneLayerEffects(
+	oldSceneLayers: KairosDeviceState['sceneLayerEffects'],
+	newSceneLayers: KairosDeviceState['sceneLayerEffects']
+): KairosCommandWithContext[] {
+	const commands: KairosCommandWithContext[] = []
+
+	const sceneLayerEffectKeys = getAllKeysString(oldSceneLayers, newSceneLayers)
+	for (const sceneLayerEffectKey of sceneLayerEffectKeys) {
+		const newSceneLayerEffect = newSceneLayers[sceneLayerEffectKey]
+		const oldSceneLayerEffect = oldSceneLayers[sceneLayerEffectKey]
+
+		const sceneLayerEffectRef = newSceneLayerEffect?.ref || oldSceneLayerEffect?.ref
+		if (!sceneLayerEffectRef) continue // No scene to diff
+
+		const effectType = newSceneLayerEffect?.state.type || oldSceneLayerEffect?.state.type
+		if (!effectType) continue
+
+		const diff = diffObject<TimelineContentKairosSceneAnySceneLayerEffect['values']>(
+			oldSceneLayerEffect?.state?.values,
+			newSceneLayerEffect?.state.values
+		)
+		if (diff) {
+			commands.push({
+				timelineObjId: newSceneLayerEffect?.timelineObjIds.join(' & ') ?? '',
+				context: `sceneLayerKey=${sceneLayerEffectKey} newSceneLayer=${!!newSceneLayerEffect} oldSceneLayer=${!!oldSceneLayerEffect}`,
+				command: {
+					type: 'scene-layer-effect',
+					ref: sceneLayerEffectRef,
+					effect: {
+						type: effectType,
+						values: diff,
+					} as TimelineContentKairosSceneAnySceneLayerEffect,
+				},
+			})
+		}
+	}
+
+	return commands
+}
 
 function diffSceneSnapshots(
 	oldSceneSnapshots: KairosDeviceState['sceneSnapshots'],
diff --git a/packages/timeline-state-resolver/src/integrations/kairos/kairos-application-monitor.ts b/packages/timeline-state-resolver/src/integrations/kairos/kairos-application-monitor.ts
index 37386f65d..04aec5216 100644
--- a/packages/timeline-state-resolver/src/integrations/kairos/kairos-application-monitor.ts
+++ b/packages/timeline-state-resolver/src/integrations/kairos/kairos-application-monitor.ts
@@ -18,6 +18,7 @@ import {
 	MediaSoundRef,
 	refToPath,
 	ResponseError,
+	refSceneLayerEffect,
 } from 'kairos-connection'
 import {
 	AuxRef,
@@ -36,6 +37,7 @@ import {
 } from 'timeline-state-resolver-types'
 import * as _ from 'underscore'
 import {
+	getLayerEffectEffectName,
 	KairosDeviceState,
 	KairosDeviceStateAux,
 	KairosDeviceStateClipPlayers,
@@ -161,6 +163,15 @@ export class KairosApplicationMonitor extends EventEmitter<KairosApplicationMoni
 				this.aware.add(refScene(mapping.options.sceneName))
 			} else if (mapping.options.mappingType === MappingKairosType.SceneLayer) {
 				this.aware.add(refSceneLayer(refScene(mapping.options.sceneName), mapping.options.layerName))
+			} else if (mapping.options.mappingType === MappingKairosType.SceneLayerEffect) {
+				const effectName = getLayerEffectEffectName(mapping.options)
+				if (effectName.length > 0)
+					this.aware.add(
+						refSceneLayerEffect(
+							refSceneLayer(refScene(mapping.options.sceneName), mapping.options.layerName),
+							effectName
+						)
+					)
 			} else if (mapping.options.mappingType === MappingKairosType.Aux) {
 				this.aware.add(refAuxName(mapping.options.auxName))
 			} else if (mapping.options.mappingType === MappingKairosType.Macro) {
@@ -300,7 +311,12 @@ export class KairosApplicationMonitor extends EventEmitter<KairosApplicationMoni
 			} else if (sourceRef.realm === 'audio-player') {
 				await ensureExists(this.kairos.audioPlayerExists(sourceRef), `Audio Player "${refToPath(sourceRef)}"`)
 			} else if (sourceRef.realm === 'scene-layer-effect') {
-				// There is no method to check a sceneLayerEffect individually (yet)
+				const layerRef = refSceneLayer(refScene(sourceRef.scenePath), sourceRef.layerPath)
+				const layerEffects = await this.kairos.listSceneLayerEffects(layerRef)
+
+				if (!layerEffects.find((effect) => _.isEqual(effect.effectPath, sourceRef.effectPath))) {
+					issues.push(`Layer Effect ${refToPath(sourceRef)} not found on the Kairos.`)
+				}
 			} else if (sourceRef.realm === 'aux') {
 				await ensureExists(this.kairos.auxExists(sourceRef), `Aux "${refToPath(sourceRef)}"`)
 			} else if (sourceRef.realm === 'media-clip') {
diff --git a/packages/timeline-state-resolver/src/integrations/kairos/stateBuilder.ts b/packages/timeline-state-resolver/src/integrations/kairos/stateBuilder.ts
index e30086bc8..2a11d0ffc 100644
--- a/packages/timeline-state-resolver/src/integrations/kairos/stateBuilder.ts
+++ b/packages/timeline-state-resolver/src/integrations/kairos/stateBuilder.ts
@@ -26,6 +26,10 @@ import {
 	KairosMacroActiveState,
 	TimelineContentKairosMacroInfo,
 	KairosTSRMappingRef,
+	MappingKairosSceneLayerEffect,
+	TimelineContentKairosSceneLayerEffect,
+	SceneLayerEffectRef,
+	TimelineContentKairosSceneAnySceneLayerEffect,
 } from 'timeline-state-resolver-types'
 import { assertNever } from '../../lib.js'
 import {
@@ -51,6 +55,7 @@ import {
 	refRamRecorder,
 	refImageStore,
 	UpdateAuxObject,
+	refSceneLayerEffect,
 } from 'kairos-connection'
 import { TimelineObjectInstance } from 'superfly-timeline'
 import { DeviceTimelineState, DeviceTimelineStateObject } from 'timeline-state-resolver-api'
@@ -60,6 +65,7 @@ export interface KairosDeviceState {
 	scenes: Record<string, KairosDeviceStateScenes>
 	sceneSnapshots: Record<string, KairosDeviceStateSceneSnapshots>
 	sceneLayers: Record<string, KairosDeviceStateSceneLayers>
+	sceneLayerEffects: Record<string, KairosDeviceStateSceneLayerEffects>
 	aux: Record<string, KairosDeviceStateAux>
 	macros: Record<string, KairosDeviceStateMacros>
 	clipPlayers: Record<number, KairosDeviceStateClipPlayers>
@@ -82,6 +88,9 @@ export type KairosDeviceStateSceneSnapshots =
 export type KairosDeviceStateSceneLayers =
 	| { ref: SceneLayerRef; state: Partial<UpdateSceneLayerObject>; timelineObjIds: string[] }
 	| undefined
+export type KairosDeviceStateSceneLayerEffects =
+	| { ref: SceneLayerEffectRef; state: TimelineContentKairosSceneAnySceneLayerEffect; timelineObjIds: string[] }
+	| undefined
 
 export type KairosDeviceStateAux =
 	| { ref: AuxRef; state: Partial<UpdateAuxObject>; timelineObjIds: string[] }
@@ -145,6 +154,7 @@ export class KairosStateBuilder {
 		scenes: {},
 		sceneSnapshots: {},
 		sceneLayers: {},
+		sceneLayerEffects: {},
 		aux: {},
 		macros: {},
 		clipPlayers: {},
@@ -177,6 +187,11 @@ export class KairosStateBuilder {
 							builder._applySceneLayer(mappings, mapping.options, content, tlObject.id)
 						}
 						break
+					case MappingKairosType.SceneLayerEffect:
+						if (content.type === TimelineContentTypeKairos.SCENE_LAYER_EFFECT) {
+							builder._applySceneLayerEffect(mapping.options, content, tlObject.id)
+						}
+						break
 					case MappingKairosType.Aux:
 						if (content.type === TimelineContentTypeKairos.AUX) {
 							builder._applyAux(mappings, mapping.options, content, tlObject.id)
@@ -307,6 +322,34 @@ export class KairosStateBuilder {
 			timelineObjId
 		)
 	}
+	private _applySceneLayerEffect(
+		mapping: MappingKairosSceneLayerEffect,
+		content: TimelineContentKairosSceneLayerEffect,
+		timelineObjId: string
+	): void {
+		if (!mapping.sceneName || mapping.sceneName.length === 0) return
+		if (!mapping.layerName || mapping.layerName.length === 0) return
+
+		if (content.effect.type !== mapping.effectType) return
+
+		const effectName = getLayerEffectEffectName(mapping)
+		if (effectName.length === 0) return
+
+		const sceneLayerRef = refSceneLayer(refScene(mapping.sceneName), mapping.layerName)
+		const sceneLayerEffectRef = refSceneLayerEffect(sceneLayerRef, effectName)
+
+		const sceneLayerEffectKey = refToPath(sceneLayerEffectRef)
+
+		const sceneLayerEffectObj: TimelineContentKairosSceneAnySceneLayerEffect = content.effect
+
+		// Perform a simple merge of the content into the state
+		this.#deviceState.sceneLayerEffects[sceneLayerEffectKey] = this._mergeState(
+			this.#deviceState.sceneLayerEffects[sceneLayerEffectKey],
+			sceneLayerEffectRef,
+			sceneLayerEffectObj,
+			timelineObjId
+		)
+	}
 
 	private _applyAux(
 		mappings: Mappings<SomeMappingKairos>,
@@ -486,6 +529,7 @@ function lookupMappingRef(
 					return refImageStore(mapping.options.playerId)
 				case MappingKairosType.SoundPlayer:
 				case MappingKairosType.SceneLayer:
+				case MappingKairosType.SceneLayerEffect:
 				case MappingKairosType.Aux:
 				case MappingKairosType.Macro:
 					return undefined // Not supported as SourceRef
@@ -509,3 +553,28 @@ function omitUndefinedValues<T extends object>(obj: T): T {
 	}
 	return obj
 }
+export function getLayerEffectEffectName(mapping: MappingKairosSceneLayerEffect): string[] {
+	if (mapping.effectName && mapping.effectName.length > 0) return mapping.effectName
+
+	// else, use default Effect Name:
+	if (mapping.effectType === 'crop') return ['Crop']
+	else if (mapping.effectType === 'transform2D') return ['Transform2D']
+	else if (mapping.effectType === 'luminanceKey') return ['LuminanceKey']
+	else if (mapping.effectType === 'chromaKey') return ['ChromaKey']
+	else if (mapping.effectType === 'yUVCorrection') return ['YUVCorrection']
+	else if (mapping.effectType === 'rGBCorrection') return ['RGBCorrection']
+	else if (mapping.effectType === 'lUTCorrection') return ['LUTCorrection']
+	else if (mapping.effectType === 'virtualPTZ') return ['VirtualPTZ']
+	else if (mapping.effectType === 'toneCurveCorrection') return ['ToneCurveCorrection']
+	else if (mapping.effectType === 'matrixCorrection') return ['MatrixCorrection']
+	else if (mapping.effectType === 'temperatureCorrection') return ['TemperatureCorrection']
+	else if (mapping.effectType === 'linearKey') return ['LinearKey']
+	else if (mapping.effectType === 'position') return ['Position']
+	else if (mapping.effectType === 'pCrop') return ['PCrop']
+	else if (mapping.effectType === 'filmLook') return ['FilmLook']
+	else if (mapping.effectType === 'glowEffect') return ['GlowEffect']
+	else {
+		assertNever(mapping.effectType)
+		return []
+	}
+}
diff --git a/packages/timeline-state-resolver/src/integrations/kairos/temporal-priority.ts b/packages/timeline-state-resolver/src/integrations/kairos/temporal-priority.ts
index 1ac52b2e0..47dde99e0 100644
--- a/packages/timeline-state-resolver/src/integrations/kairos/temporal-priority.ts
+++ b/packages/timeline-state-resolver/src/integrations/kairos/temporal-priority.ts
@@ -1,5 +1,6 @@
 import { Mapping, MappingKairosType, Mappings, SomeMappingKairos } from 'timeline-state-resolver-types'
 import {
+	getLayerEffectEffectName,
 	KairosDeviceState,
 	KairosDeviceStateAux,
 	KairosDeviceStateClipPlayers,
@@ -24,6 +25,7 @@ import {
 	refRamRecorder,
 	refScene,
 	refSceneLayer,
+	refSceneLayerEffect,
 	refToPath,
 } from 'kairos-connection'
 
@@ -160,6 +162,18 @@ export function buildDependencyGraph(
 				node = dependencyGraph.get(
 					refToPath(refSceneLayer(refScene(mapping.options.sceneName), mapping.options.layerName))
 				)
+			} else if (mapping.options.mappingType === MappingKairosType.SceneLayerEffect) {
+				const effectName = getLayerEffectEffectName(mapping.options)
+				if (effectName.length > 0) {
+					node = dependencyGraph.get(
+						refToPath(
+							refSceneLayerEffect(
+								refSceneLayer(refScene(mapping.options.sceneName), mapping.options.layerName),
+								effectName
+							)
+						)
+					)
+				}
 			} else {
 				assertNever(mapping.options)
 				continue
@@ -236,6 +250,7 @@ export function orderCommandsByTemporalPriority(
 				command.command.type === 'scene' ||
 				command.command.type === 'scene-recall-snapshot' ||
 				command.command.type === 'scene-layer' ||
+				command.command.type === 'scene-layer-effect' ||
 				command.command.type === 'aux'
 			) {
 				ref = command.command.ref