Harden runtime playback regression coverage

Author: KSemenenko

SDK/README.md

@@ -43,7 +43,7 @@ Compiled TPS output is meant to be portable. The active runtimes treat the compi
 |--------|---------|----------------|---------------|
 | `SDK/ts` | canonical runtime source | changing TPS behavior or runtime contract | `npm --prefix SDK/js run build:tps`, `npm --prefix SDK/js run coverage:typescript` |
 | `SDK/js` | JavaScript package and Node validation | changing JS packaging or JS-specific tests | `npm --prefix SDK/js run test:js`, `npm --prefix SDK/js run coverage:js` |
-| `SDK/dotnet` | C# runtime and tests | changing .NET API or .NET behavior | `dotnet build SDK/dotnet/ManagedCode.Tps.slnx -warnaserror --no-restore`, `dotnet test SDK/dotnet/ManagedCode.Tps.slnx --no-build --no-restore` |
+| `SDK/dotnet` | C# runtime and tests | changing .NET API or .NET behavior | `dotnet build SDK/dotnet/ManagedCode.Tps.slnx -warnaserror --no-restore`, `dotnet test SDK/dotnet/ManagedCode.Tps.slnx --no-restore` |
 | `SDK/flutter` | Dart runtime for Flutter hosts | changing Flutter/Dart behavior or tests | `cd SDK/flutter && dart pub get && ./coverage.sh` |
 | `SDK/swift` | Swift runtime package | changing Apple-platform runtime behavior or tests | `cd SDK/swift && ./coverage.sh` |
 | `SDK/java` | Java runtime package | changing Java behavior or tests | `cd SDK/java && ./coverage.sh` |
@@ -108,7 +108,7 @@ On .NET UI hosts, also wire `TpsPlaybackSessionOptions.EventSynchronizationConte
 
 - TypeScript: `npm --prefix SDK/js run coverage:typescript`
 - JavaScript: `npm --prefix SDK/js run coverage:js`
-- C#: `dotnet test SDK/dotnet/ManagedCode.Tps.slnx --no-build --no-restore /p:CollectCoverage=true /p:CoverletOutputFormat=json /p:ThresholdType=line%2Cbranch%2Cmethod /p:Threshold=90`
+- C#: `dotnet test SDK/dotnet/ManagedCode.Tps.slnx --no-restore /p:CollectCoverage=true /p:CoverletOutputFormat=json /p:ThresholdType=line%2Cbranch%2Cmethod /p:Threshold=90`
 - Flutter: `cd SDK/flutter && ./coverage.sh`
 - Swift: `cd SDK/swift && ./coverage.sh`
 - Java: `cd SDK/java && ./coverage.sh`

SDK/dotnet/README.md

@@ -92,8 +92,8 @@ The root [README.md](/Users/ksemenenko/Developer/TPS/README.md) is the authorita
 ## Local Commands
 
 - `dotnet build ManagedCode.Tps.slnx -warnaserror --no-restore`
-- `dotnet test ManagedCode.Tps.slnx --no-build --no-restore`
-- `dotnet test ManagedCode.Tps.slnx --no-build --no-restore /p:CollectCoverage=true /p:CoverletOutputFormat=json /p:ThresholdType=line%2Cbranch%2Cmethod /p:Threshold=90`
+- `dotnet test ManagedCode.Tps.slnx --no-restore`
+- `dotnet test ManagedCode.Tps.slnx --no-restore /p:CollectCoverage=true /p:CoverletOutputFormat=json /p:ThresholdType=line%2Cbranch%2Cmethod /p:Threshold=90`
 
 ## Target Runtime
 

SDK/dotnet/tests/ManagedCode.Tps.Tests/TpsPlaybackSessionTests.cs

@@ -633,6 +633,65 @@ public async Task PlaybackSession_CanRunDeterministicallyWithFakeTimeProvider()
         Assert.Equal(TpsPlaybackStatus.Completed, session.Status);
     }
 
+    [Fact]
+    public async Task PlaybackSession_ConcurrentControlCommands_KeepStateConsistent()
+    {
+        var script = TpsRuntime.Compile("""
+        ## [Intro]
+        ### [Lead]
+        Ready now please stay focused for this longer playback sample.
+        ### [Close]
+        Done soon after another phrase lands safely.
+        """).Script;
+        using var session = new TpsPlaybackSession(
+            script,
+            new TpsPlaybackSessionOptions
+            {
+                TickIntervalMs = 1_000
+            });
+
+        session.Play();
+
+        var tasks = Enumerable.Range(0, 4).Select(async lane =>
+        {
+            for (var iteration = 0; iteration < 40; iteration++)
+            {
+                switch ((lane + iteration) % 6)
+                {
+                    case 0:
+                        session.Seek((iteration * 37) % Math.Max(1, script.TotalDurationMs));
+                        break;
+                    case 1:
+                        session.NextWord();
+                        break;
+                    case 2:
+                        session.PreviousWord();
+                        break;
+                    case 3:
+                        session.NextBlock();
+                        break;
+                    case 4:
+                        session.PreviousBlock();
+                        break;
+                    default:
+                        session.SetSpeedOffsetWpm(((lane * 5) + iteration) % 41 - 20);
+                        break;
+                }
+
+                await Task.Yield();
+            }
+        });
+
+        await Task.WhenAll(tasks);
+
+        var snapshot = session.CreateSnapshot();
+
+        Assert.InRange(snapshot.State.ElapsedMs, 0, script.TotalDurationMs);
+        Assert.InRange(snapshot.State.CurrentWordIndex, -1, script.Words.Count - 1);
+        Assert.InRange(snapshot.Tempo.EffectiveBaseWpm, TpsSpec.MinimumWpm, TpsSpec.MaximumWpm);
+        Assert.NotNull(snapshot.State.CurrentSegment);
+    }
+
     private sealed class RecordingSynchronizationContext : SynchronizationContext
     {
         public int PostCount { get; private set; }

SDK/flutter/lib/src/managedcode_tps.dart

@@ -1206,7 +1206,6 @@ class TpsPlaybackSession {
       _clearTimer();
       _scheduleNextTick();
     }
-    _emitSnapshotChanged();
     return snapshot;
   }
 
@@ -1275,11 +1274,18 @@ class TpsPlaybackSession {
   }
 
   void _updateStatus(TpsPlaybackStatus nextStatus) {
-    if (status == nextStatus) {
+    final previousStatus = status;
+    if (previousStatus == nextStatus) {
       return;
     }
-    final previousStatus = status;
     status = nextStatus;
+    if (nextStatus != TpsPlaybackStatus.playing) {
+      _playbackOffsetMs = currentState.elapsedMs;
+      _playbackStartedAtMs = 0;
+    }
+    if (nextStatus == TpsPlaybackStatus.completed && previousStatus == TpsPlaybackStatus.playing) {
+      _clearTimer();
+    }
     _emit("statusChanged", {
       "state": currentState,
       "previousStatus": previousStatus,
@@ -1291,8 +1297,11 @@ class TpsPlaybackSession {
     final previousState = currentState;
     final nextState = player.getState(elapsedMs);
     final previousStatus = status;
+    final resolvedStatus = nextStatus == TpsPlaybackStatus.playing && nextState.isComplete
+        ? TpsPlaybackStatus.completed
+        : nextStatus;
     currentState = nextState;
-    _updateStatus(nextStatus);
+    _updateStatus(resolvedStatus);
     if (nextState.currentWord?.id != previousState.currentWord?.id) {
       _emit("wordChanged", {"state": nextState, "previousState": previousState, "status": status});
     }
@@ -1308,8 +1317,7 @@ class TpsPlaybackSession {
     if (nextState.elapsedMs != previousState.elapsedMs || status != previousStatus) {
       _emit("stateChanged", {"state": nextState, "previousState": previousState, "status": status});
     }
-    if (!previousState.isComplete && nextState.isComplete) {
-      status = TpsPlaybackStatus.completed;
+    if (!previousState.isComplete && resolvedStatus == TpsPlaybackStatus.completed) {
       _emit("completed", {"state": nextState, "previousState": previousState, "status": status});
     }
     _emitSnapshotChanged();

SDK/flutter/test/runtime_test.dart

@@ -227,6 +227,36 @@ void main() {
     session.dispose();
   });
 
+  test("emits a single snapshot for speed changes and reports completed status transitions", () async {
+    final compilation = compileTps("## [Signal]\n### [Body]\nReady now.");
+    final session = TpsPlaybackSession(compilation.script, const TpsPlaybackSessionOptions(tickIntervalMs: 10));
+    final statuses = <TpsPlaybackStatus>[];
+    var snapshotEvents = 0;
+
+    session.on("statusChanged", (event) {
+      statuses.add((event as Map<String, Object?>)["status"] as TpsPlaybackStatus);
+    });
+    session.on("snapshotChanged", (_) {
+      snapshotEvents += 1;
+    });
+
+    session.increaseSpeed(10);
+    expect(snapshotEvents, 1);
+
+    final completer = Completer<void>();
+    session.on("completed", (_) {
+      if (!completer.isCompleted) {
+        completer.complete();
+      }
+    });
+    session.play();
+    await completer.future.timeout(const Duration(seconds: 3));
+
+    expect(statuses, contains(TpsPlaybackStatus.playing));
+    expect(statuses, contains(TpsPlaybackStatus.completed));
+    session.dispose();
+  });
+
   test("compiles and navigates a large generated script", () {
     final buffer = StringBuffer()
       ..writeln("---")

SDK/java/src/test/java/com/managedcode/tps/ManagedCodeTpsTests.java

@@ -12,6 +12,7 @@
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 
@@ -49,6 +50,7 @@ public static void main(String[] args) throws Exception {
         testAuthoringEdgeCasesAndPlayerGuardRails();
         testCompiledJsonGuardsAndPlaybackLifecycle();
         testPlaybackNavigationAndTimer();
+        testConcurrentControlCommands();
         testLargeGeneratedScript();
         System.out.println("ManagedCode.Tps Java tests passed.");
     }
@@ -258,6 +260,59 @@ private static void testPlaybackNavigationAndTimer() throws InterruptedException
         }
     }
 
+    private static void testConcurrentControlCommands() throws InterruptedException {
+        ManagedCodeTps.TpsCompilationResult compilation = ManagedCodeTps.TpsRuntime.compileTps("""
+            ## [Intro]
+            ### [Lead]
+            Ready now please stay focused for this longer playback sample.
+            ### [Close]
+            Done soon after another phrase lands safely.
+            """);
+        ManagedCodeTps.TpsPlaybackSession session = new ManagedCodeTps.TpsPlaybackSession(compilation.script(), new ManagedCodeTps.TpsPlaybackSessionOptions(1_000, null, null, null, false));
+        try {
+            session.play();
+
+            CountDownLatch start = new CountDownLatch(1);
+            CountDownLatch completed = new CountDownLatch(4);
+            List<Throwable> failures = new CopyOnWriteArrayList<>();
+
+            for (int lane = 0; lane < 4; lane += 1) {
+                final int laneId = lane;
+                Thread thread = new Thread(() -> {
+                    try {
+                        start.await(3, TimeUnit.SECONDS);
+                        for (int iteration = 0; iteration < 40; iteration += 1) {
+                            switch ((laneId + iteration) % 6) {
+                                case 0 -> session.seek((iteration * 37) % Math.max(1, compilation.script().totalDurationMs()));
+                                case 1 -> session.nextWord();
+                                case 2 -> session.previousWord();
+                                case 3 -> session.nextBlock();
+                                case 4 -> session.previousBlock();
+                                default -> session.setSpeedOffsetWpm(((laneId * 5) + iteration) % 41 - 20);
+                            }
+                        }
+                    } catch (Throwable exception) {
+                        failures.add(exception);
+                    } finally {
+                        completed.countDown();
+                    }
+                });
+                thread.start();
+            }
+
+            start.countDown();
+            assertTrue(completed.await(3, TimeUnit.SECONDS), "concurrent control commands should complete");
+            assertTrue(failures.isEmpty(), "concurrent control commands should not fail: " + failures);
+
+            ManagedCodeTps.TpsPlaybackSnapshot snapshot = session.snapshot();
+            assertTrue(snapshot.state().elapsedMs() >= 0 && snapshot.state().elapsedMs() <= compilation.script().totalDurationMs(), "elapsedMs should stay in bounds");
+            assertTrue(snapshot.state().currentWordIndex() >= -1 && snapshot.state().currentWordIndex() < compilation.script().words().size(), "currentWordIndex should stay in bounds");
+            assertTrue(snapshot.tempo().effectiveBaseWpm() >= ManagedCodeTps.TpsSpec.MINIMUM_WPM && snapshot.tempo().effectiveBaseWpm() <= ManagedCodeTps.TpsSpec.MAXIMUM_WPM, "effectiveBaseWpm should stay in bounds");
+        } finally {
+            session.dispose();
+        }
+    }
+
     private static void testLargeGeneratedScript() {
         StringBuilder builder = new StringBuilder();
         builder.append("---\nbase_wpm: 140\n---\n\n");

SDK/manifest.json

@@ -33,8 +33,8 @@
       "setup": "dotnet",
       "enabled": true,
       "build": "dotnet build SDK/dotnet/ManagedCode.Tps.slnx -warnaserror --no-restore",
-      "test": "dotnet test SDK/dotnet/ManagedCode.Tps.slnx --no-build --no-restore",
-      "coverage": "dotnet test SDK/dotnet/ManagedCode.Tps.slnx --no-build --no-restore /p:CollectCoverage=true /p:CoverletOutputFormat=json /p:ThresholdType=line%2Cbranch%2Cmethod /p:Threshold=90"
+      "test": "dotnet test SDK/dotnet/ManagedCode.Tps.slnx --no-restore",
+      "coverage": "dotnet test SDK/dotnet/ManagedCode.Tps.slnx --no-restore /p:CollectCoverage=true /p:CoverletOutputFormat=json /p:ThresholdType=line%2Cbranch%2Cmethod /p:Threshold=90"
     },
     {
       "id": "flutter",

SDK/swift/Sources/ManagedCodeTps/ManagedCodeTps.swift

@@ -657,7 +657,6 @@ public final class TpsPlaybackSession {
             clearTimer()
             scheduleNextTick()
         }
-        emitSnapshotChanged()
         return snapshot
     }
 
@@ -714,18 +713,26 @@ public final class TpsPlaybackSession {
     }
 
     private func updateStatus(_ nextStatus: TpsPlaybackStatus) {
-        guard status != nextStatus else { return }
         let previousStatus = status
+        guard previousStatus != nextStatus else { return }
         status = nextStatus
+        if nextStatus != .playing {
+            playbackOffsetMs = currentState.elapsedMs
+            playbackStartedAtMs = 0
+        }
+        if nextStatus == .completed && previousStatus == .playing {
+            clearTimer()
+        }
         emit("statusChanged", event: ["state": currentState, "previousStatus": previousStatus.rawValue, "status": nextStatus.rawValue])
     }
 
     private func updatePosition(_ elapsedMs: Int, _ nextStatus: TpsPlaybackStatus) -> PlayerState {
         let previousState = currentState
         let previousStatus = status
         let nextState = player.getState(elapsedMs)
+        let resolvedStatus: TpsPlaybackStatus = nextStatus == .playing && nextState.isComplete ? .completed : nextStatus
         currentState = nextState
-        updateStatus(nextStatus)
+        updateStatus(resolvedStatus)
         if nextState.currentWord?.id != previousState.currentWord?.id {
             emit("wordChanged", event: ["state": nextState, "previousState": previousState, "status": status.rawValue])
         }
@@ -741,8 +748,7 @@ public final class TpsPlaybackSession {
         if nextState.elapsedMs != previousState.elapsedMs || status != previousStatus {
             emit("stateChanged", event: ["state": nextState, "previousState": previousState, "status": status.rawValue])
         }
-        if !previousState.isComplete && nextState.isComplete {
-            status = .completed
+        if !previousState.isComplete && resolvedStatus == .completed {
             emit("completed", event: ["state": nextState, "previousState": previousState, "status": status.rawValue])
         }
         emitSnapshotChanged()

SDK/swift/Tests/ManagedCodeTpsTests/ManagedCodeTpsTests.swift

@@ -214,6 +214,37 @@ final class ManagedCodeTpsTests: XCTestCase {
         session.dispose()
     }
 
+    func testPlaybackStatusTransitionsAndSpeedSnapshotsStayCanonical() throws {
+        let compilation = TpsRuntime.compileTps("## [Signal]\n### [Body]\nReady now.")
+        let session = TpsPlaybackSession(compilation.script, options: .init(tickIntervalMs: 10))
+        var statuses: [String] = []
+        var snapshotEvents = 0
+
+        let disposeStatus = session.on("statusChanged") { event in
+            let payload = event as! [String: Any]
+            statuses.append(payload["status"] as! String)
+        }
+        let disposeSnapshot = session.on("snapshotChanged") { _ in
+            snapshotEvents += 1
+        }
+
+        _ = session.increaseSpeed(10)
+        XCTAssertEqual(snapshotEvents, 1)
+
+        let completed = expectation(description: "completed-with-status")
+        let disposeCompleted = session.on("completed") { _ in completed.fulfill() }
+        _ = session.play()
+        wait(for: [completed], timeout: 3)
+
+        disposeCompleted()
+        disposeSnapshot()
+        disposeStatus()
+
+        XCTAssertTrue(statuses.contains(TpsPlaybackStatus.playing.rawValue))
+        XCTAssertTrue(statuses.contains(TpsPlaybackStatus.completed.rawValue))
+        session.dispose()
+    }
+
     func testLargeGeneratedScript() {
         var lines: [String] = ["---", "base_wpm: 140", "---", ""]
         for segmentIndex in 1...8 {

SDK/ts/tests/runtime/examples.test.ts

@@ -5,6 +5,7 @@ import test from "node:test";
 import { fileURLToPath } from "node:url";
 
 import { compileTps, TpsPlaybackSession, TpsPlayer, TpsStandalonePlayer } from "../../src/index.ts";
+import { parseCompiledScriptJson } from "../../src/compiled-script.ts";
 import { buildExampleSnapshot, EXAMPLE_FILES, loadExampleSnapshot } from "../../../scripts/example-snapshot-utils.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -148,3 +149,16 @@ test("source TypeScript standalone player can restore from compiled script and J
   playerFromJson.dispose();
   fromCanonicalTransport.dispose();
 });
+
+test("source TypeScript runtime rejects malformed compiled JSON and invalid fixtures", () => {
+  const invalid = compileTps(readFixture("invalid", "unknown-tag.tps"));
+  assert.equal(invalid.ok, false);
+  assert.ok(invalid.diagnostics.some((diagnostic) => diagnostic.code === "unknown-tag"));
+
+  assert.throws(() => parseCompiledScriptJson(""), /non-empty string/i);
+  assert.throws(() => parseCompiledScriptJson("[]"), /script object/i);
+
+  const canonicalTransport = JSON.parse(readFixture("transport", "runtime-parity.compiled.json"));
+  canonicalTransport.segments = [];
+  assert.throws(() => parseCompiledScriptJson(JSON.stringify(canonicalTransport)), /at least one segment/i);
+});