diff --git a/packages/flame_jenny/jenny/lib/jenny.dart b/packages/flame_jenny/jenny/lib/jenny.dart
index ce868ff82fc..7d26f0cb1e4 100644
--- a/packages/flame_jenny/jenny/lib/jenny.dart
+++ b/packages/flame_jenny/jenny/lib/jenny.dart
@@ -1,2 +1,10 @@
-export 'src/errors.dart' show SyntaxError, NameError, TypeError;
+export 'src/dialogue_runner.dart' show DialogueRunner;
+export 'src/dialogue_view.dart' show DialogueView;
+export 'src/errors.dart' show SyntaxError, NameError, TypeError, DialogueError;
+export 'src/structure/dialogue_choice.dart' show DialogueChoice;
+export 'src/structure/dialogue_line.dart' show DialogueLine;
+export 'src/structure/expressions/expression_type.dart' show ExpressionType;
+export 'src/structure/node.dart' show Node;
+export 'src/structure/option.dart' show Option;
+export 'src/variable_storage.dart' show VariableStorage;
 export 'src/yarn_project.dart' show YarnProject;
diff --git a/packages/flame_jenny/jenny/lib/src/dialogue_runner.dart b/packages/flame_jenny/jenny/lib/src/dialogue_runner.dart
new file mode 100644
index 00000000000..24811fb3b62
--- /dev/null
+++ b/packages/flame_jenny/jenny/lib/src/dialogue_runner.dart
@@ -0,0 +1,257 @@
+import 'dart:async';
+
+import 'package:jenny/src/dialogue_view.dart';
+import 'package:jenny/src/errors.dart';
+import 'package:jenny/src/structure/block.dart';
+import 'package:jenny/src/structure/commands/command.dart';
+import 'package:jenny/src/structure/dialogue_choice.dart';
+import 'package:jenny/src/structure/dialogue_line.dart';
+import 'package:jenny/src/structure/node.dart';
+import 'package:jenny/src/structure/statement.dart';
+import 'package:jenny/src/yarn_project.dart';
+import 'package:meta/meta.dart';
+
+/// [DialogueRunner] is a an engine in flame_yarn that runs a single dialogue.
+///
+/// If you think of [YarnProject] as a dialogue "program", consisting of
+/// multiple Nodes as "functions", then [DialogueRunner] is like a VM, capable
+/// of executing a single "function" in that "program".
+///
+/// A single [DialogueRunner] may only execute one dialogue Node at a time. It
+/// is an error to try to run another Node before the first one concludes.
+/// However, it is possible to create multiple [DialogueRunner]s for the same
+/// [YarnProject], and then they would be able to execute multiple dialogues at
+/// once (for example, in a crowded room there could be multiple dialogues
+/// occurring at once within different groups of people).
+///
+/// The job of a [DialogueRunner] is to fetch the dialogue lines in the correct
+/// order, and at the appropriate pace, to execute the logic in dialogue
+/// scripts, and to branch according to user input in [DialogueChoice]s. The
+/// output of a [DialogueRunner], therefore, is a stream of dialogue statements
+/// that need to be presented to the player. Such presentation, however, is
+/// handled by the [DialogueView]s, not by the [DialogueRunner].
+class DialogueRunner {
+  DialogueRunner({
+    required YarnProject yarnProject,
+    required List<DialogueView> dialogueViews,
+  })  : project = yarnProject,
+        _dialogueViews = dialogueViews,
+        _currentNodes = [],
+        _iterators = [];
+
+  final YarnProject project;
+  final List<DialogueView> _dialogueViews;
+  final List<Node> _currentNodes;
+  final List<NodeIterator> _iterators;
+  _LineDeliveryPipeline? _linePipeline;
+
+  /// Executes the node with the given name, and returns a future that finished
+  /// once the dialogue stops running.
+  Future<void> runNode(String nodeName) async {
+    if (_currentNodes.isNotEmpty) {
+      throw DialogueError(
+        'Cannot run node "$nodeName" because another node is '
+        'currently running: "${_currentNodes.last.title}"',
+      );
+    }
+    final newNode = project.nodes[nodeName];
+    if (newNode == null) {
+      throw NameError('Node "$nodeName" could not be found');
+    }
+    _currentNodes.add(newNode);
+    _iterators.add(newNode.iterator);
+    await _combineFutures(
+      [for (final view in _dialogueViews) view.onDialogueStart()],
+    );
+    await _combineFutures(
+      [for (final view in _dialogueViews) view.onNodeStart(newNode)],
+    );
+
+    while (_iterators.isNotEmpty) {
+      final iterator = _iterators.last;
+      if (iterator.moveNext()) {
+        final nextLine = iterator.current;
+        switch (nextLine.kind) {
+          case StatementKind.line:
+            await _deliverLine(nextLine as DialogueLine);
+            break;
+          case StatementKind.choice:
+            await _deliverChoices(nextLine as DialogueChoice);
+            break;
+          case StatementKind.command:
+            await _deliverCommand(nextLine as Command);
+            break;
+        }
+      } else {
+        _iterators.removeLast();
+        _currentNodes.removeLast();
+      }
+    }
+    await _combineFutures(
+      [for (final view in _dialogueViews) view.onDialogueFinish()],
+    );
+  }
+
+  void sendSignal(dynamic signal) {
+    assert(_linePipeline != null);
+    final line = _linePipeline!.line;
+    for (final view in _dialogueViews) {
+      view.onLineSignal(line, signal);
+    }
+  }
+
+  void stopLine() {
+    _linePipeline?.stop();
+  }
+
+  Future<void> _deliverLine(DialogueLine line) async {
+    final pipeline = _LineDeliveryPipeline(line, _dialogueViews);
+    _linePipeline = pipeline;
+    pipeline.start();
+    await pipeline.future;
+    _linePipeline = null;
+  }
+
+  Future<void> _deliverChoices(DialogueChoice choice) async {
+    // Compute which options are available and which aren't. This must be done
+    // only once, because some options may have non-deterministic conditionals
+    // which may produce different results on each invocation.
+    for (final option in choice.options) {
+      option.available = option.condition?.value ?? true;
+    }
+    final futures = [
+      for (final view in _dialogueViews) view.onChoiceStart(choice)
+    ];
+    if (futures.every((future) => future == DialogueView.never)) {
+      _error('No dialogue views capable of making a dialogue choice');
+    }
+    final chosenIndex = await Future.any(futures);
+    if (chosenIndex < 0 || chosenIndex >= choice.options.length) {
+      _error('Invalid option index chosen in a dialogue: $chosenIndex');
+    }
+    final chosenOption = choice.options[chosenIndex];
+    if (!chosenOption.available) {
+      _error('A dialogue view selected a disabled option: $chosenOption');
+    }
+    await _combineFutures(
+      [for (final view in _dialogueViews) view.onChoiceFinish(chosenOption)],
+    );
+    enterBlock(chosenOption.block);
+  }
+
+  FutureOr<void> _deliverCommand(Command command) {
+    return command.execute(this);
+  }
+
+  @internal
+  void enterBlock(Block block) {
+    _iterators.last.diveInto(block);
+  }
+
+  @internal
+  Future<void> jumpToNode(String nodeName) async {
+    _currentNodes.removeLast();
+    _iterators.removeLast();
+    return runNode(nodeName);
+  }
+
+  @internal
+  void stop() {
+    _currentNodes.clear();
+    _iterators.clear();
+  }
+
+  Future<void> _combineFutures(List<FutureOr<void>> maybeFutures) {
+    return Future.wait(<Future<void>>[
+      for (final maybeFuture in maybeFutures)
+        if (maybeFuture is Future) maybeFuture
+    ]);
+  }
+
+  Never _error(String message) {
+    stop();
+    throw DialogueError(message);
+  }
+}
+
+class _LineDeliveryPipeline {
+  _LineDeliveryPipeline(this.line, this.views)
+      : _completer = Completer(),
+        _futures = List.generate(views.length, (i) => null, growable: false);
+
+  final DialogueLine line;
+  final List<DialogueView> views;
+  final List<FutureOr<void>> _futures;
+  final Completer<void> _completer;
+  int _numPendingFutures = 0;
+  bool _interrupted = false;
+
+  Future<void> get future => _completer.future;
+
+  void start() {
+    assert(_numPendingFutures == 0);
+    for (var i = 0; i < views.length; i++) {
+      final maybeFuture = views[i].onLineStart(line);
+      if (maybeFuture is Future) {
+        // ignore: cast_nullable_to_non_nullable
+        final future = maybeFuture as Future<bool>;
+        _futures[i] = future.then((_) => startCompleted(i));
+        _numPendingFutures++;
+      } else {
+        continue;
+      }
+    }
+    if (_numPendingFutures == 0) {
+      finish();
+    }
+  }
+
+  void stop() {
+    _interrupted = true;
+    for (var i = 0; i < views.length; i++) {
+      if (_futures[i] != null) {
+        _futures[i] = views[i].onLineStop(line);
+      }
+    }
+  }
+
+  void finish() {
+    assert(_numPendingFutures == 0);
+    for (var i = 0; i < views.length; i++) {
+      final maybeFuture = views[i].onLineFinish(line);
+      if (maybeFuture is Future) {
+        // ignore: unnecessary_cast
+        final future = maybeFuture as Future<void>;
+        _futures[i] = future.then((_) => finishCompleted(i));
+        _numPendingFutures++;
+      } else {
+        continue;
+      }
+    }
+    if (_numPendingFutures == 0) {
+      _completer.complete();
+    }
+  }
+
+  void startCompleted(int i) {
+    if (!_interrupted) {
+      assert(_futures[i] != null);
+      assert(_numPendingFutures > 0);
+      _futures[i] = null;
+      _numPendingFutures -= 1;
+      if (_numPendingFutures == 0) {
+        finish();
+      }
+    }
+  }
+
+  void finishCompleted(int i) {
+    assert(_futures[i] != null);
+    assert(_numPendingFutures > 0);
+    _futures[i] = null;
+    _numPendingFutures -= 1;
+    if (_numPendingFutures == 0) {
+      _completer.complete();
+    }
+  }
+}
diff --git a/packages/flame_jenny/jenny/lib/src/dialogue_view.dart b/packages/flame_jenny/jenny/lib/src/dialogue_view.dart
new file mode 100644
index 00000000000..23c25800a30
--- /dev/null
+++ b/packages/flame_jenny/jenny/lib/src/dialogue_view.dart
@@ -0,0 +1,143 @@
+import 'dart:async';
+
+import 'package:jenny/src/errors.dart';
+import 'package:jenny/src/structure/dialogue_choice.dart';
+import 'package:jenny/src/structure/dialogue_line.dart';
+import 'package:jenny/src/structure/node.dart';
+import 'package:jenny/src/structure/option.dart';
+import 'package:meta/meta.dart';
+
+abstract class DialogueView {
+  const DialogueView();
+
+  /// Called before the start of a new dialogue, i.e. before any lines, options,
+  /// or commands are delivered.
+  ///
+  /// This method is a good place to prepare the game's UI, such as fading in/
+  /// animating dialogue panels, or loading resources. If this method returns a
+  /// future, then the dialogue will start running only after the future
+  /// completes.
+  FutureOr<void> onDialogueStart() {}
+
+  /// Called when the dialogue enters a new [node].
+  ///
+  /// This will be called immediately after the [onDialogueStart], and then
+  /// possibly several times more over the course of the dialogue if it visits
+  /// multiple nodes.
+  ///
+  /// If this method returns a future, then the dialogue runner will wait for it
+  /// to complete before proceeding with the actual dialogue.
+  FutureOr<void> onNodeStart(Node node) {}
+
+  /// Called when the next dialogue [line] should be presented to the user.
+  ///
+  /// The [DialogueView] may decide to present the [line] in whatever way it
+  /// wants, or to not present the line at all. For example, the dialogue view
+  /// may: augment the line object, render the line at a certain place on the
+  /// screen, render only the character's name, show the portrait of whoever is
+  /// speaking, show the text within a chat bubble, play a voice-over audio
+  /// file, store the text into the player's conversation log, move the camera
+  /// to show the speaker, etc.
+  ///
+  /// Some of these methods of delivery can be considered "primary", while
+  /// others are "auxiliary". A "primary" [DialogueView] should return `true`,
+  /// while all others `false` (especially if a dialogue view ignores the line
+  /// completely). This is used as a robustness check: if none of the dialogue
+  /// views return `true`, then a [DialogueError] will be thrown because the
+  /// line was not shown to the user in a meaningful way.
+  ///
+  /// If this method returns a future, then the dialogue runner will wait for
+  /// that future to complete before advancing to the next line. If multiple
+  /// [DialogueView]s return such futures, then the dialogue runner will wait
+  /// for all of them to complete before proceeding.
+  ///
+  /// Returning a future is quite common for non-trivial [DialogueView]s. After
+  /// all, if this method were to return immediately, the dialogue runner would
+  /// immediately advance to the next line, and the player wouldn't have time
+  /// to read the first one. A common scenario then is to reveal the line
+  /// gradually, and then wait some time before returning; or, alternatively,
+  /// return a [Completer]-based future that completes based on some user action
+  /// such as clicking a button or pressing a keyboard key.
+  ///
+  /// Note that this method is supposed to *show* the line to the player, so
+  /// do not try to hide it at the end -- for that, there is a dedicated method
+  /// [onLineFinish].
+  ///
+  /// Also, given that this method may take a significant amount of time, there
+  /// are two additional methods that may attempt to interfere into this
+  /// process: [onLineSignal] and [onLineStop].
+  FutureOr<bool> onLineStart(DialogueLine line) => false;
+
+  /// Called when the game sends a [signal] to all dialogue views.
+  ///
+  /// The signal will be sent to all views, regardless of whether they have
+  /// finished running [onLineStart] or not. The interpretation of the signal
+  /// and the appropriate response is up to the [DialogueView].
+  ///
+  /// For example, one possible scenario would be to speed up a typewriter
+  /// effect and reveal the text immediately in response to the RUSH signal.
+  /// Or make some kind of an interjection in response to an OMG event. Or
+  /// pause presentation in response to a PAUSE signal. Or give a warning if
+  /// the player makes a hostile gesture such as drawing a weapon.
+  void onLineSignal(DialogueLine line, dynamic signal) {}
+
+  /// Called when the game demands that the [line] finished presenting as soon
+  /// as possible.
+  ///
+  /// By itself, the dialogue runner will never call this method. However, it
+  /// may be invoked as a result of an explicit request by the game (or by one
+  /// of the dialogue views). Examples when this could be appropriate: (a) the
+  /// player was hit while talking to an NPC -- better stop talking and fight
+  /// for your life, (b) the user has pressed a "skip dialogue" button, so we
+  /// should stop the current line and proceed to the next one ASAP.
+  ///
+  /// This method returns a future that will be awaited before continuing to
+  /// the next line of the dialogue. At the same time, any future that's still
+  /// pending from the [onLineStart] call will be discarded and will no longer
+  /// be awaited. The [onLineFinish] method will not be called either.
+  FutureOr<void> onLineStop(DialogueLine line) {}
+
+  /// Called when the [line] has finished presenting in all dialog views.
+  ///
+  /// Some dialog views may need to clear their display when this event happens,
+  /// or make some other preparations to receive the next dialogue line. If this
+  /// method returns a future, that future will be awaited before proceeding to
+  /// the next line in the dialogue.
+  FutureOr<void> onLineFinish(DialogueLine line) {}
+
+  /// Called when the dialogue arrives at an option set, and the player must now
+  /// make a choice on how to proceed. If a dialogue view presents this choice
+  /// to the player and allows them to make a selection, then it must return a
+  /// future that completes when the choice is made. If the dialogue view does
+  /// not display menu choice, then it should return a future that never
+  /// completes (which is the default implementation).
+  ///
+  /// The dialogue runner will assume the choice has been made whenever any of
+  /// the dialogue views will have completed their futures. If none of the
+  /// dialogue views are capable of making a choice, then the dialogue will get
+  /// stuck.
+  ///
+  /// The future returned by this method should deliver an integer value of the
+  /// index of the option that was selected. This index must not exceed the
+  /// length of the [choice] list, and the indicated option must not be marked
+  /// as "unavailable". If these conditions are violated, an exception will be
+  /// raised.
+  Future<int> onChoiceStart(DialogueChoice choice) => never;
+
+  /// Called when the choice has been made, and the [option] was selected.
+  ///
+  /// If this method returns a future, the dialogue runner will wait for that
+  /// future to complete before proceeding with the dialogue.
+  FutureOr<void> onChoiceFinish(Option option) {}
+
+  /// Called when the dialogue has ended.
+  ///
+  /// This method can be used to clean up any of the dialogue UI. The returned
+  /// future will be awaited before the dialogue runner considers its job
+  /// finished.
+  FutureOr<void> onDialogueFinish() {}
+
+  /// A future that never completes.
+  @internal
+  static Future<Never> never = Completer<Never>().future;
+}
diff --git a/packages/flame_jenny/jenny/lib/src/errors.dart b/packages/flame_jenny/jenny/lib/src/errors.dart
index 7deef19aed2..416b6f9cb15 100644
--- a/packages/flame_jenny/jenny/lib/src/errors.dart
+++ b/packages/flame_jenny/jenny/lib/src/errors.dart
@@ -1,5 +1,5 @@
 class SyntaxError implements Exception {
-  SyntaxError([this.message]);
+  SyntaxError(this.message);
 
   final String? message;
 
@@ -11,7 +11,7 @@ class SyntaxError implements Exception {
 /// variable name, unknown node title, unrecognized function, unspecified
 /// command, etc.
 class NameError implements Exception {
-  NameError([this.message]);
+  NameError(this.message);
 
   final String? message;
 
@@ -20,10 +20,19 @@ class NameError implements Exception {
 }
 
 class TypeError implements Exception {
-  TypeError([this.message]);
+  TypeError(this.message);
 
   final String? message;
 
   @override
   String toString() => 'TypeError: $message';
 }
+
+class DialogueError implements Exception {
+  DialogueError(this.message);
+
+  final String? message;
+
+  @override
+  String toString() => 'DialogueError: $message';
+}
diff --git a/packages/flame_jenny/jenny/lib/src/parse/parse.dart b/packages/flame_jenny/jenny/lib/src/parse/parse.dart
index a05a8ebd82a..102f486386b 100644
--- a/packages/flame_jenny/jenny/lib/src/parse/parse.dart
+++ b/packages/flame_jenny/jenny/lib/src/parse/parse.dart
@@ -1,13 +1,15 @@
 import 'package:jenny/src/errors.dart';
 import 'package:jenny/src/parse/token.dart';
 import 'package:jenny/src/parse/tokenize.dart';
+import 'package:jenny/src/structure/block.dart';
 import 'package:jenny/src/structure/commands/command.dart';
 import 'package:jenny/src/structure/commands/if_command.dart';
 import 'package:jenny/src/structure/commands/jump_command.dart';
 import 'package:jenny/src/structure/commands/set_command.dart';
 import 'package:jenny/src/structure/commands/stop_command.dart';
 import 'package:jenny/src/structure/commands/wait_command.dart';
-import 'package:jenny/src/structure/dialogue.dart';
+import 'package:jenny/src/structure/dialogue_choice.dart';
+import 'package:jenny/src/structure/dialogue_line.dart';
 import 'package:jenny/src/structure/expressions/arithmetic.dart';
 import 'package:jenny/src/structure/expressions/expression.dart';
 import 'package:jenny/src/structure/expressions/functions.dart';
@@ -41,11 +43,11 @@ class _Parser {
   void parseMain() {
     while (position < tokens.length) {
       final header = parseNodeHeader();
-      final statements = parseNodeBody();
+      final block = parseNodeBody();
       project.nodes[header.title!] = Node(
         title: header.title!,
         tags: header.tags,
-        lines: statements,
+        content: block,
       );
     }
   }
@@ -82,41 +84,45 @@ class _Parser {
     return _NodeHeader(title, tags.isEmpty ? null : tags);
   }
 
-  List<Statement> parseNodeBody() {
-    final out = <Statement>[];
+  Block parseNodeBody() {
     take(Token.startBody);
     if (peekToken() == Token.startIndent) {
       syntaxError('unexpected indent');
     }
-    out.addAll(parseStatementList());
+    final out = parseStatementList();
     take(Token.endBody);
     return out;
   }
 
-  List<Statement> parseStatementList() {
-    final result = <Statement>[];
+  Block parseStatementList() {
+    final lines = <Statement>[];
     while (true) {
       final nextToken = peekToken();
       if (nextToken == Token.arrow) {
-        result.add(parseOption());
+        final option = parseOption();
+        if (lines.isNotEmpty && lines.last is DialogueChoice) {
+          (lines.last as DialogueChoice).options.add(option);
+        } else {
+          lines.add(DialogueChoice([option]));
+        }
       } else if (nextToken == Token.startCommand) {
-        result.add(parseCommand());
+        lines.add(parseCommand());
       } else if (nextToken.isText ||
           nextToken.isPerson ||
           nextToken == Token.startExpression) {
-        result.add(parseDialogueLine());
+        lines.add(parseDialogueLine());
       } else {
         break;
       }
     }
-    return result;
+    return Block(lines);
   }
 
   //#region Line parsing
 
   /// Consumes a regular line of text from the input, up to and including the
   /// NEWLINE token.
-  Dialogue parseDialogueLine() {
+  DialogueLine parseDialogueLine() {
     final person = maybeParseLinePerson();
     final content = parseLineContent();
     final tags = maybeParseHashtags();
@@ -124,8 +130,8 @@ class _Parser {
       syntaxError('commands are not allowed on a dialogue line');
     }
     takeNewline();
-    return Dialogue(
-      person: person,
+    return DialogueLine(
+      character: person,
       content: content,
       tags: tags,
     );
@@ -141,7 +147,7 @@ class _Parser {
       syntaxError('multiple commands are not allowed on an option line');
     }
     take(Token.newline);
-    var block = const <Statement>[];
+    var block = const Block.empty();
     if (peekToken() == Token.startIndent) {
       position += 1;
       block = parseStatementList();
@@ -149,7 +155,7 @@ class _Parser {
     }
     return Option(
       content: content,
-      person: person,
+      character: person,
       tags: tags,
       condition: condition,
       block: block,
@@ -317,15 +323,15 @@ class _Parser {
     take(Token.endCommand);
     take(Token.newline);
     if (peekToken() == Token.startCommand) {
-      return IfBlock(expression as BoolExpression, []);
+      return IfBlock(expression as BoolExpression, const Block.empty());
     }
     if (peekToken() != Token.startIndent) {
       syntaxError('the body of the <<$commandName>> command must be indented');
     }
     take(Token.startIndent);
-    final statements = parseStatementList();
+    final block = parseStatementList();
     take(Token.endIndent);
-    return IfBlock(expression as BoolExpression, statements);
+    return IfBlock(expression as BoolExpression, block);
   }
 
   IfBlock parseCommandElseBlock() {
@@ -334,7 +340,7 @@ class _Parser {
     take(Token.endCommand);
     take(Token.newline);
     if (peekToken() == Token.startCommand) {
-      return const IfBlock(constTrue, []);
+      return const IfBlock(constTrue, Block.empty());
     }
     if (peekToken() != Token.startIndent) {
       syntaxError('the body of the <<else>> command must be indented');
diff --git a/packages/flame_jenny/jenny/lib/src/structure/block.dart b/packages/flame_jenny/jenny/lib/src/structure/block.dart
new file mode 100644
index 00000000000..ae254b199f4
--- /dev/null
+++ b/packages/flame_jenny/jenny/lib/src/structure/block.dart
@@ -0,0 +1,12 @@
+import 'package:jenny/src/structure/statement.dart';
+
+class Block {
+  const Block(this.lines);
+  const Block.empty() : lines = const [];
+
+  final List<Statement> lines;
+
+  int get length => lines.length;
+  bool get isEmpty => lines.isEmpty;
+  bool get isNotEmpty => lines.isNotEmpty;
+}
diff --git a/packages/flame_jenny/jenny/lib/src/structure/commands/command.dart b/packages/flame_jenny/jenny/lib/src/structure/commands/command.dart
index 15cebb2d6eb..972e589fd29 100644
--- a/packages/flame_jenny/jenny/lib/src/structure/commands/command.dart
+++ b/packages/flame_jenny/jenny/lib/src/structure/commands/command.dart
@@ -1,8 +1,13 @@
+import 'dart:async';
+
+import 'package:jenny/src/dialogue_runner.dart';
 import 'package:jenny/src/structure/statement.dart';
-import 'package:jenny/src/yarn_project.dart';
 
 abstract class Command extends Statement {
   const Command();
 
-  void execute(YarnProject project);
+  FutureOr<void> execute(DialogueRunner dialogue);
+
+  @override
+  StatementKind get kind => StatementKind.command;
 }
diff --git a/packages/flame_jenny/jenny/lib/src/structure/commands/if_command.dart b/packages/flame_jenny/jenny/lib/src/structure/commands/if_command.dart
index b0f09c041c5..a41bf83b63e 100644
--- a/packages/flame_jenny/jenny/lib/src/structure/commands/if_command.dart
+++ b/packages/flame_jenny/jenny/lib/src/structure/commands/if_command.dart
@@ -1,7 +1,7 @@
+import 'package:jenny/src/dialogue_runner.dart';
+import 'package:jenny/src/structure/block.dart';
 import 'package:jenny/src/structure/commands/command.dart';
 import 'package:jenny/src/structure/expressions/expression.dart';
-import 'package:jenny/src/structure/statement.dart';
-import 'package:jenny/src/yarn_project.dart';
 
 class IfCommand extends Command {
   const IfCommand(this.ifs);
@@ -13,10 +13,10 @@ class IfCommand extends Command {
   final List<IfBlock> ifs;
 
   @override
-  void execute(YarnProject runtime) {
-    for (final block in ifs) {
-      if (block.condition.value) {
-        // runtime.executeEntries(block.entries);
+  void execute(DialogueRunner dialogue) {
+    for (final ifBlock in ifs) {
+      if (ifBlock.condition.value) {
+        dialogue.enterBlock(ifBlock.block);
         break;
       }
     }
@@ -27,5 +27,5 @@ class IfBlock {
   const IfBlock(this.condition, this.block);
 
   final BoolExpression condition;
-  final List<Statement> block;
+  final Block block;
 }
diff --git a/packages/flame_jenny/jenny/lib/src/structure/commands/jump_command.dart b/packages/flame_jenny/jenny/lib/src/structure/commands/jump_command.dart
index b2e8a5b5f4f..56aa72ca9a3 100644
--- a/packages/flame_jenny/jenny/lib/src/structure/commands/jump_command.dart
+++ b/packages/flame_jenny/jenny/lib/src/structure/commands/jump_command.dart
@@ -1,6 +1,6 @@
+import 'package:jenny/src/dialogue_runner.dart';
 import 'package:jenny/src/structure/commands/command.dart';
 import 'package:jenny/src/structure/expressions/expression.dart';
-import 'package:jenny/src/yarn_project.dart';
 
 class JumpCommand extends Command {
   const JumpCommand(this.target);
@@ -8,7 +8,7 @@ class JumpCommand extends Command {
   final StringExpression target;
 
   @override
-  void execute(YarnProject project) {
-    project.jumpToNode(target.value);
+  Future<void> execute(DialogueRunner dialogue) {
+    return dialogue.jumpToNode(target.value);
   }
 }
diff --git a/packages/flame_jenny/jenny/lib/src/structure/commands/set_command.dart b/packages/flame_jenny/jenny/lib/src/structure/commands/set_command.dart
index 483b8d1027a..c28dcb13221 100644
--- a/packages/flame_jenny/jenny/lib/src/structure/commands/set_command.dart
+++ b/packages/flame_jenny/jenny/lib/src/structure/commands/set_command.dart
@@ -1,6 +1,6 @@
+import 'package:jenny/src/dialogue_runner.dart';
 import 'package:jenny/src/structure/commands/command.dart';
 import 'package:jenny/src/structure/expressions/expression.dart';
-import 'package:jenny/src/yarn_project.dart';
 
 class SetCommand extends Command {
   const SetCommand(this.variable, this.expression);
@@ -9,7 +9,7 @@ class SetCommand extends Command {
   final Expression expression;
 
   @override
-  void execute(YarnProject runtime) {
-    runtime.variables.setVariable(variable, expression.value);
+  void execute(DialogueRunner dialogue) {
+    dialogue.project.variables.setVariable(variable, expression.value);
   }
 }
diff --git a/packages/flame_jenny/jenny/lib/src/structure/commands/stop_command.dart b/packages/flame_jenny/jenny/lib/src/structure/commands/stop_command.dart
index a7f4ca0494c..8cb5f9a3df6 100644
--- a/packages/flame_jenny/jenny/lib/src/structure/commands/stop_command.dart
+++ b/packages/flame_jenny/jenny/lib/src/structure/commands/stop_command.dart
@@ -1,11 +1,11 @@
+import 'package:jenny/src/dialogue_runner.dart';
 import 'package:jenny/src/structure/commands/command.dart';
-import 'package:jenny/src/yarn_project.dart';
 
 class StopCommand extends Command {
   const StopCommand();
 
   @override
-  void execute(YarnProject project) {
-    project.stopNode();
+  void execute(DialogueRunner dialogue) {
+    dialogue.stop();
   }
 }
diff --git a/packages/flame_jenny/jenny/lib/src/structure/commands/wait_command.dart b/packages/flame_jenny/jenny/lib/src/structure/commands/wait_command.dart
index 9791157ea62..142644951aa 100644
--- a/packages/flame_jenny/jenny/lib/src/structure/commands/wait_command.dart
+++ b/packages/flame_jenny/jenny/lib/src/structure/commands/wait_command.dart
@@ -1,6 +1,6 @@
+import 'package:jenny/src/dialogue_runner.dart';
 import 'package:jenny/src/structure/commands/command.dart';
 import 'package:jenny/src/structure/expressions/expression.dart';
-import 'package:jenny/src/yarn_project.dart';
 
 class WaitCommand extends Command {
   const WaitCommand(this.arg);
@@ -8,7 +8,10 @@ class WaitCommand extends Command {
   final NumExpression arg;
 
   @override
-  void execute(YarnProject project) {
-    project.wait(arg.value.toDouble());
+  Future<void> execute(DialogueRunner dialogue) {
+    final duration = Duration(
+      microseconds: (arg.value.toDouble() * 1000000).toInt(),
+    );
+    return Future.delayed(duration);
   }
 }
diff --git a/packages/flame_jenny/jenny/lib/src/structure/dialogue.dart b/packages/flame_jenny/jenny/lib/src/structure/dialogue.dart
deleted file mode 100644
index ace76b5de9d..00000000000
--- a/packages/flame_jenny/jenny/lib/src/structure/dialogue.dart
+++ /dev/null
@@ -1,14 +0,0 @@
-import 'package:jenny/src/structure/expressions/expression.dart';
-import 'package:jenny/src/structure/statement.dart';
-
-class Dialogue extends Statement {
-  const Dialogue({
-    this.person,
-    required this.content,
-    this.tags,
-  });
-
-  final String? person;
-  final StringExpression content;
-  final List<String>? tags;
-}
diff --git a/packages/flame_jenny/jenny/lib/src/structure/dialogue_choice.dart b/packages/flame_jenny/jenny/lib/src/structure/dialogue_choice.dart
new file mode 100644
index 00000000000..91f320ba1aa
--- /dev/null
+++ b/packages/flame_jenny/jenny/lib/src/structure/dialogue_choice.dart
@@ -0,0 +1,14 @@
+import 'package:jenny/src/structure/option.dart';
+import 'package:jenny/src/structure/statement.dart';
+
+class DialogueChoice extends Statement {
+  const DialogueChoice(this.options);
+
+  final List<Option> options;
+
+  @override
+  StatementKind get kind => StatementKind.choice;
+
+  @override
+  String toString() => 'DialogueChoice($options)';
+}
diff --git a/packages/flame_jenny/jenny/lib/src/structure/dialogue_line.dart b/packages/flame_jenny/jenny/lib/src/structure/dialogue_line.dart
new file mode 100644
index 00000000000..d373ab5bd5f
--- /dev/null
+++ b/packages/flame_jenny/jenny/lib/src/structure/dialogue_line.dart
@@ -0,0 +1,23 @@
+import 'package:jenny/src/structure/expressions/expression.dart';
+import 'package:jenny/src/structure/statement.dart';
+
+class DialogueLine extends Statement {
+  const DialogueLine({
+    this.character,
+    required this.content,
+    this.tags,
+  });
+
+  final String? character;
+  final StringExpression content;
+  final List<String>? tags;
+
+  @override
+  StatementKind get kind => StatementKind.line;
+
+  @override
+  String toString() {
+    final prefix = character == null ? '' : '$character: ';
+    return 'DialogueLine($prefix${content.value})';
+  }
+}
diff --git a/packages/flame_jenny/jenny/lib/src/structure/node.dart b/packages/flame_jenny/jenny/lib/src/structure/node.dart
index 8d98b077520..cd0b2c8f086 100644
--- a/packages/flame_jenny/jenny/lib/src/structure/node.dart
+++ b/packages/flame_jenny/jenny/lib/src/structure/node.dart
@@ -1,16 +1,56 @@
+import 'package:jenny/src/structure/block.dart';
 import 'package:jenny/src/structure/statement.dart';
 
-class Node {
-  Node({
+class Node extends Iterable<Statement> {
+  const Node({
     required this.title,
-    required this.lines,
+    required this.content,
     this.tags,
   });
 
   final String title;
   final Map<String, String>? tags;
-  final List<Statement> lines;
+  final Block content;
+
+  List<Statement> get lines => content.lines;
 
   @override
   String toString() => 'Node($title)';
+
+  @override
+  NodeIterator get iterator => NodeIterator(this);
+}
+
+class NodeIterator implements Iterator<Statement> {
+  NodeIterator(this.node) {
+    diveInto(node.content);
+  }
+
+  final Node node;
+  final List<Block> blocks = [];
+  final List<int> multiIndex = [];
+
+  @override
+  Statement get current => blocks.last.lines[multiIndex.last];
+
+  @override
+  bool moveNext() {
+    while (multiIndex.isNotEmpty) {
+      final lastIndex = multiIndex.last;
+      final lastBlock = blocks.last;
+      if (lastIndex + 1 < lastBlock.length) {
+        multiIndex.last += 1;
+        return true;
+      } else {
+        multiIndex.removeLast();
+        blocks.removeLast();
+      }
+    }
+    return false;
+  }
+
+  void diveInto(Block block) {
+    blocks.add(block);
+    multiIndex.add(-1);
+  }
 }
diff --git a/packages/flame_jenny/jenny/lib/src/structure/option.dart b/packages/flame_jenny/jenny/lib/src/structure/option.dart
index bab3824b1f9..8d2f0313995 100644
--- a/packages/flame_jenny/jenny/lib/src/structure/option.dart
+++ b/packages/flame_jenny/jenny/lib/src/structure/option.dart
@@ -1,19 +1,26 @@
+import 'package:jenny/src/structure/block.dart';
 import 'package:jenny/src/structure/expressions/expression.dart';
-import 'package:jenny/src/structure/statement.dart';
 
-class Option extends Statement {
+class Option {
   Option({
     required this.content,
-    this.person,
+    this.character,
     this.condition,
     this.tags,
-    this.block = const <Statement>[],
+    this.block = const Block([]),
   });
 
-  final String? person;
+  final String? character;
   final StringExpression content;
   final List<String>? tags;
   final BoolExpression? condition;
-  final List<Statement> block;
+  final Block block;
   bool available = true;
+
+  @override
+  String toString() {
+    final prefix = character == null ? '' : '$character: ';
+    final suffix = available ? '' : ' #disabled';
+    return 'Option($prefix${content.value}$suffix)';
+  }
 }
diff --git a/packages/flame_jenny/jenny/lib/src/structure/statement.dart b/packages/flame_jenny/jenny/lib/src/structure/statement.dart
index c56ee696c3b..000e0c4e822 100644
--- a/packages/flame_jenny/jenny/lib/src/structure/statement.dart
+++ b/packages/flame_jenny/jenny/lib/src/structure/statement.dart
@@ -1,3 +1,24 @@
+import 'package:jenny/src/structure/commands/command.dart';
+import 'package:jenny/src/structure/dialogue_choice.dart';
+import 'package:jenny/src/structure/dialogue_line.dart';
+
+/// Base class for all entries in a dialogue, where "entry" is a unit of
+/// processing in a dialogue. There are 3 [kind]s of [Statement]s:
+/// - [DialogueLine]
+/// - [DialogueChoice]
+/// - [Command]
 abstract class Statement {
   const Statement();
+
+  /// The type of this dialogue entry, corresponds to the derived class:
+  /// - [DialogueLine] -> [StatementKind.line]
+  /// - [DialogueChoice] -> [StatementKind.choice]
+  /// - [Command] -> [StatementKind.command]
+  StatementKind get kind;
+}
+
+enum StatementKind {
+  line,
+  choice,
+  command,
 }
diff --git a/packages/flame_jenny/jenny/lib/src/variable_storage.dart b/packages/flame_jenny/jenny/lib/src/variable_storage.dart
index 1e87f4743cd..96c629f4bd2 100644
--- a/packages/flame_jenny/jenny/lib/src/variable_storage.dart
+++ b/packages/flame_jenny/jenny/lib/src/variable_storage.dart
@@ -1,6 +1,9 @@
+import 'package:jenny/src/errors.dart';
 import 'package:jenny/src/structure/expressions/expression_type.dart';
+import 'package:meta/meta.dart';
 
 class VariableStorage {
+  @protected
   final Map<String, dynamic> variables = <String, dynamic>{};
 
   int get length => variables.length;
@@ -26,6 +29,21 @@ class VariableStorage {
   }
 
   void setVariable(String name, dynamic value) {
+    final dynamic oldValue = variables[name];
+    if (!(value is String || value is num || value is bool)) {
+      throw DialogueError(
+        'Cannot set variable $name to a value with type ${value.runtimeType}',
+      );
+    }
+    if (oldValue != null &&
+        !(value is String && oldValue is String) &&
+        !(value is num && oldValue is num) &&
+        !(value is bool && oldValue is bool)) {
+      throw DialogueError(
+        'Redefinition of variable $name from type ${oldValue.runtimeType} to '
+        '${value.runtimeType} is not allowed',
+      );
+    }
     variables[name] = value;
   }
 }
diff --git a/packages/flame_jenny/jenny/lib/src/yarn_project.dart b/packages/flame_jenny/jenny/lib/src/yarn_project.dart
index fb1dd838e23..0400620e39d 100644
--- a/packages/flame_jenny/jenny/lib/src/yarn_project.dart
+++ b/packages/flame_jenny/jenny/lib/src/yarn_project.dart
@@ -1,8 +1,14 @@
 import 'package:jenny/src/parse/parse.dart' as impl;
 import 'package:jenny/src/structure/node.dart';
 import 'package:jenny/src/variable_storage.dart';
-import 'package:meta/meta.dart';
 
+/// [YarnProject] is a central place where all dialogue-related information
+/// is held:
+/// - [nodes]: the map of nodes parsed from yarn files;
+/// - [variables]: the repository of all variables accessible to yarn scripts;
+/// - [functions]: user-defined functions;
+/// - [commands]: user-defined commands;
+///
 class YarnProject {
   YarnProject()
       : nodes = <String, Node>{},
@@ -20,13 +26,4 @@ class YarnProject {
   void setVariable(String name, dynamic value) {
     variables.setVariable(name, value);
   }
-
-  @internal
-  void jumpToNode(String node) {}
-
-  @internal
-  void stopNode() {}
-
-  @internal
-  void wait(num seconds) {}
 }
diff --git a/packages/flame_jenny/jenny/test/dialogue_runner_test.dart b/packages/flame_jenny/jenny/test/dialogue_runner_test.dart
new file mode 100644
index 00000000000..ec66e18584c
--- /dev/null
+++ b/packages/flame_jenny/jenny/test/dialogue_runner_test.dart
@@ -0,0 +1,270 @@
+import 'dart:async';
+
+import 'package:jenny/jenny.dart';
+import 'package:test/test.dart';
+
+import 'utils.dart';
+
+void main() {
+  group('DialogueRunner', () {
+    test('plain dialogue', () async {
+      final yarn = YarnProject()
+        ..parse('title: Hamlet\n'
+            '---\n'
+            "Bernardo:  Who's there?\n"
+            'Francisco: Nay, answer me. Stand and unfold yourself.\n'
+            'Bernardo:  Long live the King!\n'
+            'Francisco: Bernardo?\n'
+            'Bernardo:  He\n'
+            'Francisco: You come most carefully upon your hour.\n'
+            "Bernardo:  'Tis now struck twelve. Get thee to bed, Francisco.\n"
+            "Francisco: For this relief much thanks. 'Tis bitter cold, "
+            'And I am sick at heart.\n'
+            '===\n');
+      final view = _RecordingDialogueView();
+      final dialogue = DialogueRunner(yarnProject: yarn, dialogueViews: [view]);
+      await dialogue.runNode('Hamlet');
+      expect(
+        view.events,
+        [
+          // ignore_for_file: prefer_adjacent_string_concatenation
+          '[*] onDialogueStart()',
+          '[*] onNodeStart(Node(Hamlet))',
+          "[*] onLineStart(DialogueLine(Bernardo: Who's there?))",
+          "[*] onLineFinish(DialogueLine(Bernardo: Who's there?))",
+          '[*] onLineStart(DialogueLine(Francisco: Nay, answer me. ' +
+              'Stand and unfold yourself.))',
+          '[*] onLineFinish(DialogueLine(Francisco: Nay, answer me. Stand ' +
+              'and unfold yourself.))',
+          '[*] onLineStart(DialogueLine(Bernardo: Long live the King!))',
+          '[*] onLineFinish(DialogueLine(Bernardo: Long live the King!))',
+          '[*] onLineStart(DialogueLine(Francisco: Bernardo?))',
+          '[*] onLineFinish(DialogueLine(Francisco: Bernardo?))',
+          '[*] onLineStart(DialogueLine(Bernardo: He))',
+          '[*] onLineFinish(DialogueLine(Bernardo: He))',
+          '[*] onLineStart(DialogueLine(Francisco: You come most carefully ' +
+              'upon your hour.))',
+          '[*] onLineFinish(DialogueLine(Francisco: You come most carefully ' +
+              'upon your hour.))',
+          "[*] onLineStart(DialogueLine(Bernardo: 'Tis now struck twelve. " +
+              'Get thee to bed, Francisco.))',
+          "[*] onLineFinish(DialogueLine(Bernardo: 'Tis now struck twelve. " +
+              'Get thee to bed, Francisco.))',
+          '[*] onLineStart(DialogueLine(Francisco: For this relief much ' +
+              "thanks. 'Tis bitter cold, And I am sick at heart.))",
+          '[*] onLineFinish(DialogueLine(Francisco: For this relief much ' +
+              "thanks. 'Tis bitter cold, And I am sick at heart.))",
+          '[*] onDialogueFinish()',
+        ],
+      );
+    });
+
+    test('DialogueViews with delays', () async {
+      final yarn = YarnProject()
+        ..parse('title: The Robot and the Mattress\n'
+            '---\n'
+            'Zem: Hello, robot\n'
+            'Marvin: Blah\n'
+            '===\n');
+      final events = <String>[];
+      final view1 = _DelayedDialogueView(
+        target: events,
+        name: 'A',
+        lineStartDelay: 0.1,
+        lineFinishDelay: 0.02,
+      );
+      final view2 = _DelayedDialogueView(
+        target: events,
+        name: 'B',
+        lineFinishDelay: 0.05,
+      );
+      final view3 = _DelayedDialogueView(
+        target: events,
+        name: 'C',
+        lineStartDelay: 0.15,
+      );
+      final dialogue = DialogueRunner(
+        yarnProject: yarn,
+        dialogueViews: [view1, view2, view3],
+      );
+      await dialogue.runNode('The Robot and the Mattress');
+      expect(events, [
+        '[A] onDialogueStart()',
+        '[B] onDialogueStart()',
+        '[C] onDialogueStart()',
+        '[A] onNodeStart(Node(The Robot and the Mattress))',
+        '[B] onNodeStart(Node(The Robot and the Mattress))',
+        '[C] onNodeStart(Node(The Robot and the Mattress))',
+        '[A] onLineStart(DialogueLine(Zem: Hello, robot))',
+        '[B] onLineStart(DialogueLine(Zem: Hello, robot))',
+        '[C] onLineStart(DialogueLine(Zem: Hello, robot))',
+        '[A] onLineFinish(DialogueLine(Zem: Hello, robot))',
+        '[B] onLineFinish(DialogueLine(Zem: Hello, robot))',
+        '[C] onLineFinish(DialogueLine(Zem: Hello, robot))',
+        '[A] onLineStart(DialogueLine(Marvin: Blah))',
+        '[B] onLineStart(DialogueLine(Marvin: Blah))',
+        '[C] onLineStart(DialogueLine(Marvin: Blah))',
+        '[A] onLineFinish(DialogueLine(Marvin: Blah))',
+        '[B] onLineFinish(DialogueLine(Marvin: Blah))',
+        '[C] onLineFinish(DialogueLine(Marvin: Blah))',
+        '[A] onDialogueFinish()',
+        '[B] onDialogueFinish()',
+        '[C] onDialogueFinish()',
+      ]);
+    });
+
+    test('dialogue with choices', () async {
+      final yarn = YarnProject()
+        ..parse('title: X\n---\n'
+            '-> Hi there\n'
+            '-> Howdy\n'
+            '   Greetings to you too\n'
+            '-> Yo! <<if false>>\n'
+            'Kk-thx-bye\n'
+            '===\n');
+      final view = _RecordingDialogueView(choices: [1]);
+      final dialogue = DialogueRunner(yarnProject: yarn, dialogueViews: [view]);
+      await dialogue.runNode('X');
+      expect(
+        view.events,
+        [
+          '[*] onDialogueStart()',
+          '[*] onNodeStart(Node(X))',
+          '[*] onChoiceStart(DialogueChoice([Option(Hi there), ' +
+              'Option(Howdy), Option(Yo!  #disabled)])) -> 1',
+          '[*] onChoiceFinish(Option(Howdy))',
+          '[*] onLineStart(DialogueLine(Greetings to you too))',
+          '[*] onLineFinish(DialogueLine(Greetings to you too))',
+          '[*] onLineStart(DialogueLine(Kk-thx-bye))',
+          '[*] onLineFinish(DialogueLine(Kk-thx-bye))',
+          '[*] onDialogueFinish()',
+        ],
+      );
+
+      view.events.clear();
+      view.choices.add(0);
+      await dialogue.runNode('X');
+      expect(
+        view.events,
+        [
+          '[*] onDialogueStart()',
+          '[*] onNodeStart(Node(X))',
+          '[*] onChoiceStart(DialogueChoice([Option(Hi there), ' +
+              'Option(Howdy), Option(Yo!  #disabled)])) -> 0',
+          '[*] onChoiceFinish(Option(Hi there))',
+          '[*] onLineStart(DialogueLine(Kk-thx-bye))',
+          '[*] onLineFinish(DialogueLine(Kk-thx-bye))',
+          '[*] onDialogueFinish()',
+        ],
+      );
+    });
+
+    test('invalid dialogue choices', () async {
+      final yarn = YarnProject()
+        ..parse('title:A\n---\n'
+            '-> Only one\n'
+            '-> Only two <<if false>>\n'
+            '===\n');
+      final view = _RecordingDialogueView(choices: [2, 1]);
+      final dialogue = DialogueRunner(yarnProject: yarn, dialogueViews: [view]);
+      await expectLater(
+        () => dialogue.runNode('A'),
+        hasDialogueError('Invalid option index chosen in a dialogue: 2'),
+      );
+      await expectLater(
+        () => dialogue.runNode('A'),
+        hasDialogueError(
+          'A dialogue view selected a disabled option: '
+          'Option(Only two  #disabled)',
+        ),
+      );
+    });
+
+    test('no decision-making views', () {
+      final yarn = YarnProject()..parse('title:A\n---\n-> One\n===\n');
+      final dialogue = DialogueRunner(
+        yarnProject: yarn,
+        dialogueViews: [_SimpleDialogueView(), _SimpleDialogueView()],
+      );
+      expect(
+        () => dialogue.runNode('A'),
+        hasDialogueError(
+          'No dialogue views capable of making a dialogue choice',
+        ),
+      );
+    });
+  });
+}
+
+class _SimpleDialogueView extends DialogueView {}
+
+class _RecordingDialogueView extends DialogueView {
+  _RecordingDialogueView({
+    List<String>? target,
+    String? name,
+    List<int>? choices,
+  })  : events = target ?? [],
+        name = name ?? '*',
+        choices = choices ?? [];
+
+  final List<String> events;
+  final String name;
+  final List<int> choices;
+
+  @override
+  void onDialogueStart() => _record('onDialogueStart()');
+
+  @override
+  void onDialogueFinish() => _record('onDialogueFinish()');
+
+  @override
+  void onNodeStart(Node node) => _record('onNodeStart($node)');
+
+  @override
+  FutureOr<bool> onLineStart(DialogueLine line) =>
+      _record('onLineStart($line)');
+
+  @override
+  void onLineFinish(DialogueLine line) => _record('onLineFinish($line)');
+
+  @override
+  Future<int> onChoiceStart(DialogueChoice choice) {
+    final selection = choices.isEmpty ? 0 : choices.removeAt(0);
+    _record('onChoiceStart($choice) -> $selection');
+    return Future<int>.value(selection);
+  }
+
+  @override
+  void onChoiceFinish(Option option) => _record('onChoiceFinish($option)');
+
+  bool _record(String event) {
+    events.add('[$name] $event');
+    return true;
+  }
+}
+
+class _DelayedDialogueView extends _RecordingDialogueView {
+  _DelayedDialogueView({
+    super.target,
+    super.name,
+    this.lineStartDelay = 0,
+    this.lineFinishDelay = 0,
+  });
+
+  final double lineStartDelay;
+  final double lineFinishDelay;
+
+  @override
+  Future<bool> onLineStart(DialogueLine line) {
+    super.onLineStart(line);
+    final delay = Duration(milliseconds: (lineStartDelay * 1000).toInt());
+    return Future<bool>.delayed(delay, () => true);
+  }
+
+  @override
+  Future<void> onLineFinish(DialogueLine line) {
+    super.onLineFinish(line);
+    final delay = Duration(milliseconds: (lineFinishDelay * 1000).toInt());
+    return Future.delayed(delay);
+  }
+}
diff --git a/packages/flame_jenny/jenny/test/parse/parse_test.dart b/packages/flame_jenny/jenny/test/parse/parse_test.dart
index e594763f6b4..2706ded68a9 100644
--- a/packages/flame_jenny/jenny/test/parse/parse_test.dart
+++ b/packages/flame_jenny/jenny/test/parse/parse_test.dart
@@ -2,11 +2,9 @@ import 'package:jenny/jenny.dart';
 import 'package:jenny/src/parse/parse.dart';
 import 'package:jenny/src/structure/commands/if_command.dart';
 import 'package:jenny/src/structure/commands/jump_command.dart';
-import 'package:jenny/src/structure/dialogue.dart';
-import 'package:jenny/src/structure/option.dart';
 import 'package:test/test.dart';
 
-import 'utils.dart';
+import '../utils.dart';
 
 void main() {
   // The tests here are further organized into subgroups according to which
@@ -135,12 +133,12 @@ void main() {
               'Saturn\n'
               'Uranus\n'
               '===\n');
-        final node = yarn.nodes['test']!;
-        expect(node.lines.length, 3);
+        final block = yarn.nodes['test']!.content;
+        expect(block.lines.length, 3);
         for (var i = 0; i < 3; i++) {
-          expect(node.lines[i], isA<Dialogue>());
-          final line = node.lines[i] as Dialogue;
-          expect(line.person, isNull);
+          expect(block.lines[i], isA<DialogueLine>());
+          final line = block.lines[i] as DialogueLine;
+          expect(line.character, isNull);
           expect(line.tags, isNull);
           expect(line.content.value, ['Jupyter', 'Saturn', 'Uranus'][i]);
         }
@@ -151,18 +149,18 @@ void main() {
       test('line with a speaker', () {
         final yarn = YarnProject()
           ..parse('title:A\n---\nMrGoo: whatever\n===\n');
-        expect(yarn.nodes['A']!.lines.first, isA<Dialogue>());
-        final line = yarn.nodes['A']!.lines[0] as Dialogue;
-        expect(line.person, 'MrGoo');
+        expect(yarn.nodes['A']!.lines.first, isA<DialogueLine>());
+        final line = yarn.nodes['A']!.lines[0] as DialogueLine;
+        expect(line.character, 'MrGoo');
         expect(line.content.value, 'whatever');
       });
 
       test('line with multiple expressions', () {
         final yarn = YarnProject()
           ..parse('title:A\n---\n{1} {false} {"fake news"}\n===\n');
-        expect(yarn.nodes['A']!.lines.first, isA<Dialogue>());
-        final line = yarn.nodes['A']!.lines[0] as Dialogue;
-        expect(line.person, isNull);
+        expect(yarn.nodes['A']!.lines.first, isA<DialogueLine>());
+        final line = yarn.nodes['A']!.lines[0] as DialogueLine;
+        expect(line.character, isNull);
         expect(line.content.value, '1 false fake news');
       });
 
@@ -171,7 +169,7 @@ void main() {
           ..parse('title:A\n---\n.hello #here #zzz\n===\n');
         final node = yarn.nodes['A']!;
         expect(node.lines.length, 1);
-        final line = node.lines[0] as Dialogue;
+        final line = node.lines[0] as DialogueLine;
         expect(line.tags, isNotNull);
         expect(line.tags!.length, 2);
         expect(line.tags, contains('#here'));
@@ -184,7 +182,7 @@ void main() {
               '\\{ curly text \\}\n'
               '===\n');
         expect(
-          (yarn.nodes['A']!.lines[0] as Dialogue).content.value,
+          (yarn.nodes['A']!.lines[0] as DialogueLine).content.value,
           '{ curly text }',
         );
       });
@@ -220,11 +218,12 @@ void main() {
               '->    Gamma\n'
               '===\n');
         final node = yarn.nodes['test']!;
-        expect(node.lines.length, 3);
+        expect(node.lines.length, 1);
+        final choiceSet = node.lines.first as DialogueChoice;
+        expect(choiceSet.options.length, 3);
         for (var i = 0; i < 3; i++) {
-          expect(node.lines[i], isA<Option>());
-          final line = node.lines[i] as Option;
-          expect(line.person, isNull);
+          final line = choiceSet.options[i];
+          expect(line.character, isNull);
           expect(line.tags, isNull);
           expect(line.condition, isNull);
           expect(line.block, isEmpty);
@@ -239,12 +238,13 @@ void main() {
               '-> Bob: Hi: there!\n'
               '===\n');
         final node = yarn.nodes['A']!;
-        final line0 = node.lines[0] as Option;
-        final line1 = node.lines[1] as Option;
-        expect(line0.person, 'Alice');
-        expect(line0.content.value, 'Hello!');
-        expect(line1.person, 'Bob');
-        expect(line1.content.value, 'Hi: there!');
+        final choice = node.lines[0] as DialogueChoice;
+        final option0 = choice.options[0];
+        final option1 = choice.options[1];
+        expect(option0.character, 'Alice');
+        expect(option1.character, 'Bob');
+        expect(option0.content.value, 'Hello!');
+        expect(option1.content.value, 'Hi: there!');
       });
 
       test('option with a followup dialogue', () {
@@ -257,22 +257,26 @@ void main() {
               '    My condolences...\n'
               '===\n');
         final node = yarn.nodes['A']!;
-        expect(node.lines.length, 2);
-        final choice1 = node.lines[0] as Option;
-        final choice2 = node.lines[1] as Option;
+        final choiceSet = node.lines[0] as DialogueChoice;
+        expect(choiceSet.options.length, 2);
+        final choice1 = choiceSet.options[0];
+        final choice2 = choiceSet.options[1];
         expect(choice1.content.value, 'choice one');
         expect(choice1.block, isNotNull);
         expect(choice1.block.length, 2);
         expect(
-          (choice1.block[0] as Dialogue).content.value,
+          (choice1.block.lines[0] as DialogueLine).content.value,
           'Nice one, James!',
         );
-        expect((choice1.block[1] as Dialogue).content.value, 'Back to ya!');
+        expect(
+          (choice1.block.lines[1] as DialogueLine).content.value,
+          'Back to ya!',
+        );
         expect(choice2.content.value, 'choice two');
         expect(choice2.block, isNotNull);
-        expect(choice2.block.length, 1);
+        expect(choice2.block.lines.length, 1);
         expect(
-          (choice2.block[0] as Dialogue).content.value,
+          (choice2.block.lines[0] as DialogueLine).content.value,
           'My condolences...',
         );
       });
@@ -333,7 +337,7 @@ void main() {
               '===\n');
         expect(
           yarn.nodes['test']!.lines
-              .map((line) => num.parse((line as Dialogue).content.value))
+              .map((line) => num.parse((line as DialogueLine).content.value))
               .toList(),
           [-6, -14, -42, -114],
         );
@@ -355,7 +359,7 @@ void main() {
               '===\n');
         expect(
           yarn.nodes['test']!.lines
-              .map((line) => (line as Dialogue).content.value)
+              .map((line) => (line as DialogueLine).content.value)
               .toList(),
           ['15.76', 'hello, world'],
         );
@@ -385,7 +389,7 @@ void main() {
               '===\n');
         expect(
           yarn.nodes['test']!.lines
-              .map((line) => (line as Dialogue).content.value)
+              .map((line) => (line as DialogueLine).content.value)
               .toList(),
           ['14', 'o,'],
         );
@@ -407,7 +411,7 @@ void main() {
               '===\n');
         expect(
           yarn.nodes['test']!.lines
-              .map((line) => (line as Dialogue).content.value)
+              .map((line) => (line as DialogueLine).content.value)
               .toList(),
           ['44.0', '-6'],
         );
@@ -426,7 +430,7 @@ void main() {
               '{ 48 / 2 / 3 }\n'
               '===\n');
         expect(
-          (yarn.nodes['test']!.lines[0] as Dialogue).content.value,
+          (yarn.nodes['test']!.lines[0] as DialogueLine).content.value,
           '8.0',
         );
         expect(
@@ -444,9 +448,9 @@ void main() {
               '{ 48 % 5 }\n'
               '{ 4 % 1.2 }\n'
               '===\n');
-        expect((yarn.nodes['A']!.lines[0] as Dialogue).content.value, '3');
+        expect((yarn.nodes['A']!.lines[0] as DialogueLine).content.value, '3');
         expect(
-          num.parse((yarn.nodes['A']!.lines[1] as Dialogue).content.value),
+          num.parse((yarn.nodes['A']!.lines[1] as DialogueLine).content.value),
           closeTo(4 % 1.2, 1e-10),
         );
         expect(
@@ -469,7 +473,7 @@ void main() {
               '===\n');
         expect(
           yarn.nodes['test']!.lines
-              .map((line) => (line as Dialogue).content.value),
+              .map((line) => (line as DialogueLine).content.value),
           ['true', 'true', 'false'],
         );
         expect(
@@ -494,9 +498,9 @@ void main() {
               '===\n');
         final node = yarn.nodes['test']!;
         expect(node.lines.length, 3);
-        expect((node.lines[0] as Dialogue).content.value, '-1');
-        expect((node.lines[1] as Dialogue).content.value, '22');
-        expect((node.lines[2] as Dialogue).content.value, '7.0');
+        expect((node.lines[0] as DialogueLine).content.value, '-1');
+        expect((node.lines[1] as DialogueLine).content.value, '22');
+        expect((node.lines[2] as DialogueLine).content.value, '7.0');
       });
 
       test('unknown variable', () {
@@ -550,10 +554,16 @@ void main() {
         final command = node.lines[0] as IfCommand;
         expect(command.ifs.length, 2);
         expect(command.ifs[0].condition.value, true);
-        expect(command.ifs[0].block[0], isA<Dialogue>());
-        expect((command.ifs[0].block[0] as Dialogue).content.value, 'First!');
+        expect(command.ifs[0].block.lines[0], isA<DialogueLine>());
+        expect(
+          (command.ifs[0].block.lines[0] as DialogueLine).content.value,
+          'First!',
+        );
         expect(command.ifs[1].condition.value, true);
-        expect((command.ifs[1].block[0] as Dialogue).content.value, 'Second');
+        expect(
+          (command.ifs[1].block.lines[0] as DialogueLine).content.value,
+          'Second',
+        );
       });
 
       test('<<elseif>>s', () {
diff --git a/packages/flame_jenny/jenny/test/parse/tokenize_test.dart b/packages/flame_jenny/jenny/test/parse/tokenize_test.dart
index f5600316d94..a4cc15ce99a 100644
--- a/packages/flame_jenny/jenny/test/parse/tokenize_test.dart
+++ b/packages/flame_jenny/jenny/test/parse/tokenize_test.dart
@@ -2,7 +2,7 @@ import 'package:jenny/src/parse/token.dart';
 import 'package:jenny/src/parse/tokenize.dart';
 import 'package:test/test.dart';
 
-import 'utils.dart';
+import '../utils.dart';
 
 void main() {
   // Tests are organized according to which lexing Mode they are checking
diff --git a/packages/flame_jenny/jenny/test/structure/block_test.dart b/packages/flame_jenny/jenny/test/structure/block_test.dart
new file mode 100644
index 00000000000..fabc3fe73a1
--- /dev/null
+++ b/packages/flame_jenny/jenny/test/structure/block_test.dart
@@ -0,0 +1,25 @@
+import 'package:jenny/src/structure/block.dart';
+import 'package:jenny/src/structure/dialogue_line.dart';
+import 'package:jenny/src/structure/expressions/literal.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Block', () {
+    test('empty block', () {
+      const block = Block.empty();
+      expect(block.length, 0);
+      expect(block.isEmpty, true);
+      expect(block.isNotEmpty, false);
+    });
+
+    test('non-empty block', () {
+      const line0 = DialogueLine(content: constEmptyString);
+      const line1 = DialogueLine(content: StringLiteral('one'));
+      const line2 = DialogueLine(content: StringLiteral('two'));
+      const block = Block([line0, line1, line2]);
+      expect(block.length, 3);
+      expect(block.isEmpty, false);
+      expect(block.isNotEmpty, true);
+    });
+  });
+}
diff --git a/packages/flame_jenny/jenny/test/structure/dialogue_choice_test.dart b/packages/flame_jenny/jenny/test/structure/dialogue_choice_test.dart
new file mode 100644
index 00000000000..6fa87a329a4
--- /dev/null
+++ b/packages/flame_jenny/jenny/test/structure/dialogue_choice_test.dart
@@ -0,0 +1,13 @@
+import 'package:jenny/src/structure/dialogue_choice.dart';
+import 'package:jenny/src/structure/statement.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('DialogueChoice', () {
+    test('.kind', () {
+      const choiceSet = DialogueChoice([]);
+      expect(choiceSet.options.isEmpty, true);
+      expect(choiceSet.kind, StatementKind.choice);
+    });
+  });
+}
diff --git a/packages/flame_jenny/jenny/test/structure/dialogue_line_test.dart b/packages/flame_jenny/jenny/test/structure/dialogue_line_test.dart
new file mode 100644
index 00000000000..6d20ecdc670
--- /dev/null
+++ b/packages/flame_jenny/jenny/test/structure/dialogue_line_test.dart
@@ -0,0 +1,32 @@
+import 'package:jenny/jenny.dart';
+import 'package:jenny/src/structure/expressions/literal.dart';
+import 'package:jenny/src/structure/statement.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('DialogueLine', () {
+    test('empty line', () {
+      const line = DialogueLine(content: constEmptyString);
+      expect(line.character, isNull);
+      expect(line.tags, isNull);
+      expect(line.content.value, '');
+      expect(line.kind, StatementKind.line);
+      expect('$line', 'DialogueLine()');
+    });
+
+    test('line with meta information', () {
+      const line = DialogueLine(
+        character: 'Bob',
+        content: StringLiteral('Hello!'),
+        tags: ['#red', '#fast'],
+      );
+      expect(line.kind, StatementKind.line);
+      expect(line.content.value, 'Hello!');
+      expect(line.character, 'Bob');
+      expect(line.tags!.length, 2);
+      expect(line.tags![0], '#red');
+      expect(line.tags![1], '#fast');
+      expect('$line', 'DialogueLine(Bob: Hello!)');
+    });
+  });
+}
diff --git a/packages/flame_jenny/jenny/test/structure/node_test.dart b/packages/flame_jenny/jenny/test/structure/node_test.dart
new file mode 100644
index 00000000000..17d908c4afb
--- /dev/null
+++ b/packages/flame_jenny/jenny/test/structure/node_test.dart
@@ -0,0 +1,117 @@
+import 'package:jenny/src/structure/block.dart';
+import 'package:jenny/src/structure/dialogue_choice.dart';
+import 'package:jenny/src/structure/dialogue_line.dart';
+import 'package:jenny/src/structure/expressions/literal.dart';
+import 'package:jenny/src/structure/node.dart';
+import 'package:jenny/src/structure/option.dart';
+import 'package:jenny/src/structure/statement.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Node', () {
+    test('simple node', () {
+      const node = Node(
+        title: 'Introduction',
+        content: Block.empty(),
+      );
+
+      expect(node.title, 'Introduction');
+      expect(node.lines, <Statement>[]);
+      expect(node.tags, isNull);
+      expect('$node', 'Node(Introduction)');
+    });
+
+    test('node with tags', () {
+      const node = Node(
+        title: 'Conclusion',
+        content: Block.empty(),
+        tags: {'line': 'af451', 'characters': 'Alice, Bob'},
+      );
+      expect(node.title, 'Conclusion');
+      expect(node.tags, isNotEmpty);
+      expect(node.tags!.length, 2);
+      expect(node.tags!['line'], 'af451');
+      expect(node.tags!['characters'], 'Alice, Bob');
+    });
+
+    group('iterators', () {
+      test('iterating an empty node', () {
+        const node = Node(title: 'X', content: Block.empty());
+        final statements = List<Statement>.from(node);
+        expect(statements, isEmpty);
+      });
+
+      test('iterating node with one line', () {
+        const line0 = DialogueLine(content: constEmptyString);
+        const node = Node(title: 'X', content: Block([line0]));
+        expect(node.toList(), [line0]);
+      });
+
+      test('iterating multi-line node', () {
+        const line1 = DialogueLine(content: StringLiteral('one'));
+        const line2 = DialogueLine(content: StringLiteral('two'));
+        const line3 = DialogueLine(content: StringLiteral('three'));
+        const line4 = DialogueLine(content: StringLiteral('four'));
+        const node = Node(
+          title: 'quadruple',
+          content: Block([line1, line2, line3, line4]),
+        );
+        expect(List<Statement>.from(node), [line1, line2, line3, line4]);
+      });
+
+      test('iterating deep node', () {
+        final node = Node(
+          title: 'complicated',
+          content: Block([
+            const DialogueLine(content: StringLiteral('one')),
+            const DialogueLine(content: StringLiteral('two')),
+            DialogueChoice([
+              Option(
+                content: const StringLiteral('select 1'),
+                block: const Block([
+                  DialogueLine(content: StringLiteral('so one it is')),
+                  DialogueLine(content: StringLiteral('good choice!')),
+                ]),
+              ),
+              Option(
+                content: const StringLiteral('select 2'),
+                block: const Block([
+                  DialogueLine(content: StringLiteral('oops!')),
+                ]),
+              ),
+            ]),
+            const DialogueLine(content: StringLiteral('bye!')),
+          ]),
+        );
+
+        final lines0 = <Statement>[];
+        final it0 = node.iterator;
+        while (it0.moveNext()) {
+          lines0.add(it0.current);
+        }
+        expect(lines0, node.lines);
+
+        final lines1 = <Statement>[];
+        final it1 = node.iterator;
+        while (it1.moveNext()) {
+          final nextLine = it1.current;
+          lines1.add(nextLine);
+          if (nextLine is DialogueChoice) {
+            it1.diveInto(nextLine.options[0].block);
+          }
+        }
+        expect(
+          lines1,
+          [
+            const DialogueLine(content: StringLiteral('one')),
+            const DialogueLine(content: StringLiteral('two')),
+            node.lines[2] as DialogueChoice,
+            const DialogueLine(content: StringLiteral('so one it is')),
+            const DialogueLine(content: StringLiteral('good choice!')),
+            const DialogueLine(content: StringLiteral('bye!')),
+          ],
+        );
+      });
+    });
+  });
+}
diff --git a/packages/flame_jenny/jenny/test/utils.dart b/packages/flame_jenny/jenny/test/utils.dart
new file mode 100644
index 00000000000..be5353e3c2d
--- /dev/null
+++ b/packages/flame_jenny/jenny/test/utils.dart
@@ -0,0 +1,26 @@
+import 'package:jenny/jenny.dart';
+import 'package:test/test.dart';
+
+Matcher hasSyntaxError(String message) {
+  return throwsA(
+    isA<SyntaxError>().having((e) => e.toString(), 'toString', message),
+  );
+}
+
+Matcher hasNameError(String message) {
+  return throwsA(
+    isA<NameError>().having((e) => e.toString(), 'toString', message),
+  );
+}
+
+Matcher hasTypeError(String message) {
+  return throwsA(
+    isA<TypeError>().having((e) => e.toString(), 'toString', message),
+  );
+}
+
+Matcher hasDialogueError(String message) {
+  return throwsA(
+    isA<DialogueError>().having((e) => e.message, 'message', message),
+  );
+}
diff --git a/packages/flame_jenny/jenny/test/variable_storage_test.dart b/packages/flame_jenny/jenny/test/variable_storage_test.dart
new file mode 100644
index 00000000000..e22a01e1e6d
--- /dev/null
+++ b/packages/flame_jenny/jenny/test/variable_storage_test.dart
@@ -0,0 +1,76 @@
+import 'package:jenny/jenny.dart';
+import 'package:test/test.dart';
+
+import 'utils.dart';
+
+void main() {
+  group('VariableStorage', () {
+    test('empty', () {
+      final storage = VariableStorage();
+      expect(storage.length, 0);
+      expect(storage.isEmpty, true);
+      expect(storage.isNotEmpty, false);
+      expect(storage.hasVariable('x'), false);
+    });
+
+    test('store numeric variable', () {
+      final storage = VariableStorage();
+      storage.setVariable('x', 42);
+      expect(storage.hasVariable('x'), true);
+      expect(storage.getVariable('x'), 42);
+      expect(storage.getVariableType('x'), ExpressionType.numeric);
+      expect(storage.getNumericValue('x'), 42);
+    });
+
+    test('store string variable', () {
+      final storage = VariableStorage();
+      storage.setVariable('s', 'Flame');
+      expect(storage.hasVariable('s'), true);
+      expect(storage.getVariable('s'), 'Flame');
+      expect(storage.getVariableType('s'), ExpressionType.string);
+      expect(storage.getStringValue('s'), 'Flame');
+    });
+
+    test('store boolean variable', () {
+      final storage = VariableStorage();
+      storage.setVariable('b', true);
+      expect(storage.hasVariable('b'), true);
+      expect(storage.getVariable('b'), true);
+      expect(storage.getVariableType('b'), ExpressionType.boolean);
+      expect(storage.getBooleanValue('b'), true);
+    });
+
+    test('unknown variable type', () {
+      final storage = BadVariableStorage();
+      expect(storage.hasVariable('x'), true);
+      expect(storage.getVariableType('x'), ExpressionType.unknown);
+    });
+
+    test('setVariable to unknown type', () {
+      final storage = VariableStorage();
+      expect(
+        () => storage.setVariable('xyz', [1, 2, 3]),
+        hasDialogueError(
+          'Cannot set variable xyz to a value with type List<int>',
+        ),
+      );
+    });
+
+    test('setVariable to a different type', () {
+      final storage = VariableStorage();
+      storage.setVariable('xyz', true);
+      expect(
+        () => storage.setVariable('xyz', 7),
+        hasDialogueError(
+          'Redefinition of variable xyz from type bool to int is not allowed',
+        ),
+      );
+    });
+  });
+}
+
+class BadVariableStorage extends VariableStorage {
+  BadVariableStorage() {
+    variables['x'] = null;
+  }
+}