escoria updateHEADmain

1 files changed, 1879 insertions, 0 deletions

diff --git a/addons/escoria-core/testing/ashes/interpreter/esc_interpreter_test.gd b/addons/escoria-core/testing/ashes/interpreter/esc_interpreter_test.gd
new file mode 100644
index 0000000..e03d122
--- /dev/null
+++ b/addons/escoria-core/testing/ashes/interpreter/esc_interpreter_test.gd
@@ -0,0 +1,1879 @@
+# GdUnit generated TestSuite
+class_name ESCInterpreterTest
+extends GdUnitTestSuite
+
+@warning_ignore("unused_parameter")
+@warning_ignore("return_value_discarded")
+
+const MARK_SCENE := preload("res://game/characters/mark/mark.tscn")
+const SIMPLE_CHOOSER_SCENE := preload("res://addons/escoria-dialog-simple/chooser/simple.tscn")
+
+var _terminate_on_errors_before: bool
+var _command_directories_before: PackedStringArray
+var _dialog_player_before
+
+
+class DialogPlayerDouble extends ESCDialogPlayer:
+	var _choice_indexes: Array = []
+	var _choices_consumed: int = 0
+	var _dialogs_started: Array = []
+
+
+	func _init(choice_indexes: Array = []):
+		_choice_indexes = choice_indexes.duplicate()
+
+
+	func start_dialog_choices(dialog: ESCDialog, _type: String = "simple"):
+		var option_keys: Array = []
+		var option_texts: Array = []
+		var option_source_indexes: Array = []
+		for option in dialog.options:
+			option_keys.append(option.translation_key)
+			option_texts.append(option.option)
+			option_source_indexes.append(option.source_option_index)
+
+		var timeout_option := dialog.get_timeout_option()
+
+		_dialogs_started.append({
+			"avatar": dialog.avatar,
+			"timeout": dialog.timeout,
+			"timeout_option": dialog.timeout_option,
+			"authored_options_count": dialog.authored_options_count,
+			"visible_timeout_option": timeout_option.option if timeout_option else null,
+			"options_size": dialog.options.size(),
+			"option_keys": option_keys,
+			"option_texts": option_texts,
+			"option_source_indexes": option_source_indexes
+		})
+
+		# Mirror the real dialog player closely enough for interpreter tests:
+		# only valid options are choosable, and scripted indexes deterministically
+		# drive nested dialog flows without needing UI interaction.
+		var valid_options: Array = []
+		for option in dialog.options:
+			if option.is_valid():
+				valid_options.append(option)
+
+		var choice_index := 0
+		if not _choice_indexes.is_empty():
+			choice_index = int(_choice_indexes.pop_front())
+			_choices_consumed += 1
+
+		call_deferred("_emit_choice", valid_options[choice_index] if choice_index < valid_options.size() else null)
+
+
+	func _emit_choice(option) -> void:
+		option_chosen.emit(option)
+
+
+	func get_choices_consumed() -> int:
+		return _choices_consumed
+
+
+	func get_remaining_choices() -> int:
+		return _choice_indexes.size()
+
+
+	func get_dialogs_started() -> Array:
+		return _dialogs_started.duplicate(true)
+
+
+func before() -> void:
+	# Interpreter tests intentionally trigger runtime errors in a few cases, so
+	# they disable terminate-on-error and install a test-only command directory.
+	# The dialog player is also replaced on demand by a deterministic test
+	# double so dialog execution can run headlessly.
+	ESCInterpreterFactory.reset_interpreter()
+	escoria.event_manager.interrupt([], false)
+	escoria.event_manager.clear_event_queue()
+	_terminate_on_errors_before = ESCProjectSettingsManager.get_setting(
+		ESCProjectSettingsManager.TERMINATE_ON_ERRORS
+	)
+	_command_directories_before = PackedStringArray(
+		ESCProjectSettingsManager.get_setting(
+			ESCProjectSettingsManager.COMMAND_DIRECTORIES
+		)
+	)
+	_dialog_player_before = escoria.get("dialog_player")
+
+	ESCProjectSettingsManager.set_setting(
+		ESCProjectSettingsManager.TERMINATE_ON_ERRORS,
+		false
+	)
+	ESCProjectSettingsManager.set_setting(
+		ESCProjectSettingsManager.COMMAND_DIRECTORIES,
+		PackedStringArray([
+			"res://addons/escoria-core/testing/ashes/interpreter/support/commands"
+		] + Array(_command_directories_before))
+	)
+	escoria.command_registry.registry.clear()
+	escoria.set("dialog_player", null)
+
+
+func after() -> void:
+	# Restore shared Escoria settings and globals so each test starts from the
+	# same baseline and does not leak command registry or dialog-player state.
+	ESCInterpreterFactory.reset_interpreter()
+	escoria.event_manager.interrupt([], false)
+	escoria.event_manager.clear_event_queue()
+	ESCProjectSettingsManager.set_setting(
+		ESCProjectSettingsManager.TERMINATE_ON_ERRORS,
+		_terminate_on_errors_before
+	)
+	ESCProjectSettingsManager.set_setting(
+		ESCProjectSettingsManager.COMMAND_DIRECTORIES,
+		_command_directories_before
+	)
+	escoria.command_registry.registry.clear()
+	escoria.set("dialog_player", _dialog_player_before)
+
+
+func test_execute_block_restores_scope_after_break() -> void:
+	# This fixture creates a nested block-local `x`, exits that block with
+	# `break`, and then reads `x` afterward into a global. If `_execute_block()`
+	# fails to restore `_environment` on the early return, the later lookup will
+	# incorrectly resolve the inner `x` instead of the outer one.
+	var source := _load_fixture("block_scope_restores_after_break.esc")
+	var compiler := ESCCompiler.new()
+	var scanner := ESCScanner.new()
+	scanner.set_source(source)
+	scanner.set_filename(_fixture_path("block_scope_restores_after_break.esc"))
+
+	var tokens: Array = scanner.scan_tokens()
+	var parser := ESCParser.new()
+	parser.init(compiler, tokens, "")
+
+	var statements := parser.parse()
+	assert_bool(compiler.had_error).is_false()
+	assert_int(statements.size()).is_equal(1)
+
+	var interpreter := ESCInterpreter.new([], {})
+	var resolver := ESCResolver.new(interpreter)
+	resolver.resolve(statements)
+
+	await interpreter.interpret(statements)
+
+	var globals := interpreter.get_global_values()
+	assert_bool(globals.has("result")).is_true()
+	assert_float(float(globals["result"])).is_equal(1.0)
+
+	interpreter.cleanup()
+
+
+func test_invalid_numeric_comparison_does_not_succeed_silently() -> void:
+	# This fixture performs an invalid numeric comparison. Invalid numeric
+	# operations should log an interpreter error and evaluate to `null` rather
+	# than continuing into a native GDScript operator error.
+	var source := _load_fixture("invalid_numeric_comparison.esc")
+	var compiler := ESCCompiler.new()
+	var scanner := ESCScanner.new()
+	scanner.set_source(source)
+	scanner.set_filename(_fixture_path("invalid_numeric_comparison.esc"))
+
+	var tokens: Array = scanner.scan_tokens()
+	var parser := ESCParser.new()
+	parser.init(compiler, tokens, "")
+
+	var statements := parser.parse()
+	assert_bool(compiler.had_error).is_false()
+	assert_int(statements.size()).is_equal(1)
+
+	var interpreter := ESCInterpreter.new([], {})
+	var resolver := ESCResolver.new(interpreter)
+	resolver.resolve(statements)
+
+	await interpreter.interpret(statements)
+
+	var globals := interpreter.get_global_values()
+	assert_bool(globals.has("result")).is_true()
+	assert_bool(globals["result"] == null).is_true()
+
+	interpreter.cleanup()
+
+
+func test_print_with_zero_arguments_does_not_native_crash() -> void:
+	# This fixture calls the builtin `print()` with zero arguments. The current
+	# implementation only rejects calls with more than one argument, so this
+	# test captures the actual runtime behavior before we decide on a fix.
+	var source := _load_fixture("print_zero_args.esc")
+	var compiler := ESCCompiler.new()
+	var scanner := ESCScanner.new()
+	scanner.set_source(source)
+	scanner.set_filename(_fixture_path("print_zero_args.esc"))
+
+	var tokens: Array = scanner.scan_tokens()
+	var parser := ESCParser.new()
+	parser.init(compiler, tokens, "")
+
+	var statements := parser.parse()
+	assert_bool(compiler.had_error).is_false()
+	assert_int(statements.size()).is_equal(1)
+
+	var interpreter := ESCInterpreter.new([], {})
+	var resolver := ESCResolver.new(interpreter)
+	resolver.resolve(statements)
+
+	await interpreter.interpret(statements)
+
+	interpreter.cleanup()
+
+
+func test_print_with_two_arguments_does_not_native_crash() -> void:
+	# This fixture calls the builtin `print()` with too many arguments. The
+	# builtin should reject the call cleanly and avoid any native runtime error.
+	var source := _load_fixture("print_two_args.esc")
+	var compiler := ESCCompiler.new()
+	var scanner := ESCScanner.new()
+	scanner.set_source(source)
+	scanner.set_filename(_fixture_path("print_two_args.esc"))
+
+	var tokens: Array = scanner.scan_tokens()
+	var parser := ESCParser.new()
+	parser.init(compiler, tokens, "")
+
+	var statements := parser.parse()
+	assert_bool(compiler.had_error).is_false()
+	assert_int(statements.size()).is_equal(1)
+
+	var interpreter := ESCInterpreter.new([], {})
+	var resolver := ESCResolver.new(interpreter)
+	resolver.resolve(statements)
+
+	await interpreter.interpret(statements)
+
+	interpreter.cleanup()
+
+
+func test_stop_in_nested_block_prevents_later_statements() -> void:
+	# `stop` should unwind the current event immediately, even when it is issued
+	# from inside a nested block. The later assignment must therefore never run.
+	var outcome := await _interpret_fixture("stop_nested_block.esc")
+	var globals: Dictionary = outcome.globals
+	assert_bool(globals.has("result")).is_true()
+	assert_float(float(globals["result"])).is_equal(0.0)
+
+
+func test_done_in_nested_dialog_block_prevents_later_statements() -> void:
+	# `done` should conclude the current dialog from inside a nested block, but
+	# it must not abort the rest of the event. The assignment after the dialog
+	# should still execute, proving the dialog exits cleanly without leaking a
+	# control-flow sentinel to the enclosing event body.
+	var outcome := await _interpret_fixture(
+		"done_nested_block_in_dialog.esc",
+		[0]
+	)
+	var globals: Dictionary = outcome.globals
+	assert_bool(globals.has("result")).is_true()
+	assert_float(float(globals["result"])).is_equal(1.0)
+
+
+func test_break_one_returns_to_parent_dialog_level() -> void:
+	# `break 1` should move dialog control back up one level, not continue the
+	# remainder of the current outer option body. The scripted choice sequence
+	# must therefore consume a third outer-dialog choice after the nested break;
+	# if the dialog ends early instead, the final string alone is ambiguous.
+	var outcome := await _interpret_fixture(
+		"nested_dialog_break_one.esc",
+		[0, 0, 1]
+	)
+	assert_bool(outcome.globals.has("result")).is_true()
+	assert_str(String(outcome.globals["result"])).is_equal("start-done")
+	assert_int(int(outcome.dialog_choices_consumed)).is_equal(3)
+	assert_int(int(outcome.remaining_dialog_choices)).is_equal(0)
+
+
+func test_done_exits_entire_nested_dialog_tree() -> void:
+	# `done` should conclude the entire dialog from any nesting depth. After the
+	# nested choice issues `done`, the outer option body must not continue and
+	# the outer dialog must not be shown again. Execution should resume only
+	# after the dialog statement, so the final value should reflect the initial
+	# value plus the post-dialog append.
+	var outcome := await _interpret_fixture(
+		"done_exits_entire_nested_dialog.esc",
+		[0, 0]
+	)
+	var globals: Dictionary = outcome.globals
+	assert_bool(globals.has("result")).is_true()
+	assert_str(String(globals["result"])).is_equal("start-done")
+
+
+func test_dialog_followup_runs_after_all_options_are_exhausted() -> void:
+	# When each option invalidates itself, the dialog should conclude once no
+	# valid options remain. Execution must then continue with the statement after
+	# the dialog block.
+	var outcome := await _interpret_fixture(
+		"dialog_exhausted_options_runs_followup.esc",
+		[0, 0]
+	)
+	var globals: Dictionary = outcome.globals
+	assert_bool(globals.has("result")).is_true()
+	assert_str(String(globals["result"])).is_equal("start-say1-say2-finished")
+	assert_bool(bool(globals["option1_is_valid"])).is_false()
+	assert_bool(bool(globals["option2_is_valid"])).is_false()
+	assert_int(int(outcome.dialog_choices_consumed)).is_equal(2)
+	assert_int(int(outcome.remaining_dialog_choices)).is_equal(0)
+
+
+func test_break_two_exits_two_dialog_levels() -> void:
+	# `break 2` from the innermost dialog should move back up two dialog levels
+	# to the outermost dialog in this fixture shape. As with `break 1`, the test
+	# also verifies that the final scripted outer choice was actually consumed,
+	# which proves the outer dialog stayed alive after the nested unwind.
+	var outcome := await _interpret_fixture(
+		"break_two_exits_two_dialog_levels.esc",
+		[0, 0, 0, 1]
+	)
+	assert_bool(outcome.globals.has("result")).is_true()
+	assert_str(String(outcome.globals["result"])).is_equal("start-done")
+	assert_int(int(outcome.dialog_choices_consumed)).is_equal(4)
+	assert_int(int(outcome.remaining_dialog_choices)).is_equal(0)
+
+
+func test_stop_in_dialog_option_prevents_later_event_statements() -> void:
+	# `stop` issued from a dialog option should abort the entire event, not just
+	# the current dialog. The assignment after the dialog must therefore never run.
+	var outcome := await _interpret_fixture(
+		"stop_in_dialog_option.esc",
+		[0]
+	)
+	assert_bool(outcome.globals.has("result")).is_true()
+	assert_float(float(outcome.globals["result"])).is_equal(0.0)
+
+
+func test_delayed_command_in_dialog_option_preserves_ordering() -> void:
+	# A blocking command inside a dialog option must complete before the option
+	# body resumes and before execution continues after the dialog. If it does
+	# not block correctly, the final append would observe `unset` instead of the
+	# command-written value.
+	var outcome := await _interpret_fixture(
+		"delayed_command_in_dialog_option.esc",
+		[0]
+	)
+	assert_bool(outcome.globals.has("result")).is_true()
+	assert_str(String(outcome.globals["result"])).is_equal("cmd-after")
+
+
+func test_delayed_command_in_loop_preserves_ordering() -> void:
+	# A blocking command inside a loop body must finish before the loop can
+	# continue to the next statement. The later append therefore proves the
+	# delayed command completed before the event resumed after the loop.
+	var outcome := await _interpret_fixture("delayed_command_in_loop.esc")
+	assert_bool(outcome.globals.has("result")).is_true()
+	assert_str(String(outcome.globals["result"])).is_equal("cmd-after")
+	assert_bool(outcome.globals.has("count")).is_true()
+	assert_float(float(outcome.globals["count"])).is_equal(1.0)
+
+
+func test_interrupting_delayed_command_stops_event_progress() -> void:
+	# Interrupting an in-flight command should stop the surrounding event from
+	# resuming normal execution. The command records that it observed the
+	# interrupt, and the later append must never run.
+	var source := _load_fixture("delayed_command_interrupt.esc")
+	var compiler := ESCCompiler.new()
+	var scanner := ESCScanner.new()
+	scanner.set_source(source)
+	scanner.set_filename(_fixture_path("delayed_command_interrupt.esc"))
+
+	var tokens: Array = scanner.scan_tokens()
+	var parser := ESCParser.new()
+	parser.init(compiler, tokens, "")
+
+	var statements := parser.parse()
+	assert_bool(compiler.had_error).is_false()
+	assert_int(statements.size()).is_equal(1)
+
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	resolver.resolve(statements)
+
+	assert_object(statements[0]).is_instanceof(ESCGrammarStmts.Event)
+	var event_stmt: ESCGrammarStmts.Event = statements[0]
+	interpreter.call_deferred("interpret", statements)
+	await escoria.get_tree().create_timer(0.05).timeout
+	interpreter.interrupt()
+	await event_stmt.finished
+
+	var globals := interpreter.get_global_values()
+	assert_bool(globals.has("result")).is_true()
+	assert_str(String(globals["result"])).is_equal("start")
+	assert_bool(globals.has("was_interrupted")).is_true()
+	assert_bool(bool(globals["was_interrupted"])).is_true()
+	assert_bool(event_stmt.is_interrupted()).is_true()
+
+	interpreter.cleanup()
+
+
+func test_interrupting_delayed_command_in_dialog_stops_event_progress() -> void:
+	# Interrupting an in-flight command inside a dialog option should abort the
+	# surrounding event just as cleanly as interruption in a plain block. The
+	# dialog must not resume and the post-dialog append must never run.
+	var source := _load_fixture("delayed_command_interrupt_in_dialog.esc")
+	var compiler := ESCCompiler.new()
+	var scanner := ESCScanner.new()
+	scanner.set_source(source)
+	scanner.set_filename(_fixture_path("delayed_command_interrupt_in_dialog.esc"))
+
+	var tokens: Array = scanner.scan_tokens()
+	var parser := ESCParser.new()
+	parser.init(compiler, tokens, "")
+
+	var statements := parser.parse()
+	assert_bool(compiler.had_error).is_false()
+	assert_int(statements.size()).is_equal(1)
+
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	resolver.resolve(statements)
+	var dialog_player := DialogPlayerDouble.new([0])
+	escoria.set("dialog_player", dialog_player)
+
+	assert_object(statements[0]).is_instanceof(ESCGrammarStmts.Event)
+	var event_stmt: ESCGrammarStmts.Event = statements[0]
+	interpreter.call_deferred("interpret", statements)
+	await escoria.get_tree().create_timer(0.05).timeout
+	interpreter.interrupt()
+	await event_stmt.finished
+
+	var globals := interpreter.get_global_values()
+	assert_bool(globals.has("result")).is_true()
+	assert_str(String(globals["result"])).is_equal("start")
+	assert_bool(globals.has("was_interrupted")).is_true()
+	assert_bool(bool(globals["was_interrupted"])).is_true()
+	assert_bool(event_stmt.is_interrupted()).is_true()
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_interrupting_delayed_command_stops_multi_iteration_loop() -> void:
+	# Interrupting a delayed command in the first loop iteration should stop the
+	# loop itself, not just the current statement. The counter must therefore
+	# stay at zero and the post-loop append must never run.
+	var source := _load_fixture("delayed_command_interrupt_in_multi_loop.esc")
+	var compiler := ESCCompiler.new()
+	var scanner := ESCScanner.new()
+	scanner.set_source(source)
+	scanner.set_filename(_fixture_path("delayed_command_interrupt_in_multi_loop.esc"))
+
+	var tokens: Array = scanner.scan_tokens()
+	var parser := ESCParser.new()
+	parser.init(compiler, tokens, "")
+
+	var statements := parser.parse()
+	assert_bool(compiler.had_error).is_false()
+	assert_int(statements.size()).is_equal(1)
+
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	resolver.resolve(statements)
+
+	assert_object(statements[0]).is_instanceof(ESCGrammarStmts.Event)
+	var event_stmt: ESCGrammarStmts.Event = statements[0]
+	interpreter.call_deferred("interpret", statements)
+	await escoria.get_tree().create_timer(0.05).timeout
+	interpreter.interrupt()
+	await event_stmt.finished
+
+	var globals := interpreter.get_global_values()
+	assert_bool(globals.has("result")).is_true()
+	assert_str(String(globals["result"])).is_equal("start")
+	assert_bool(globals.has("was_interrupted")).is_true()
+	assert_bool(bool(globals["was_interrupted"])).is_true()
+	assert_bool(globals.has("count")).is_true()
+	assert_float(float(globals["count"])).is_equal(0.0)
+	assert_bool(event_stmt.is_interrupted()).is_true()
+
+	interpreter.cleanup()
+
+
+func test_invalid_command_does_not_continue_event() -> void:
+	# A missing command should fail the current event cleanly instead of letting
+	# later statements continue as if the command had succeeded.
+	var outcome := await _interpret_fixture("invalid_command_does_not_continue.esc")
+	assert_bool(outcome.globals.has("result")).is_true()
+	assert_str(String(outcome.globals["result"])).is_equal("start")
+
+
+func test_invalid_command_in_dialog_does_not_continue_event() -> void:
+	# A missing command inside a dialog option should still terminate the event
+	# cleanly. The assignment after the dialog must not run.
+	var outcome := await _interpret_fixture(
+		"invalid_command_in_dialog_stops_event.esc",
+		[0]
+	)
+	assert_bool(outcome.globals.has("result")).is_true()
+	assert_str(String(outcome.globals["result"])).is_equal("start")
+
+
+func test_invalid_command_in_loop_does_not_continue_event() -> void:
+	# A missing command inside a loop body should escape the loop as a terminal
+	# runtime error instead of allowing later loop or post-loop statements to run.
+	var outcome := await _interpret_fixture("invalid_command_in_loop_stops_event.esc")
+	assert_bool(outcome.globals.has("result")).is_true()
+	assert_str(String(outcome.globals["result"])).is_equal("start")
+	assert_bool(outcome.globals.has("count")).is_true()
+	assert_float(float(outcome.globals["count"])).is_equal(0.0)
+
+
+func test_script_preserves_multi_target_use_events_without_creating_untargeted_use() -> void:
+	# Room05-style scripts can define the same action multiple times with
+	# different targets. Both targeted events must survive compilation, while an
+	# untargeted lookup for the same action must not accidentally match either.
+	var script_object := _compile_fixture_script("multi_target_use_events.esc")
+
+	assert_bool(script_object.has_event_with_target("use", "r5_wrench")).is_true()
+	assert_bool(script_object.has_event_with_target("use", "r5_pen")).is_true()
+	assert_bool(script_object.has_event_with_target("use")).is_false()
+
+	var wrench_event = script_object.get_event_with_target("use", "r5_wrench")
+	var pen_event = script_object.get_event_with_target("use", "r5_pen")
+
+	assert_object(wrench_event).is_not_null()
+	assert_object(pen_event).is_not_null()
+	assert_object(wrench_event).is_not_same(pen_event)
+	assert_str(wrench_event.get_target_name()).is_equal("r5_wrench")
+	assert_str(pen_event.get_target_name()).is_equal("r5_pen")
+	assert_int(wrench_event.get_num_statements_in_block()).is_equal(1)
+	assert_int(pen_event.get_num_statements_in_block()).is_equal(1)
+
+
+func test_dialog_option_scope_shadowing_restores_outer_local() -> void:
+	# A dialog option body introduces nested block scope. Assignments inside the
+	# option should see the inner shadowing variable, while execution after the
+	# dialog must still resolve the original outer local.
+	var outcome := await _interpret_fixture(
+		"dialog_scope_shadowing.esc",
+		[0]
+	)
+	assert_bool(outcome.globals.has("result")).is_true()
+	assert_str(String(outcome.globals["result"])).is_equal("inner:outer")
+
+
+func test_interrupting_background_channel_does_not_interrupt_front_channel() -> void:
+	# Background-channel interruption should only affect commands running on
+	# that channel. The front event must still complete normally while the
+	# background event should finish as interrupted once its in-flight command
+	# observes the interrupt.
+	var events = _load_fixture_events("channel_interrupt_isolation.esc")
+	assert_bool(events.has_event_with_target("front_event")).is_true()
+	assert_bool(events.has_event_with_target("background_event")).is_true()
+	escoria.globals_manager.set_global("channel_front_result", "start")
+	escoria.globals_manager.set_global("channel_background_result", "start")
+	escoria.globals_manager.set_global("channel_front_was_interrupted", false)
+	escoria.globals_manager.set_global("channel_background_was_interrupted", false)
+
+	var signal_results := {
+		"front": null,
+		"background": null,
+	}
+	var on_front_finished := func(return_code, event_name) -> void:
+		if event_name == "front_event":
+			signal_results["front"] = [return_code, event_name]
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if event_name == "background_event" and finished_channel_name == "bg_test":
+			signal_results["background"] = [return_code, event_name, finished_channel_name]
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_event(events.get_event_with_target("front_event"))
+	escoria.event_manager.queue_background_event(
+		"bg_test",
+		events.get_event_with_target("background_event")
+	)
+
+	await escoria.get_tree().create_timer(0.05).timeout
+	escoria.event_manager.interrupt_channel("bg_test")
+
+	while signal_results["front"] == null or signal_results["background"] == null:
+		await escoria.get_tree().process_frame
+
+	var front_finished = signal_results["front"]
+	var background_finished = signal_results["background"]
+
+	assert_int(int(front_finished[0])).is_equal(ESCExecution.RC_OK)
+	assert_int(int(background_finished[0])).is_equal(ESCExecution.RC_INTERRUPTED)
+	assert_str(String(escoria.globals_manager.get_global("channel_front_result"))).is_equal("front-cmd-after")
+	assert_bool(escoria.globals_manager.get_global("channel_front_was_interrupted") == true).is_false()
+	assert_str(String(escoria.globals_manager.get_global("channel_background_result"))).is_equal("start")
+	assert_bool(escoria.globals_manager.get_global("channel_background_was_interrupted") == true).is_true()
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_concurrent_channels_complete_without_interrupting_each_other() -> void:
+	# Two events on different channels should be able to run at the same time
+	# and still complete normally when no interrupt is issued.
+	var events = _load_fixture_events("channel_interrupt_isolation.esc")
+	assert_bool(events.has_event_with_target("front_event")).is_true()
+	assert_bool(events.has_event_with_target("background_event")).is_true()
+	escoria.globals_manager.set_global("channel_front_result", "start")
+	escoria.globals_manager.set_global("channel_background_result", "start")
+	escoria.globals_manager.set_global("channel_front_was_interrupted", false)
+	escoria.globals_manager.set_global("channel_background_was_interrupted", false)
+
+	var signal_results := {
+		"front": null,
+		"background": null,
+	}
+	var on_front_finished := func(return_code, event_name) -> void:
+		if event_name == "front_event":
+			signal_results["front"] = [return_code, event_name]
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if event_name == "background_event" and finished_channel_name == "bg_test":
+			signal_results["background"] = [return_code, event_name, finished_channel_name]
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_event(events.get_event_with_target("front_event"))
+	escoria.event_manager.queue_background_event(
+		"bg_test",
+		events.get_event_with_target("background_event")
+	)
+
+	while signal_results["front"] == null or signal_results["background"] == null:
+		await escoria.get_tree().process_frame
+
+	var front_finished = signal_results["front"]
+	var background_finished = signal_results["background"]
+
+	assert_int(int(front_finished[0])).is_equal(ESCExecution.RC_OK)
+	assert_int(int(background_finished[0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(escoria.globals_manager.get_global("channel_front_result"))).is_equal("front-cmd-after")
+	assert_bool(escoria.globals_manager.get_global("channel_front_was_interrupted") == true).is_false()
+	assert_str(String(escoria.globals_manager.get_global("channel_background_result"))).is_equal("bg-cmd-after")
+	assert_bool(escoria.globals_manager.get_global("channel_background_was_interrupted") == true).is_false()
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_interrupting_channel_clears_queued_successor_events() -> void:
+	# Interrupting a channel should stop the currently running event and purge
+	# later queued events on that same channel before they ever start running.
+	var events = _load_fixture_events("channel_interrupt_clears_queue.esc")
+	assert_bool(events.has_event_with_target("first")).is_true()
+	assert_bool(events.has_event_with_target("second")).is_true()
+	escoria.globals_manager.set_global("bg_queue_interrupted", false)
+
+	var background_finishes: Array = []
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if finished_channel_name == "bg_test":
+			background_finishes.append([return_code, event_name, finished_channel_name])
+
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("first"))
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("second"))
+
+	await escoria.get_tree().create_timer(0.05).timeout
+	escoria.event_manager.interrupt_channel("bg_test")
+
+	while background_finishes.is_empty():
+		await escoria.get_tree().process_frame
+
+	assert_int(background_finishes.size()).is_equal(1)
+	assert_int(int(background_finishes[0][0])).is_equal(ESCExecution.RC_INTERRUPTED)
+	assert_str(String(background_finishes[0][1])).is_equal("first")
+	assert_str(String(background_finishes[0][2])).is_equal("bg_test")
+	assert_str(String(escoria.globals_manager.get_global("bg_queue_result"))).is_equal("first")
+	assert_bool(escoria.globals_manager.get_global("bg_queue_interrupted") == true).is_true()
+
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_concurrent_channels_do_not_block_other_channel_queues() -> void:
+	# Each channel should serialize only its own queue. A front-channel event
+	# must complete independently while a background channel works through two
+	# queued events in order.
+	var events = _load_fixture_events("channel_queue_progress_isolated.esc")
+	assert_bool(events.has_event_with_target("front_event")).is_true()
+	assert_bool(events.has_event_with_target("background_first")).is_true()
+	assert_bool(events.has_event_with_target("background_second")).is_true()
+	escoria.globals_manager.set_global("isolated_front_result", "start")
+	escoria.globals_manager.set_global("isolated_background_result", "start")
+	escoria.globals_manager.set_global("isolated_front_interrupted", false)
+	escoria.globals_manager.set_global("isolated_background_interrupted", false)
+
+	var signal_results := {
+		"front": null,
+		"background_finishes": [],
+	}
+	var on_front_finished := func(return_code, event_name) -> void:
+		if event_name == "front_event":
+			signal_results["front"] = [return_code, event_name]
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if finished_channel_name == "bg_test":
+			signal_results["background_finishes"].append([return_code, event_name, finished_channel_name])
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_event(events.get_event_with_target("front_event"))
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("background_first"))
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("background_second"))
+
+	while signal_results["front"] == null or signal_results["background_finishes"].size() < 2:
+		await escoria.get_tree().process_frame
+
+	var front_finished = signal_results["front"]
+	var background_finishes: Array = signal_results["background_finishes"]
+
+	assert_int(int(front_finished[0])).is_equal(ESCExecution.RC_OK)
+	assert_int(int(background_finishes[0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(background_finishes[0][1])).is_equal("background_first")
+	assert_int(int(background_finishes[1][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(background_finishes[1][1])).is_equal("background_second")
+	assert_str(String(escoria.globals_manager.get_global("isolated_front_result"))).is_equal("front-cmd-after")
+	assert_bool(escoria.globals_manager.get_global("isolated_front_interrupted") == true).is_false()
+	assert_str(String(escoria.globals_manager.get_global("isolated_background_result"))).is_equal("first-cmd-after-first-second")
+	assert_bool(escoria.globals_manager.get_global("isolated_background_interrupted") == true).is_false()
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_global_interrupt_stops_running_channels_and_clears_queues() -> void:
+	# A global interrupt should stop every currently running channel and purge
+	# any queued successor events before they start. This fixture queues one
+	# running and one queued event on both `_front` and `bg_test`.
+	var events = _load_fixture_events("global_interrupt_clears_all_channels.esc")
+	assert_bool(events.has_event_with_target("front_running")).is_true()
+	assert_bool(events.has_event_with_target("front_queued")).is_true()
+	assert_bool(events.has_event_with_target("background_running")).is_true()
+	assert_bool(events.has_event_with_target("background_queued")).is_true()
+	escoria.globals_manager.set_global("global_interrupt_front_result", "start")
+	escoria.globals_manager.set_global("global_interrupt_background_result", "start")
+	escoria.globals_manager.set_global("global_interrupt_front_was_interrupted", false)
+	escoria.globals_manager.set_global("global_interrupt_background_was_interrupted", false)
+
+	var signal_results := {
+		"front_finishes": [],
+		"background_finishes": [],
+	}
+	var on_front_finished := func(return_code, event_name) -> void:
+		signal_results["front_finishes"].append([return_code, event_name])
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if finished_channel_name == "bg_test":
+			signal_results["background_finishes"].append([return_code, event_name, finished_channel_name])
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_event(events.get_event_with_target("front_running"))
+	escoria.event_manager.queue_event(events.get_event_with_target("front_queued"))
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("background_running"))
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("background_queued"))
+
+	await escoria.get_tree().create_timer(0.05).timeout
+	escoria.event_manager.interrupt()
+
+	while signal_results["front_finishes"].is_empty() or signal_results["background_finishes"].is_empty():
+		await escoria.get_tree().process_frame
+
+	await escoria.get_tree().create_timer(0.05).timeout
+
+	assert_int(signal_results["front_finishes"].size()).is_equal(1)
+	assert_int(int(signal_results["front_finishes"][0][0])).is_equal(ESCExecution.RC_INTERRUPTED)
+	assert_str(String(signal_results["front_finishes"][0][1])).is_equal("front_running")
+	assert_int(signal_results["background_finishes"].size()).is_equal(1)
+	assert_int(int(signal_results["background_finishes"][0][0])).is_equal(ESCExecution.RC_INTERRUPTED)
+	assert_str(String(signal_results["background_finishes"][0][1])).is_equal("background_running")
+	assert_str(String(signal_results["background_finishes"][0][2])).is_equal("bg_test")
+	assert_str(String(escoria.globals_manager.get_global("global_interrupt_front_result"))).is_equal("start")
+	assert_bool(escoria.globals_manager.get_global("global_interrupt_front_was_interrupted") == true).is_true()
+	assert_str(String(escoria.globals_manager.get_global("global_interrupt_background_result"))).is_equal("start")
+	assert_bool(escoria.globals_manager.get_global("global_interrupt_background_was_interrupted") == true).is_true()
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_queue_event_block_waits_for_correct_background_event_under_concurrency() -> void:
+	# Blocking queue_event waits must ignore unrelated background completions,
+	# including earlier events on the same channel, and return only when the
+	# specifically requested background event finishes.
+	var script_object := _compile_fixture_script("queue_event_block_waits_for_correct_background_event.esc")
+	assert_bool(script_object.has_event_with_target("background_first")).is_true()
+	assert_bool(script_object.has_event_with_target("background_target")).is_true()
+	assert_bool(script_object.has_event_with_target("front_event")).is_true()
+	escoria.globals_manager.set_global("block_wait_result", "start")
+	escoria.globals_manager.set_global("block_wait_front_result", "start")
+
+	escoria.event_manager.queue_background_event(
+		"bg_test",
+		script_object.get_event_with_target("background_first")
+	)
+	escoria.event_manager.queue_event(script_object.get_event_with_target("front_event"))
+
+	var block_rc: int = await escoria.event_manager.queue_event_from_esc(
+		script_object,
+		"background_target",
+		"bg_test",
+		true
+	)
+
+	assert_int(block_rc).is_equal(ESCExecution.RC_OK)
+	assert_str(String(escoria.globals_manager.get_global("block_wait_result"))).is_equal("first-target")
+	assert_str(String(escoria.globals_manager.get_global("block_wait_front_result"))).is_equal("front")
+
+
+func test_queue_event_block_waits_for_correct_front_event_under_concurrency() -> void:
+	# Blocking front queue_event waits must ignore both background completions
+	# and earlier foreground events, returning only when the specifically
+	# requested front event finishes.
+	var script_object := _compile_fixture_script("queue_event_block_waits_for_correct_front_event.esc")
+	assert_bool(script_object.has_event_with_target("front_first")).is_true()
+	assert_bool(script_object.has_event_with_target("front_target")).is_true()
+	assert_bool(script_object.has_event_with_target("background_event")).is_true()
+	escoria.globals_manager.set_global("front_block_wait_result", "start")
+	escoria.globals_manager.set_global("front_block_wait_background_result", "start")
+
+	escoria.event_manager.queue_event(script_object.get_event_with_target("front_first"))
+	escoria.event_manager.queue_background_event(
+		"bg_test",
+		script_object.get_event_with_target("background_event")
+	)
+
+	var block_rc: int = await escoria.event_manager.queue_event_from_esc(
+		script_object,
+		"front_target",
+		"_front",
+		true
+	)
+
+	assert_int(block_rc).is_equal(ESCExecution.RC_OK)
+	assert_str(String(escoria.globals_manager.get_global("front_block_wait_result"))).is_equal("first-target")
+	assert_str(String(escoria.globals_manager.get_global("front_block_wait_background_result"))).is_equal("background")
+
+
+func test_sequential_front_events_preserve_globals_between_runtime_interpreters() -> void:
+	# Each event-manager run currently observes globals written by earlier runs.
+	# The ownership refactor must preserve that user-visible behavior even though
+	# the underlying interpreter instances will stop sharing a singleton slot.
+	var events = _load_fixture_events("interpreter_runtime_state_persists_between_events.esc")
+	assert_bool(events.has_event_with_target("first")).is_true()
+	assert_bool(events.has_event_with_target("second")).is_true()
+
+	var front_finishes: Array = []
+	var on_front_finished := func(return_code, event_name) -> void:
+		front_finishes.append([return_code, event_name])
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+
+	escoria.event_manager.queue_event(events.get_event_with_target("first"))
+	while front_finishes.size() < 1:
+		await escoria.get_tree().process_frame
+
+	escoria.event_manager.queue_event(events.get_event_with_target("second"))
+	while front_finishes.size() < 2:
+		await escoria.get_tree().process_frame
+
+	assert_int(front_finishes.size()).is_equal(2)
+	assert_int(int(front_finishes[0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(front_finishes[0][1])).is_equal("first")
+	assert_int(int(front_finishes[1][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(front_finishes[1][1])).is_equal("second")
+	assert_str(String(escoria.globals_manager.get_global("interpreter_runtime_result"))).is_equal("first-second")
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+
+
+func test_background_event_sees_globals_written_by_previous_front_event() -> void:
+	# Front and background channels each create their own runtime interpreter.
+	# A background event queued after a front event must still observe globals
+	# written by that earlier front-channel execution.
+	var events = _load_fixture_events("interpreter_runtime_state_persists_between_events.esc")
+	assert_bool(events.has_event_with_target("background_seed")).is_true()
+	assert_bool(events.has_event_with_target("background_after")).is_true()
+
+	var front_finishes: Array = []
+	var background_finishes: Array = []
+	var on_front_finished := func(return_code, event_name) -> void:
+		front_finishes.append([return_code, event_name])
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if finished_channel_name == "bg_test":
+			background_finishes.append([return_code, event_name, finished_channel_name])
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_event(events.get_event_with_target("background_seed"))
+	while front_finishes.size() < 1:
+		await escoria.get_tree().process_frame
+
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("background_after"))
+	while background_finishes.size() < 1:
+		await escoria.get_tree().process_frame
+
+	assert_int(front_finishes.size()).is_equal(1)
+	assert_int(int(front_finishes[0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(front_finishes[0][1])).is_equal("background_seed")
+	assert_int(background_finishes.size()).is_equal(1)
+	assert_int(int(background_finishes[0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(background_finishes[0][1])).is_equal("background_after")
+	assert_str(String(background_finishes[0][2])).is_equal("bg_test")
+	assert_str(String(escoria.globals_manager.get_global("interpreter_runtime_background_result"))).is_equal("first-background")
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_running_interpreter_sees_new_global_defined_by_other_channel() -> void:
+	# A runtime interpreter that is already running must observe globals declared
+	# by a concurrent channel after it has started. Otherwise overlapping events
+	# can regress from shared-global behavior to "Undefined variable" failures.
+	var events = _load_fixture_events("concurrent_new_global_visibility.esc")
+	assert_bool(events.has_event_with_target("front_waits_for_new_global")).is_true()
+	assert_bool(events.has_event_with_target("background_declares_new_global")).is_true()
+
+	var front_finishes: Array = []
+	var background_finishes: Array = []
+	var on_front_finished := func(return_code, event_name) -> void:
+		front_finishes.append([return_code, event_name])
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if finished_channel_name == "bg_test":
+			background_finishes.append([return_code, event_name, finished_channel_name])
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_event(events.get_event_with_target("front_waits_for_new_global"))
+	await escoria.get_tree().create_timer(0.05).timeout
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("background_declares_new_global"))
+
+	while front_finishes.is_empty() or background_finishes.is_empty():
+		await escoria.get_tree().process_frame
+
+	assert_int(int(front_finishes[0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(str(front_finishes[0][1])).is_equal("front_waits_for_new_global")
+	assert_int(int(background_finishes[0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(str(background_finishes[0][1])).is_equal("background_declares_new_global")
+	assert_str(str(escoria.globals_manager.get_global("concurrent_visibility_result"))).is_equal("from-background")
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_queue_background_event_allows_consecutive_duplicate_queue_entries() -> void:
+	# Queueing the same background event twice in a row should be allowed on a
+	# background channel. In practice these queues are populated via ASHES
+	# commands, so the second request should remain queued behind the first run.
+	var events = _load_fixture_events("background_duplicate_suppression.esc")
+	assert_bool(events.has_event_with_target("repeat_event")).is_true()
+	escoria.globals_manager.set_global("background_duplicate_count", 0)
+	escoria.globals_manager.set_global("background_duplicate_last", "start")
+
+	var background_finishes: Array = []
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if finished_channel_name == "bg_test":
+			background_finishes.append([return_code, event_name, finished_channel_name])
+
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("repeat_event"))
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("repeat_event"))
+
+	while background_finishes.size() < 2:
+		await escoria.get_tree().process_frame
+
+	assert_int(background_finishes.size()).is_equal(2)
+	assert_int(int(background_finishes[0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(background_finishes[0][1])).is_equal("repeat_event")
+	assert_str(String(background_finishes[0][2])).is_equal("bg_test")
+	assert_int(int(background_finishes[1][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(background_finishes[1][1])).is_equal("repeat_event")
+	assert_str(String(background_finishes[1][2])).is_equal("bg_test")
+	assert_int(int(escoria.globals_manager.get_global("background_duplicate_count"))).is_equal(2)
+	assert_str(String(escoria.globals_manager.get_global("background_duplicate_last"))).is_equal("tick")
+
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_queue_background_event_allows_same_event_after_current_run_starts() -> void:
+	# Once the first background event is already running, queueing the same event
+	# again on that channel should queue a second run behind it instead of being
+	# suppressed as a duplicate.
+	var events = _load_fixture_events("background_duplicate_suppression.esc")
+	assert_bool(events.has_event_with_target("repeat_event")).is_true()
+	escoria.globals_manager.set_global("background_duplicate_count", 0)
+	escoria.globals_manager.set_global("background_duplicate_last", "start")
+
+	var background_finishes: Array = []
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if finished_channel_name == "bg_test":
+			background_finishes.append([return_code, event_name, finished_channel_name])
+
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("repeat_event"))
+	await escoria.get_tree().create_timer(0.01).timeout
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("repeat_event"))
+
+	while background_finishes.size() < 2:
+		await escoria.get_tree().process_frame
+
+	assert_int(background_finishes.size()).is_equal(2)
+	assert_int(int(background_finishes[0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(background_finishes[0][1])).is_equal("repeat_event")
+	assert_int(int(background_finishes[1][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(background_finishes[1][1])).is_equal("repeat_event")
+	assert_int(int(escoria.globals_manager.get_global("background_duplicate_count"))).is_equal(2)
+	assert_str(String(escoria.globals_manager.get_global("background_duplicate_last"))).is_equal("tick")
+
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_global_interrupt_preserves_exception_events() -> void:
+	# `interrupt(exceptions=...)` should leave only the named running and queued
+	# events alive. Here the front running event and one queued background event
+	# are excepted, while the other front/background events must be cleared.
+	var events = _load_fixture_events("global_interrupt_preserves_exceptions.esc")
+	assert_bool(events.has_event_with_target("front_keep")).is_true()
+	assert_bool(events.has_event_with_target("front_drop")).is_true()
+	assert_bool(events.has_event_with_target("background_drop")).is_true()
+	assert_bool(events.has_event_with_target("background_keep")).is_true()
+	escoria.globals_manager.set_global("interrupt_except_front_result", "start")
+	escoria.globals_manager.set_global("interrupt_except_front_interrupted", false)
+	escoria.globals_manager.set_global("interrupt_except_background_result", "start")
+	escoria.globals_manager.set_global("interrupt_except_background_interrupted", false)
+	escoria.globals_manager.set_global("interrupt_except_background_keep_result", "start")
+
+	var signal_results := {
+		"front_finishes": [],
+		"background_finishes": [],
+	}
+	var on_front_finished := func(return_code, event_name) -> void:
+		signal_results["front_finishes"].append([return_code, event_name])
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if finished_channel_name == "bg_test":
+			signal_results["background_finishes"].append([return_code, event_name, finished_channel_name])
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_event(events.get_event_with_target("front_keep"))
+	escoria.event_manager.queue_event(events.get_event_with_target("front_drop"))
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("background_drop"))
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("background_keep"))
+
+	await escoria.get_tree().create_timer(0.05).timeout
+	escoria.event_manager.interrupt(PackedStringArray(["front_keep", "background_keep"]))
+
+	while signal_results["front_finishes"].is_empty() or signal_results["background_finishes"].size() < 2:
+		await escoria.get_tree().process_frame
+
+	assert_int(signal_results["front_finishes"].size()).is_equal(1)
+	assert_int(int(signal_results["front_finishes"][0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(signal_results["front_finishes"][0][1])).is_equal("front_keep")
+	assert_int(signal_results["background_finishes"].size()).is_equal(2)
+	assert_int(int(signal_results["background_finishes"][0][0])).is_equal(ESCExecution.RC_INTERRUPTED)
+	assert_str(String(signal_results["background_finishes"][0][1])).is_equal("background_drop")
+	assert_int(int(signal_results["background_finishes"][1][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(signal_results["background_finishes"][1][1])).is_equal("background_keep")
+	assert_str(String(escoria.globals_manager.get_global("interrupt_except_front_result"))).is_equal("front-cmd-after")
+	assert_bool(escoria.globals_manager.get_global("interrupt_except_front_interrupted") == true).is_false()
+	assert_str(String(escoria.globals_manager.get_global("interrupt_except_background_result"))).is_equal("start")
+	assert_bool(escoria.globals_manager.get_global("interrupt_except_background_interrupted") == true).is_true()
+	assert_str(String(escoria.globals_manager.get_global("interrupt_except_background_keep_result"))).is_equal("bg-keep-after")
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_scheduled_front_event_runs_after_current_front_event_while_background_is_busy() -> void:
+	# Scheduled events always feed the `_front` queue. They should still dispatch
+	# while a background channel is busy, but must wait for the current front
+	# event to finish before the scheduled front event runs.
+	var events = _load_fixture_events("scheduled_front_event_with_busy_background.esc")
+	assert_bool(events.has_event_with_target("front_running")).is_true()
+	assert_bool(events.has_event_with_target("scheduled_front")).is_true()
+	assert_bool(events.has_event_with_target("background_running")).is_true()
+	escoria.globals_manager.set_global("scheduled_front_result", "start")
+	escoria.globals_manager.set_global("scheduled_front_interrupted", false)
+	escoria.globals_manager.set_global("scheduled_background_result", "start")
+	escoria.globals_manager.set_global("scheduled_background_interrupted", false)
+
+	var signal_results := {
+		"front_finishes": [],
+		"background_finishes": [],
+	}
+	var on_front_finished := func(return_code, event_name) -> void:
+		signal_results["front_finishes"].append([return_code, event_name])
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if finished_channel_name == "bg_test":
+			signal_results["background_finishes"].append([return_code, event_name, finished_channel_name])
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_event(events.get_event_with_target("front_running"))
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("background_running"))
+	escoria.event_manager.schedule_event(events.get_event_with_target("scheduled_front"), 0.05, "")
+
+	while signal_results["front_finishes"].size() < 2 or signal_results["background_finishes"].is_empty():
+		await escoria.get_tree().process_frame
+
+	assert_int(signal_results["front_finishes"].size()).is_equal(2)
+	assert_int(int(signal_results["front_finishes"][0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(signal_results["front_finishes"][0][1])).is_equal("front_running")
+	assert_int(int(signal_results["front_finishes"][1][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(signal_results["front_finishes"][1][1])).is_equal("scheduled_front")
+	assert_int(signal_results["background_finishes"].size()).is_equal(1)
+	assert_int(int(signal_results["background_finishes"][0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(signal_results["background_finishes"][0][1])).is_equal("background_running")
+	assert_str(String(escoria.globals_manager.get_global("scheduled_front_result"))).is_equal("front-running-after-scheduled")
+	assert_bool(escoria.globals_manager.get_global("scheduled_front_interrupted") == true).is_false()
+	assert_str(String(escoria.globals_manager.get_global("scheduled_background_result"))).is_equal("background-running-after")
+	assert_bool(escoria.globals_manager.get_global("scheduled_background_interrupted") == true).is_false()
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_global_interrupt_preserves_scheduled_events_before_dispatch() -> void:
+	# Global interrupt should stop the currently running event, but it should
+	# not clear scheduled events that have not yet been promoted into the front
+	# queue. The scheduled front event should therefore still dispatch and
+	# complete normally after the interrupted event finishes.
+	var events = _load_fixture_events("scheduled_event_interrupted_before_dispatch.esc")
+	assert_bool(events.has_event_with_target("front_running")).is_true()
+	assert_bool(events.has_event_with_target("scheduled_front")).is_true()
+	escoria.globals_manager.set_global("scheduled_interrupt_result", "start")
+	escoria.globals_manager.set_global("scheduled_interrupt_was_interrupted", false)
+
+	var front_finishes: Array = []
+	var on_front_finished := func(return_code, event_name) -> void:
+		front_finishes.append([return_code, event_name])
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+
+	escoria.event_manager.queue_event(events.get_event_with_target("front_running"))
+	escoria.event_manager.schedule_event(events.get_event_with_target("scheduled_front"), 0.2, "")
+
+	await escoria.get_tree().create_timer(0.05).timeout
+	escoria.event_manager.interrupt()
+
+	while front_finishes.is_empty():
+		await escoria.get_tree().process_frame
+
+	await escoria.get_tree().create_timer(0.25).timeout
+
+	assert_int(front_finishes.size()).is_equal(2)
+	assert_int(int(front_finishes[0][0])).is_equal(ESCExecution.RC_INTERRUPTED)
+	assert_str(String(front_finishes[0][1])).is_equal("front_running")
+	assert_int(int(front_finishes[1][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(front_finishes[1][1])).is_equal("scheduled_front")
+	assert_str(String(escoria.globals_manager.get_global("scheduled_interrupt_result"))).is_equal("start-scheduled")
+	assert_bool(escoria.globals_manager.get_global("scheduled_interrupt_was_interrupted") == true).is_true()
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+
+
+func test_clear_event_queue_preserves_scheduled_events() -> void:
+	# Clearing the event queue should only remove events that are already queued
+	# for execution. Scheduled events live in a separate list until `_process()`
+	# promotes them into the front queue, so they should still dispatch after
+	# `clear_event_queue()` is called.
+	var events = _load_fixture_events("scheduled_event_interrupted_before_dispatch.esc")
+	assert_bool(events.has_event_with_target("scheduled_front")).is_true()
+	escoria.globals_manager.set_global("scheduled_interrupt_result", "start")
+
+	var front_finishes: Array = []
+	var on_front_finished := func(return_code, event_name) -> void:
+		front_finishes.append([return_code, event_name])
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+
+	escoria.event_manager.schedule_event(events.get_event_with_target("scheduled_front"), 0.05, "")
+	escoria.event_manager.clear_event_queue()
+
+	while front_finishes.is_empty():
+		await escoria.get_tree().process_frame
+
+	assert_int(front_finishes.size()).is_equal(1)
+	assert_int(int(front_finishes[0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(front_finishes[0][1])).is_equal("scheduled_front")
+	assert_str(String(escoria.globals_manager.get_global("scheduled_interrupt_result"))).is_equal("start-scheduled")
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+
+
+func test_interrupt_channel_does_not_affect_still_scheduled_front_events() -> void:
+	# A scheduled front event should be unaffected by `interrupt_channel()` for a
+	# background channel while it is still waiting in `scheduled_events`. Once it
+	# is later promoted into `_front`, it should run like any other front-queue
+	# event.
+	var events = _load_fixture_events("scheduled_front_event_with_busy_background.esc")
+	assert_bool(events.has_event_with_target("scheduled_front")).is_true()
+	assert_bool(events.has_event_with_target("background_running")).is_true()
+	escoria.globals_manager.set_global("scheduled_front_result", "start")
+	escoria.globals_manager.set_global("scheduled_front_interrupted", false)
+	escoria.globals_manager.set_global("scheduled_background_result", "start")
+	escoria.globals_manager.set_global("scheduled_background_interrupted", false)
+
+	var signal_results := {
+		"front_finishes": [],
+		"background_finishes": [],
+	}
+	var on_front_finished := func(return_code, event_name) -> void:
+		signal_results["front_finishes"].append([return_code, event_name])
+	var on_background_finished := func(return_code, event_name, finished_channel_name) -> void:
+		if finished_channel_name == "bg_test":
+			signal_results["background_finishes"].append([return_code, event_name, finished_channel_name])
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+	escoria.event_manager.background_event_finished.connect(on_background_finished)
+
+	escoria.event_manager.queue_background_event("bg_test", events.get_event_with_target("background_running"))
+	escoria.event_manager.schedule_event(events.get_event_with_target("scheduled_front"), 0.2, "")
+
+	await escoria.get_tree().create_timer(0.05).timeout
+	escoria.event_manager.interrupt_channel("bg_test")
+
+	while signal_results["front_finishes"].is_empty() or signal_results["background_finishes"].is_empty():
+		await escoria.get_tree().process_frame
+
+	assert_int(signal_results["background_finishes"].size()).is_equal(1)
+	assert_int(int(signal_results["background_finishes"][0][0])).is_equal(ESCExecution.RC_INTERRUPTED)
+	assert_str(String(signal_results["background_finishes"][0][1])).is_equal("background_running")
+	assert_int(signal_results["front_finishes"].size()).is_equal(1)
+	assert_int(int(signal_results["front_finishes"][0][0])).is_equal(ESCExecution.RC_OK)
+	assert_str(String(signal_results["front_finishes"][0][1])).is_equal("scheduled_front")
+	assert_str(String(escoria.globals_manager.get_global("scheduled_front_result"))).is_equal("start-scheduled")
+	assert_bool(escoria.globals_manager.get_global("scheduled_front_interrupted") == true).is_false()
+	assert_str(String(escoria.globals_manager.get_global("scheduled_background_result"))).is_equal("start")
+	assert_bool(escoria.globals_manager.get_global("scheduled_background_interrupted") == true).is_true()
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+	escoria.event_manager.background_event_finished.disconnect(on_background_finished)
+
+
+func test_immediate_command_preserves_statement_ordering() -> void:
+	# A synchronous command should complete before the next statement runs. The
+	# trailing assignment observes the command's mutation and appends to it.
+	var outcome := await _interpret_fixture("immediate_command_ordering.esc")
+	var globals: Dictionary = outcome.globals
+	assert_bool(globals.has("result")).is_true()
+	assert_str(String(globals["result"])).is_equal("cmd-after")
+
+
+func test_delayed_command_preserves_statement_ordering() -> void:
+	# An asynchronous command must also block statement sequencing. If the
+	# interpreter failed to await it, the trailing assignment would append to the
+	# pre-command value instead of the command-written one.
+	var outcome := await _interpret_fixture("delayed_command_ordering.esc")
+	var globals: Dictionary = outcome.globals
+	assert_bool(globals.has("result")).is_true()
+	assert_str(String(globals["result"])).is_equal("cmd-after")
+
+
+func test_set_animations_updates_persisted_player_resource_on_repeat_calls() -> void:
+	# Room changes restore player animations from the reserved
+	# `ANIMATION_RESOURCES` global. Repeated `set_animations()` calls must update
+	# the stored path each time, otherwise the next room load re-applies a stale
+	# costume even if the live player was changed back already.
+	var previous_animations = escoria.globals_manager.get_global(
+		escoria.room_manager.GLOBAL_ANIMATION_RESOURCES
+	)
+	var room := ESCRoom.new()
+	room.global_id = "test_room_issue_1226"
+	escoria.object_manager.set_current_room(room)
+
+	var player := MARK_SCENE.instantiate() as ESCPlayer
+	player.global_id = "player"
+	escoria.object_manager.register_object(
+		ESCObject.new(player.global_id, player),
+		room,
+		true,
+		false
+	)
+	escoria.globals_manager.set_global(
+		escoria.room_manager.GLOBAL_ANIMATION_RESOURCES,
+		{},
+		true
+	)
+
+	var command := SetAnimationsCommand.new()
+	var jester_animations := "res://game/characters/mark/mark_animations_jester.tres"
+	var default_animations := "res://game/characters/mark/mark_animations.tres"
+
+	assert_int(command.run([player.global_id, jester_animations])).is_equal(ESCExecution.RC_OK)
+	assert_int(command.run([player.global_id, default_animations])).is_equal(ESCExecution.RC_OK)
+
+	var animations: Dictionary = escoria.globals_manager.get_global(
+		escoria.room_manager.GLOBAL_ANIMATION_RESOURCES
+	)
+	assert_bool(animations.has(player.global_id)).is_true()
+	assert_str(String(animations[player.global_id])).is_equal(default_animations)
+
+	var room_key := ESCRoomObjectsKey.new()
+	room_key.room_global_id = room.global_id
+	room_key.room_instance_id = room.get_instance_id()
+	escoria.object_manager.unregister_object_by_global_id(player.global_id, room_key)
+	escoria.globals_manager.set_global(
+		escoria.room_manager.GLOBAL_ANIMATION_RESOURCES,
+		previous_animations if previous_animations != null else {},
+		true
+	)
+	player.free()
+	room.free()
+
+
+func test_set_speed_rejects_negative_values_but_accepts_zero() -> void:
+	var room := ESCRoom.new()
+	room.global_id = "test_room_set_speed_contract"
+	escoria.object_manager.set_current_room(room)
+
+	var player := MARK_SCENE.instantiate() as ESCPlayer
+	player.global_id = "player"
+	escoria.object_manager.register_object(
+		ESCObject.new(player.global_id, player),
+		room,
+		true,
+		false
+	)
+
+	var command := SetSpeedCommand.new()
+	var initial_speed := player.speed
+
+	assert_bool(command.validate([player.global_id, -1])).is_false()
+	assert_int(player.speed).is_equal(initial_speed)
+
+	assert_bool(command.validate([player.global_id, 0])).is_true()
+	assert_int(command.run([player.global_id, 0])).is_equal(ESCExecution.RC_OK)
+	assert_int(player.speed).is_equal(0)
+
+	var room_key := ESCRoomObjectsKey.new()
+	room_key.room_global_id = room.global_id
+	room_key.room_instance_id = room.get_instance_id()
+	escoria.object_manager.unregister_object_by_global_id(player.global_id, room_key)
+	player.free()
+	room.free()
+
+
+func test_trigger_actions_select_targeted_events_for_activating_object() -> void:
+	var script_object := _compile_fixture_script("trigger_targeted_events_use_object_id.esc")
+	var room := ESCRoom.new()
+	room.global_id = "test_trigger_targeted_events_room"
+	escoria.object_manager.set_current_room(room)
+
+	var trigger_node := Node2D.new()
+	var trigger_object := ESCObject.new("trigger_under_test", trigger_node)
+	trigger_object.events = script_object.events
+	escoria.object_manager.register_object(trigger_object, room, true, false)
+
+	escoria.globals_manager.set_global("trigger_in_result", "unset", true)
+	escoria.globals_manager.set_global("trigger_out_result", "unset", true)
+
+	var finished_events: Array = []
+	var on_front_finished := func(return_code, event_name) -> void:
+		if return_code == ESCExecution.RC_OK:
+			finished_events.append(event_name)
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+
+	escoria.action_manager.do(
+		escoria.action_manager.ACTION.TRIGGER_IN,
+		[trigger_object.global_id, "player", "trigger_in"]
+	)
+
+	if not await _wait_for_finished_events(finished_events, 1, "targeted trigger_in"):
+		escoria.event_manager.event_finished.disconnect(on_front_finished)
+		_cleanup_registered_object(trigger_object, trigger_node, room)
+		return
+
+	assert_str(String(escoria.globals_manager.get_global("trigger_in_result"))).is_equal(
+		"player-in"
+	)
+	assert_str(String(finished_events[0])).is_equal("trigger_in")
+
+	escoria.action_manager.do(
+		escoria.action_manager.ACTION.TRIGGER_OUT,
+		[trigger_object.global_id, "player", "trigger_out"]
+	)
+
+	if not await _wait_for_finished_events(finished_events, 2, "targeted trigger_out"):
+		escoria.event_manager.event_finished.disconnect(on_front_finished)
+		_cleanup_registered_object(trigger_object, trigger_node, room)
+		return
+
+	assert_str(String(escoria.globals_manager.get_global("trigger_out_result"))).is_equal(
+		"player-out"
+	)
+	assert_str(String(finished_events[1])).is_equal("trigger_out")
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+
+	_cleanup_registered_object(trigger_object, trigger_node, room)
+
+
+func test_trigger_actions_fall_back_to_targetless_events() -> void:
+	var script_object := _compile_fixture_script("trigger_targeted_events_use_object_id.esc")
+	var room := ESCRoom.new()
+	room.global_id = "test_trigger_targetless_events_room"
+	escoria.object_manager.set_current_room(room)
+
+	var trigger_node := Node2D.new()
+	var trigger_object := ESCObject.new("trigger_under_test", trigger_node)
+	trigger_object.events = script_object.events
+	escoria.object_manager.register_object(trigger_object, room, true, false)
+
+	escoria.globals_manager.set_global("trigger_in_result", "unset", true)
+	escoria.globals_manager.set_global("trigger_out_result", "unset", true)
+
+	var finished_events: Array = []
+	var on_front_finished := func(return_code, event_name) -> void:
+		if return_code == ESCExecution.RC_OK:
+			finished_events.append(event_name)
+
+	escoria.event_manager.event_finished.connect(on_front_finished)
+
+	escoria.action_manager.do(
+		escoria.action_manager.ACTION.TRIGGER_IN,
+		[trigger_object.global_id, "unexpected_actor", "trigger_in"]
+	)
+
+	if not await _wait_for_finished_events(finished_events, 1, "targetless trigger_in fallback"):
+		escoria.event_manager.event_finished.disconnect(on_front_finished)
+		_cleanup_registered_object(trigger_object, trigger_node, room)
+		return
+
+	assert_str(String(escoria.globals_manager.get_global("trigger_in_result"))).is_equal(
+		"fallback-in"
+	)
+	assert_str(String(finished_events[0])).is_equal("trigger_in")
+
+	escoria.action_manager.do(
+		escoria.action_manager.ACTION.TRIGGER_OUT,
+		[trigger_object.global_id, "unexpected_actor", "trigger_out"]
+	)
+
+	if not await _wait_for_finished_events(finished_events, 2, "targetless trigger_out fallback"):
+		escoria.event_manager.event_finished.disconnect(on_front_finished)
+		_cleanup_registered_object(trigger_object, trigger_node, room)
+		return
+
+	assert_str(String(escoria.globals_manager.get_global("trigger_out_result"))).is_equal(
+		"fallback-out"
+	)
+	assert_str(String(finished_events[1])).is_equal("trigger_out")
+
+	escoria.event_manager.event_finished.disconnect(on_front_finished)
+
+	_cleanup_registered_object(trigger_object, trigger_node, room)
+
+
+func _cleanup_registered_object(trigger_object: ESCObject, trigger_node: Node, room: ESCRoom) -> void:
+	var room_key := ESCRoomObjectsKey.new()
+	room_key.room_global_id = room.global_id
+	room_key.room_instance_id = room.get_instance_id()
+	escoria.object_manager.unregister_object_by_global_id(trigger_object.global_id, room_key)
+	trigger_node.free()
+	room.free()
+
+
+func _wait_for_finished_events(
+	finished_events: Array,
+	expected_size: int,
+	context: String
+) -> bool:
+	for _frame in range(120):
+		if finished_events.size() >= expected_size:
+			return true
+
+		await escoria.get_tree().process_frame
+
+	fail(
+		"Timed out waiting for %s; expected %d finished event(s), got %d." % [
+			context,
+			expected_size,
+			finished_events.size()
+		]
+	)
+	return false
+
+
+func _interpret_fixture(name: String, dialog_choices: Array = []) -> Dictionary:
+	# Shared interpreter harness for fixture-based tests. This intentionally
+	# runs the full scan -> parse -> resolve -> interpret pipeline so the tests
+	# cover the real runtime path rather than isolated visitor calls.
+	var source := _load_fixture(name)
+	var compiler := ESCCompiler.new()
+	var scanner := ESCScanner.new()
+	scanner.set_source(source)
+	scanner.set_filename(_fixture_path(name))
+
+	var tokens: Array = scanner.scan_tokens()
+	var parser := ESCParser.new()
+	parser.init(compiler, tokens, "")
+
+	var statements := parser.parse()
+	assert_bool(compiler.had_error).is_false()
+	assert_int(statements.size()).is_equal(1)
+
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	resolver.resolve(statements)
+	var dialog_player = null
+
+	if not dialog_choices.is_empty():
+		# Install a temporary deterministic dialog player only for tests that
+		# need scripted choices, then clean it up afterward to avoid orphan nodes.
+		dialog_player = DialogPlayerDouble.new(dialog_choices)
+		escoria.set("dialog_player", dialog_player)
+
+	await interpreter.interpret(statements)
+
+	var globals := interpreter.get_global_values().duplicate(true)
+	var dialog_choices_consumed := 0
+	var remaining_dialog_choices := 0
+
+	if dialog_player:
+		dialog_choices_consumed = dialog_player.get_choices_consumed()
+		remaining_dialog_choices = dialog_player.get_remaining_choices()
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+	return {
+		"globals": globals,
+		"dialog_choices_consumed": dialog_choices_consumed,
+		"remaining_dialog_choices": remaining_dialog_choices,
+	}
+
+
+func test_dialog_start_args_are_passed_to_runtime_dialog() -> void:
+	var script_object := _compile_fixture_script("dialog_start_args_reach_runtime.esc")
+	var dialog_player := DialogPlayerDouble.new([1])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+	assert_int(dialog_player.get_choices_consumed()).is_equal(1)
+
+	var started_dialogs := dialog_player.get_dialogs_started()
+	assert_int(started_dialogs.size()).is_equal(1)
+	assert_str(started_dialogs[0]["avatar"]).is_equal("res://game/dialog_avatars/player.tres")
+	assert_int(started_dialogs[0]["timeout"]).is_equal(5)
+	assert_int(started_dialogs[0]["timeout_option"]).is_equal(2)
+	assert_int(started_dialogs[0]["authored_options_count"]).is_equal(2)
+	assert_int(started_dialogs[0]["options_size"]).is_equal(2)
+	assert_str(started_dialogs[0]["visible_timeout_option"]).is_equal("Second option")
+	assert_array(started_dialogs[0]["option_source_indexes"]).contains_exactly([1, 2])
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_dialog_timeout_option_uses_authored_index_after_filtering() -> void:
+	var script_object := _compile_fixture_script("dialog_timeout_visible_authored_default_after_filtering.esc")
+	var dialog_player := DialogPlayerDouble.new([1])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+	assert_int(dialog_player.get_choices_consumed()).is_equal(1)
+
+	var started_dialogs := dialog_player.get_dialogs_started()
+	assert_int(started_dialogs.size()).is_equal(1)
+	assert_int(started_dialogs[0]["timeout"]).is_equal(5)
+	assert_int(started_dialogs[0]["timeout_option"]).is_equal(3)
+	assert_int(started_dialogs[0]["authored_options_count"]).is_equal(3)
+	assert_int(started_dialogs[0]["options_size"]).is_equal(2)
+	assert_array(started_dialogs[0]["option_source_indexes"]).contains_exactly([2, 3])
+	assert_array(started_dialogs[0]["option_texts"]).contains_exactly(["Second option", "Third option"])
+	assert_str(started_dialogs[0]["visible_timeout_option"]).is_equal("Third option")
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_dialog_timeout_option_hidden_after_filtering_is_not_available() -> void:
+	var script_object := _compile_fixture_script("dialog_timeout_hidden_authored_default_after_filtering.esc")
+	var dialog_player := DialogPlayerDouble.new([0])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+	assert_int(dialog_player.get_choices_consumed()).is_equal(1)
+
+	var started_dialogs := dialog_player.get_dialogs_started()
+	assert_int(started_dialogs.size()).is_equal(1)
+	assert_int(started_dialogs[0]["timeout"]).is_equal(5)
+	assert_int(started_dialogs[0]["timeout_option"]).is_equal(1)
+	assert_int(started_dialogs[0]["authored_options_count"]).is_equal(3)
+	assert_int(started_dialogs[0]["options_size"]).is_equal(2)
+	assert_array(started_dialogs[0]["option_source_indexes"]).contains_exactly([2, 3])
+	assert_array(started_dialogs[0]["option_texts"]).contains_exactly(["Second option", "Third option"])
+	assert_object(started_dialogs[0]["visible_timeout_option"]).is_null()
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_simple_chooser_does_not_start_timer_when_timeout_default_is_hidden() -> void:
+	var dialog := ESCDialog.new()
+	dialog.timeout = 5
+	dialog.timeout_option = 1
+	dialog.authored_options_count = 2
+	dialog.options = [
+		_make_dialog_option("Visible option", 2),
+	]
+
+	var chooser = SIMPLE_CHOOSER_SCENE.instantiate()
+	add_child(chooser)
+	chooser.set_dialog(dialog)
+	chooser.show_chooser()
+
+	assert_bool(chooser.get_node("Timer").is_stopped()).is_true()
+	assert_float(chooser.get_node("TimerProgress").value).is_equal(0.0)
+
+	chooser.queue_free()
+
+
+func test_simple_chooser_starts_timer_when_timeout_default_is_visible() -> void:
+	var dialog := ESCDialog.new()
+	dialog.timeout = 5
+	dialog.timeout_option = 2
+	dialog.authored_options_count = 2
+	dialog.options = [
+		_make_dialog_option("First option", 1),
+		_make_dialog_option("Second option", 2),
+	]
+
+	var chooser = SIMPLE_CHOOSER_SCENE.instantiate()
+	add_child(chooser)
+	chooser.set_dialog(dialog)
+	chooser.show_chooser()
+
+	assert_bool(chooser.get_node("Timer").is_stopped()).is_false()
+
+	chooser.queue_free()
+
+
+func test_dialog_start_invalid_avatar_type_returns_error() -> void:
+	var script_object := _compile_fixture_script("dialog_start_invalid_avatar_type.esc")
+	var dialog_player := DialogPlayerDouble.new([])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+	assert_int(dialog_player.get_choices_consumed()).is_equal(0)
+	assert_int(dialog_player.get_dialogs_started().size()).is_equal(0)
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_dialog_start_invalid_timeout_type_returns_error() -> void:
+	var script_object := _compile_fixture_script("dialog_start_invalid_timeout_type.esc")
+	var dialog_player := DialogPlayerDouble.new([])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+	assert_int(dialog_player.get_choices_consumed()).is_equal(0)
+	assert_int(dialog_player.get_dialogs_started().size()).is_equal(0)
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_dialog_option_translation_key_is_passed_to_runtime_dialog() -> void:
+	var script_object := _compile_fixture_script("dialog_option_translation_key.esc")
+	var dialog_player := DialogPlayerDouble.new([0])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+	assert_int(dialog_player.get_choices_consumed()).is_equal(1)
+
+	var started_dialogs := dialog_player.get_dialogs_started()
+	assert_int(started_dialogs.size()).is_equal(1)
+	assert_array(started_dialogs[0]["option_keys"]).contains_exactly(["UNCLE_SVEN", ""])
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_dialog_start_invalid_timeout_option_type_returns_error() -> void:
+	var script_object := _compile_fixture_script("dialog_start_invalid_timeout_option_type.esc")
+	var dialog_player := DialogPlayerDouble.new([])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+	assert_int(dialog_player.get_choices_consumed()).is_equal(0)
+	assert_int(dialog_player.get_dialogs_started().size()).is_equal(0)
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_dialog_start_invalid_timeout_option_negative_returns_error() -> void:
+	var script_object := _compile_fixture_script("dialog_start_invalid_timeout_option_negative.esc")
+	var dialog_player := DialogPlayerDouble.new([])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+	assert_int(dialog_player.get_choices_consumed()).is_equal(0)
+	assert_int(dialog_player.get_dialogs_started().size()).is_equal(0)
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_dialog_option_translation_key_beats_legacy_prefix_fallback() -> void:
+	var script_object := _compile_fixture_script("dialog_option_translation_key_beats_legacy_prefix.esc")
+	var dialog_player := DialogPlayerDouble.new([0])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+
+	var started_dialogs := dialog_player.get_dialogs_started()
+	assert_int(started_dialogs.size()).is_equal(1)
+	assert_array(started_dialogs[0]["option_keys"]).contains_exactly(["OUTER_KEY"])
+	assert_array(started_dialogs[0]["option_texts"]).contains_exactly(["INNER_KEY:Fallback text"])
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_dialog_option_translation_key_with_condition_survives_runtime_filtering() -> void:
+	var script_object := _compile_fixture_script("dialog_option_translation_key_with_condition.esc")
+	var dialog_player := DialogPlayerDouble.new([0])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+
+	var started_dialogs := dialog_player.get_dialogs_started()
+	assert_int(started_dialogs.size()).is_equal(1)
+	assert_int(started_dialogs[0]["options_size"]).is_equal(1)
+	assert_array(started_dialogs[0]["option_keys"]).contains_exactly(["CONDITIONAL_KEY"])
+	assert_array(started_dialogs[0]["option_texts"]).contains_exactly(["Conditional option"])
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func test_dialog_option_translation_key_with_expression_preserves_key_and_value() -> void:
+	var script_object := _compile_fixture_script("dialog_option_translation_key_with_expression.esc")
+	var dialog_player := DialogPlayerDouble.new([0])
+	escoria.set("dialog_player", dialog_player)
+	var interpreter := ESCInterpreter.new(ESCCompiler.load_commands(), {})
+	var resolver := ESCResolver.new(interpreter)
+	var event: ESCGrammarStmts.Event = script_object.get_event_with_target("talk")
+
+	assert_object(event).is_not_null()
+
+	resolver.resolve(event)
+
+	await interpreter.interpret(event)
+
+	var started_dialogs := dialog_player.get_dialogs_started()
+	assert_int(started_dialogs.size()).is_equal(1)
+	assert_array(started_dialogs[0]["option_keys"]).contains_exactly(["DYNAMIC_KEY"])
+	assert_array(started_dialogs[0]["option_texts"]).contains_exactly(["Dynamic option"])
+
+	_cleanup_dialog_test(interpreter, dialog_player)
+
+
+func _cleanup_dialog_test(interpreter: ESCInterpreter, dialog_player: DialogPlayerDouble) -> void:
+	interpreter.cleanup()
+
+	if dialog_player:
+		escoria.set("dialog_player", null)
+		dialog_player.queue_free()
+
+
+func test_compiler_rejects_exact_duplicate_event_targets() -> void:
+	var source := _load_fixture("duplicate_exact_target_event_overwrites.esc")
+	var compiler := ESCCompiler.new()
+	var script_object := compiler.compile(source)
+
+	assert_bool(compiler.had_error).is_true()
+	assert_int(script_object.events.events.size()).is_equal(1)
+	assert_object(script_object.get_event_with_target("use", "wrench")).is_not_null()
+
+
+func _load_fixture(name: String) -> String:
+	return FileAccess.get_file_as_string(_fixture_path(name))
+
+
+func _load_fixture_events(name: String):
+	var script_object := _compile_fixture_script(name)
+	return script_object.events
+
+
+func _compile_fixture_script(name: String) -> ESCScript:
+	var source := _load_fixture(name)
+	var compiler := ESCCompiler.new()
+	var script_object := compiler.compile(source, _fixture_path(name))
+	assert_bool(compiler.had_error).is_false()
+	return script_object
+
+
+func _fixture_path(name: String) -> String:
+	return "res://addons/escoria-core/testing/ashes/interpreter/fixtures/%s" % name
+
+
+func _make_dialog_option(text: String, source_option_index: int) -> ESCDialogOption:
+	var option := ESCDialogOption.new()
+	option.option = text
+	option.source_option_index = source_option_index
+	option.set_is_valid(true)
+	return option