diff --git a/.changeset/attribute-equality.md b/.changeset/attribute-equality.md
new file mode 100644
index 00000000..574cdc38
--- /dev/null
+++ b/.changeset/attribute-equality.md
@@ -0,0 +1,14 @@
+---
+"@empirica/core": patch
+---
+
+Fix setting attributes with the same mutated object as the current one.
+
+For example, before this patch, the value would not be saved, since we are
+reusing the same object, which we've only mutated in place:
+
+```js
+const value = player.get("myobject");
+value["mykey"] = "myvalue";
+player.set("myobject", value);
+```
diff --git a/lib/@empirica/core/src/shared/attributes.ts b/lib/@empirica/core/src/shared/attributes.ts
index 26be6ee0..ed5ece31 100644
--- a/lib/@empirica/core/src/shared/attributes.ts
+++ b/lib/@empirica/core/src/shared/attributes.ts
@@ -236,6 +236,7 @@ export class Attribute {
   private attrs?: Attribute[];
 
   private val = new BehaviorSubject<JsonValue | undefined>(undefined);
+  private serVal?: string;
 
   constructor(
     private setAttributes: (input: SetAttributeInput[]) => Promise<unknown>,
@@ -294,6 +295,8 @@ export class Attribute {
       throw new Error(`cannot set both append and index`);
     }
 
+    const serVal = JSON.stringify(value);
+
     if (!item && (ao?.index !== undefined || ao?.append)) {
       let index = ao!.index || 0;
       if (ao?.append) {
@@ -316,7 +319,7 @@ export class Attribute {
         );
       } else {
         const existing = this.attrs[index];
-        if (existing && existing.value === value) {
+        if (existing && existing.serVal === serVal) {
           return;
         }
       }
@@ -325,17 +328,19 @@ export class Attribute {
       const v = this._recalcVectorVal();
       this.val.next(v);
     } else {
-      if (this.value === value) {
+      if (this.serVal === serVal) {
         return;
       }
 
       this.val.next(value);
     }
 
+    this.serVal = serVal;
+
     const attrProps: SetAttributeInput = {
       key: this.key,
       nodeID: this.scopeID,
-      val: JSON.stringify(value),
+      val: serVal,
     };
 
     if (ao) {
diff --git a/lib/admin-ui/src/components/batches/NewBatch.svelte b/lib/admin-ui/src/components/batches/NewBatch.svelte
index 1c4bcf21..5851e1e3 100644
--- a/lib/admin-ui/src/components/batches/NewBatch.svelte
+++ b/lib/admin-ui/src/components/batches/NewBatch.svelte
@@ -14,10 +14,10 @@
 </script>
 
 <script>
-  import { formatLobby } from "../../utils/lobbies.js";
   import { push } from "svelte-spa-router";
   import { currentAdmin } from "../../utils/auth.js";
   import { validateBatchConfig } from "../../utils/batches.js";
+  import { formatLobby } from "../../utils/lobbies.js";
   import Alert from "../common/Alert.svelte";
   import ButtonGroup from "../common/ButtonGroup.svelte";
   import EmptyState from "../common/EmptyState.svelte";
@@ -47,7 +47,7 @@
     }
   }
 
-  async function handleSubmit() {
+  async function handleSubmit(event) {
     let config;
     switch (assignmentMethod) {
       case "simple":
@@ -57,20 +57,22 @@
         config = complete;
         break;
       case "custom":
-        config = custom;
+        window["rawCustomConfig"]
+          ? (config = custom.config)
+          : (config = custom);
         break;
       default:
         throw new Error("unknown assgnement method");
     }
 
-    console.info("submitting", JSON.stringify(config));
+    console.debug("submitting", JSON.stringify(config));
 
     const attributes = [
       { key: "config", val: JSON.stringify(config), immutable: true },
       { key: "status", val: JSON.stringify("created"), protected: true },
     ];
 
-    if (assignmentMethod !== "custom") {
+    if (assignmentMethod !== "custom" || window["rawCustomConfig"]) {
       attributes.push({
         key: "lobbyConfig",
         val: JSON.stringify(lobby),
@@ -87,7 +89,7 @@
         attributes,
       });
 
-      console.log("new batch", batch);
+      console.debug("new batch", batch);
       window.lastNewBatch = batch;
 
       newBatch = false;
diff --git a/tests/stress/experiment/client/src/App.jsx b/tests/stress/experiment/client/src/App.jsx
index 4cce43f3..12051505 100644
--- a/tests/stress/experiment/client/src/App.jsx
+++ b/tests/stress/experiment/client/src/App.jsx
@@ -16,11 +16,43 @@ export default function App() {
       <div className="h-screen relative">
         <EmpiricaMenu position="bottom-left" />
         <div className="h-full overflow-auto">
-          <EmpiricaContext disableConsent>
-            <Game />
+          <EmpiricaContext disableConsent finished={Finished}>
+            <ErrorBoundarySimple>
+              <Game />
+            </ErrorBoundarySimple>
           </EmpiricaContext>
         </div>
       </div>
     </EmpiricaParticipant>
   );
 }
+
+export function Finished() {
+  return (
+    <div>
+      <h2 data-test="game-finished">Finished</h2>
+    </div>
+  );
+}
+
+class ErrorBoundarySimple extends React.Component {
+  state = { hasError: false };
+
+  componentDidCatch(error) {
+    // report the error to your favorite Error Tracking tool (ex: Sentry, Bugsnag)
+    console.error(error);
+  }
+
+  static getDerivedStateFromError(error) {
+    // Update state so the next render will show the fallback UI.
+    return { hasError: true };
+  }
+
+  render() {
+    if (this.state.hasError) {
+      return "Failed";
+    }
+
+    return this.props.children;
+  }
+}
diff --git a/tests/stress/experiment/client/src/Game.jsx b/tests/stress/experiment/client/src/Game.jsx
index 47187264..8ffbf7c4 100644
--- a/tests/stress/experiment/client/src/Game.jsx
+++ b/tests/stress/experiment/client/src/Game.jsx
@@ -1,4 +1,3 @@
-import React, { useEffect } from "react";
 import {
   useGame,
   usePlayer,
@@ -6,8 +5,54 @@ import {
   useRound,
   useStage,
 } from "@empirica/core/player/classic/react";
+import React, { useEffect, useRef } from "react";
 
-export function Game() {
+class Scope {
+  scope = null;
+  keyListeners = new Set();
+  scopeListener = false;
+
+  constructor(kind) {
+    this.kind = kind;
+  }
+
+  updateScope(scope) {
+    this.scope = scope;
+    for (const key of this.keyListeners.keys()) {
+      window.keyChanged(this.kind, key, scope?.get(key), Boolean(scope));
+    }
+
+    if (this.scopeListener) {
+      window.scopeChanged(this.kind, Boolean(scope));
+    }
+  }
+
+  listenKey(key) {
+    this.keyListeners.add(key);
+  }
+
+  listenScope() {
+    this.scopeListener = true;
+  }
+
+  get(key) {
+    return this.scope?.get(key);
+  }
+
+  set(key, value) {
+    this.scope?.set(key, value);
+  }
+}
+const coll = {
+  game: new Scope("game"),
+  round: new Scope("round"),
+  stage: new Scope("stage"),
+  player: new Scope("player"),
+  players: new Scope("players"),
+};
+window.empirica_test_collector = coll;
+
+function GameInner() {
   const game = useGame();
   const round = useRound();
   const stage = useStage();
@@ -20,30 +65,26 @@ export function Game() {
   }, []);
 
   useEffect(() => {
-    window.game = game;
-    window.round = round;
-    window.stage = stage;
-    window.player = player;
-    window.players = players;
-
-    return () => {
-      delete window.game;
-      delete window.round;
-      delete window.stage;
-      delete window.player;
-      delete window.players;
-    };
-  }, []);
+    coll.game.updateScope(game);
+  }, [game]);
+
+  useEffect(() => {
+    coll.round.updateScope(round);
+  }, [round]);
+
+  useEffect(() => {
+    coll.stage.updateScope(stage);
+  }, [stage]);
 
-  // useEffect(() => {
-  //   let i = 0;
-  //   const interval = setInterval(() => {
-  //     round.set(`someKey ${i}`, "someValue");
-  //     i++;
-  //   }, 1000 / treatment.newKeyRate);
+  useEffect(() => {
+    coll.player.updateScope(player);
+  }, [player]);
+
+  useEffect(() => {
+    coll.players.updateScope(players);
+  }, [players]);
 
-  //   return () => clearInterval(interval);
-  // }, []);
+  console.log("submitted", player.stage.get("submit"));
 
   return (
     <div>
@@ -51,6 +92,35 @@ export function Game() {
       <h2 data-test="round-name">{round.get("name")}</h2>
       <h3 data-test="stage-name">{stage.get("name")}</h3>
       <h3 data-test="player-count">{treatment.playerCount}</h3>
+
+      {player.stage.get("submit") ? (
+        <div data-test="submitted">Submitted</div>
+      ) : (
+        <div data-test="stage-ongoing">Stage ongoing</div>
+      )}
+
+      <button
+        data-test="submit-stage"
+        onClick={() => {
+          player.stage.set("submit", true);
+        }}
+      >
+        Submit
+      </button>
     </div>
   );
 }
+
+export class Game extends React.Component {
+  componentWillUnmount() {
+    coll.game.updateScope(null);
+    coll.round.updateScope(null);
+    coll.stage.updateScope(null);
+    coll.player.updateScope(null);
+    coll.players.updateScope(null);
+  }
+
+  render() {
+    return <GameInner />;
+  }
+}
diff --git a/tests/stress/playwright.config.js b/tests/stress/playwright.config.js
index 556f2769..13372f33 100644
--- a/tests/stress/playwright.config.js
+++ b/tests/stress/playwright.config.js
@@ -20,7 +20,9 @@ module.exports = defineConfig({
   /* Retry on CI only */
   retries: process.env.CI ? 2 : 0,
   /* Opt out of parallel tests on CI. */
-  workers: process.env.CI ? 1 : undefined,
+  // workers: process.env.CI ? 1 : undefined,
+  /* Opt out of parallel tests for now, since using a single external empirica instance. */
+  workers: 1,
   /* Reporter to use. See https://playwright.dev/docs/test-reporters */
   reporter: [["html", { open: "never" }]],
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
diff --git a/tests/stress/tests/admin.js b/tests/stress/tests/admin.js
index 3a812f26..f89a9883 100644
--- a/tests/stress/tests/admin.js
+++ b/tests/stress/tests/admin.js
@@ -17,27 +17,84 @@ export class Admin extends Actor {
   }
 }
 
-export const adminNewBatch = (treatment = "10player", gameCount = 1) =>
+export function completeAssignment(treatments) {
+  return {
+    kind: "complete",
+    config: {
+      treatments,
+    },
+  };
+}
+
+export function completeTreatment(name, factors, count) {
+  return {
+    treatment: {
+      name,
+      factors,
+    },
+    count,
+  };
+}
+
+export function quickGame(playerCount, roundCount, stageCount, factors = {}) {
+  return completeAssignment([
+    completeTreatment(
+      "quick",
+      { ...factors, playerCount, roundCount, stageCount },
+      1
+    ),
+  ]);
+}
+
+/**
+ * @param {Object} params Information about the user.
+ * @param {string} [params.treatmentName] The name of the user.
+ * @param {Object} [params.treatmentConfig] The email of the user.
+ * @param {number} [params.gameCount] The email of the user.
+ */
+export const adminNewBatch = ({
+  treatmentName = "10player",
+  treatmentConfig = null,
+  gameCount = 1,
+}) =>
   new Step("new batch", async (actor) => {
     // Open the new batch dialog
     await actor.page.getByTestId("newBatchButton").click();
 
-    // Select the treatment
-    await actor.page
-      .getByTestId("treatmentSelect")
-      .selectOption({ label: treatment });
-
-    // Optionally set the game count
-    if (gameCount && gameCount > 1) {
-      await actor.page.locator('[data-test="gameCountInput"]').first().click();
+    if (treatmentConfig !== null) {
+      // Fill in a custom treatment
+      await actor.page.getByTestId("customAssignmentButton").click();
       await actor.page
-        .locator('[data-test="gameCountInput"]')
-        .first()
-        .press("Meta+a");
+        .getByTestId("configurationTextArea")
+        .fill(JSON.stringify(treatmentConfig));
+      await actor.screenshot("custom-treatment");
+
+      // Marking for the batch to be created with just the config
+      // in the textarea, without wrapping with kind=custom.
+      await actor.page.evaluate(() => {
+        window["rawCustomConfig"] = true;
+      });
+    } else {
+      // Select the treatment
       await actor.page
-        .locator('[data-test="gameCountInput"]')
-        .first()
-        .fill(`${gameCount}`);
+        .getByTestId("treatmentSelect")
+        .selectOption({ label: treatmentName });
+
+      // Optionally set the game count
+      if (gameCount && gameCount > 1) {
+        await actor.page
+          .locator('[data-test="gameCountInput"]')
+          .first()
+          .click();
+        await actor.page
+          .locator('[data-test="gameCountInput"]')
+          .first()
+          .press("Meta+a");
+        await actor.page
+          .locator('[data-test="gameCountInput"]')
+          .first()
+          .fill(`${gameCount}`);
+      }
     }
 
     // Create the batch
@@ -45,10 +102,8 @@ export const adminNewBatch = (treatment = "10player", gameCount = 1) =>
 
     // Wait for the batch to be created and get it
     await actor.page.mainFrame().waitForFunction("window.lastNewBatch");
-    const lastNewBatch = await actor.page.evaluate(() =>
-      // Using eval() because IDE complains about window.lastNewBatch not being
-      // defined...
-      eval("window.lastNewBatch")
+    const lastNewBatch = await actor.page.evaluate(
+      () => window["lastNewBatch"]
     );
 
     // This shouldn't happen, but just in case...
diff --git a/tests/stress/tests/attributes.spec.js b/tests/stress/tests/attributes.spec.js
new file mode 100644
index 00000000..99d9c4b0
--- /dev/null
+++ b/tests/stress/tests/attributes.spec.js
@@ -0,0 +1,69 @@
+// @ts-check
+/// <reference path="./index.d.ts" />
+
+const { test } = require("@playwright/test");
+import { Context } from "./context";
+import { adminNewBatch, quickGame } from "./admin";
+import { playerStart, submitStage, waitGameFinished } from "./player";
+import { sleep } from "./utils";
+
+// At the moment, we use the same empirica server for all tests, so we need to
+// run them serially. This will change when we have a dedicated server for eac XLh
+// test.
+test.describe.configure({ mode: "serial" });
+
+test.only("attribute as object, correct equality check", async ({
+  browser,
+}) => {
+  const ctx = new Context(browser);
+
+  const playerCount = 2;
+  const roundCount = 1;
+  const stageCount = 1;
+
+  ctx.logMatching(/mutObj/);
+  ctx.logMatching(/ set/);
+
+  await ctx.start();
+  await ctx.addPlayers(playerCount);
+  ctx.players[0].logWS();
+  ctx.players[1].logWS();
+
+  await ctx.applyAdmin(
+    adminNewBatch({
+      treatmentConfig: quickGame(playerCount, roundCount, stageCount),
+    })
+  );
+
+  // TODO fix watching keys...
+  // ctx.players[0].listenKey("game", "key1");
+  // ctx.players[1].listenKey("game", "key1");
+
+  await ctx.applyPlayers(playerStart);
+
+  // Initial value
+  await ctx.players[0].set("game", "key1", { hello: "world" });
+  await sleep(200);
+  await ctx.expectPlayers("game", "key1", { hello: "world" });
+
+  // Mutate object in place, verify that value is updated
+  await ctx.players[1].mutObj("game", "key1", "hello", "all");
+  await sleep(200);
+  await ctx.expectPlayers("game", "key1", { hello: "all" });
+
+  // And again
+  await ctx.players[1].mutObj("game", "key1", "hello", "everyone");
+  await sleep(200);
+  await ctx.expectPlayers("game", "key1", { hello: "everyone" });
+
+  // This should be a noop, you wouldn't see it from the interface, but you
+  // should be able to see from the test logs (confirmed at time of writing).
+  await ctx.players[1].mutObj("game", "key1", "hello", "everyone");
+  await sleep(200);
+  await ctx.expectPlayers("game", "key1", { hello: "everyone" });
+
+  await ctx.applyPlayers(submitStage);
+  await ctx.applyPlayers(waitGameFinished);
+
+  await ctx.close();
+});
diff --git a/tests/stress/tests/context.js b/tests/stress/tests/context.js
index bef08fff..444b62f6 100644
--- a/tests/stress/tests/context.js
+++ b/tests/stress/tests/context.js
@@ -83,6 +83,12 @@ export class Context {
   async applyPlayers(step) {
     await applyAll(this.players, step);
   }
+
+  async expectPlayers(kind, key, value) {
+    for (const player of this.players) {
+      await player.expect(kind, key, value);
+    }
+  }
 }
 
 export function applyAll(actors, step) {
diff --git a/tests/stress/tests/main.spec.js b/tests/stress/tests/main.spec.js
index b20bc7bd..07eef5ee 100644
--- a/tests/stress/tests/main.spec.js
+++ b/tests/stress/tests/main.spec.js
@@ -3,8 +3,13 @@
 
 const { test } = require("@playwright/test");
 import { Context } from "./context";
-import { adminNewBatch } from "./admin";
-import { playerStart } from "./player";
+import { adminNewBatch, quickGame } from "./admin";
+import {
+  playerStart,
+  submitStage,
+  waitGameFinished,
+  waitNextStage,
+} from "./player";
 import { sleep } from "./utils";
 
 // At the moment, we use the same empirica server for all tests, so we need to
@@ -21,15 +26,41 @@ test("1 x 10 player", async ({ browser }) => {
   await ctx.addPlayers(10);
   ctx.players[0].logWS();
 
-  await ctx.applyAdmin(adminNewBatch("10player"));
+  await ctx.applyAdmin(adminNewBatch({ treatmentName: "10player" }));
 
-  const starts = [];
-  for (const player of ctx.players) {
-    starts.push(player.apply(playerStart));
-    sleep(1000);
+  await ctx.applyPlayers(playerStart);
+
+  await ctx.close();
+});
+
+test("10 full games, 2 players", async ({ browser }) => {
+  const ctx = new Context(browser);
+
+  const playerCount = 2;
+  const roundCount = 1;
+  const stageCount = 10;
+  const totalStages = roundCount * stageCount;
+
+  await ctx.start();
+  await ctx.addPlayers(playerCount);
+  ctx.players[0].logWS();
+  ctx.players[0].listenScope("game");
+
+  await ctx.applyAdmin(
+    adminNewBatch({
+      treatmentConfig: quickGame(playerCount, roundCount, stageCount),
+    })
+  );
+
+  await ctx.applyPlayers(playerStart);
+  await ctx.applyPlayers(submitStage);
+
+  for (let i = 0; i < totalStages - 1; i++) {
+    await ctx.applyPlayers(waitNextStage);
+    await ctx.applyPlayers(submitStage);
   }
 
-  await Promise.all(starts);
+  await ctx.applyPlayers(waitGameFinished);
 
   await ctx.close();
 });
@@ -43,10 +74,10 @@ test.skip("4 x 10 player - staggered arrival", async ({ browser }) => {
   await ctx.addPlayers(40);
   ctx.players[0].logWS();
 
-  await ctx.applyAdmin(adminNewBatch("10player"));
-  await ctx.applyAdmin(adminNewBatch("10player"));
-  await ctx.applyAdmin(adminNewBatch("10player"));
-  await ctx.applyAdmin(adminNewBatch("10player"));
+  await ctx.applyAdmin(adminNewBatch({ treatmentName: "10player" }));
+  await ctx.applyAdmin(adminNewBatch({ treatmentName: "10player" }));
+  await ctx.applyAdmin(adminNewBatch({ treatmentName: "10player" }));
+  await ctx.applyAdmin(adminNewBatch({ treatmentName: "10player" }));
 
   const starts = [];
   for (const player of ctx.players) {
@@ -74,10 +105,10 @@ test.skip("4 x 10 player - concurrent arrival", async ({ browser }) => {
   await ctx.addPlayers(40);
   ctx.players[0].logWS();
 
-  await ctx.applyAdmin(adminNewBatch("10player"));
-  await ctx.applyAdmin(adminNewBatch("10player"));
-  await ctx.applyAdmin(adminNewBatch("10player"));
-  await ctx.applyAdmin(adminNewBatch("10player"));
+  await ctx.applyAdmin(adminNewBatch({ treatmentName: "10player" }));
+  await ctx.applyAdmin(adminNewBatch({ treatmentName: "10player" }));
+  await ctx.applyAdmin(adminNewBatch({ treatmentName: "10player" }));
+  await ctx.applyAdmin(adminNewBatch({ treatmentName: "10player" }));
   await ctx.applyPlayers(playerStart);
   await ctx.close();
 });
@@ -91,7 +122,7 @@ test("1 x 40 player - concurrent arrival", async ({ browser }) => {
   await ctx.addPlayers(40);
   ctx.players[0].logWS();
 
-  await ctx.applyAdmin(adminNewBatch("40player"));
+  await ctx.applyAdmin(adminNewBatch({ treatmentName: "40player" }));
   await ctx.applyPlayers(playerStart);
   await ctx.close();
 });
diff --git a/tests/stress/tests/player.js b/tests/stress/tests/player.js
index 0814bcda..93dd313d 100644
--- a/tests/stress/tests/player.js
+++ b/tests/stress/tests/player.js
@@ -30,6 +30,93 @@ export class Player extends Actor {
     await expect(
       this.page.getByRole("heading", { name: "No experiments available" })
     ).toBeVisible();
+
+    const scopeChangeIcon = chalk.gray("←");
+    const name = chalk.greenBright(`(${this.name})`.padEnd(10, " "));
+
+    await this.page.exposeFunction(
+      "keyChanged",
+      (kind, key, value, scopeExists) => {
+        console.log(
+          scopeChangeIcon,
+          chalk.magenta("KEY"),
+          name,
+          this.currentTS(),
+          scopeExists
+            ? chalk.green(` ${kind} ${key}=${value} ✔`)
+            : chalk.red(` ${kind} ✘`)
+        );
+      }
+    );
+
+    await this.page.exposeFunction("scopeChanged", (kind, scopeExists) => {
+      console.log(
+        scopeChangeIcon,
+        chalk.blue("SCP"),
+        name,
+        this.currentTS(),
+        scopeExists ? chalk.green(` ${kind} ✔`) : chalk.red(` ${kind} ✘`)
+      );
+    });
+  }
+
+  async listenScope(kind) {
+    await this.page.evaluate((kind) => {
+      eval("window.empirica_test_collector")[kind].listenScope();
+    }, kind);
+  }
+
+  async listenKey(kind, key) {
+    await this.page.evaluate(
+      ({ kind, key }) => {
+        eval("window.empirica_test_collector")[kind].listenKey(key);
+      },
+      { kind, key }
+    );
+  }
+
+  async get(kind, key) {
+    return await this.page.evaluate(
+      ({ kind, key }) => eval("window.empirica_test_collector")[kind].get(key),
+      { kind, key }
+    );
+  }
+
+  async set(kind, key, value) {
+    await this.page.evaluate(
+      ({ kind, key, value }) => {
+        eval("window.empirica_test_collector")[kind].set(key, value);
+      },
+      { kind, key, value }
+    );
+  }
+
+  async expect(kind, key, value) {
+    const val = JSON.stringify(await this.get(kind, key));
+    const valueJSON = JSON.stringify(value);
+    if (val !== valueJSON) {
+      throw new Error(
+        `value was not as expected, expected: ${valueJSON}, got: ${val}`
+      );
+    }
+  }
+
+  // mutObj is a special function that allows to mutate an object at key in
+  // place (without overwriting the whole object). This is to trigger a case,
+  // where the value is not updated correctly, because equality check is done on
+  // the object reference, not the content.
+  // The value at key must of course be an object. This is only really useful
+  // for this one test.
+  async mutObj(kind, key, k, v) {
+    await this.page.evaluate(
+      ({ kind, key, k, v }) => {
+        const record = eval("window.empirica_test_collector")[kind];
+        const myobject = record.get(key);
+        myobject[k] = v;
+        record.set(key, myobject);
+      },
+      { kind, key, k, v }
+    );
   }
 
   logWS() {
@@ -37,23 +124,42 @@ export class Player extends Actor {
       received: playerReceivedPrinter(this),
     });
   }
+
+  listen() {
+    return Math.floor(Date.now() / 1000);
+  }
 }
 
-export const playerStart = new Step("start", async (actor) => {
+export const playerStart = new Step("start game", async (actor) => {
   // Fill the form
   actor.info("fill form");
   await actor.page.locator("input#playerID").fill(actor.uniqueID);
   await actor.page.locator(`button[type="submit"]`).click();
 
-  // Wait for the lobby to be visible
+  // Wait for first stage to be visible
   actor.info("signed in");
-  await actor.page.getByTestId("game-started").waitFor({ timeout: 3000000 });
+  await actor.page.getByTestId("stage-ongoing").waitFor({ timeout: 3000000 });
 
-  // Wait for the game to start
   actor.info("game started");
   await actor.screenshot("game started");
 });
 
+export const submitStage = new Step("submit stage", async (actor) => {
+  await actor.page.getByTestId("submit-stage").click();
+  await actor.page.getByTestId("submitted").waitFor({ timeout: 1000 });
+});
+
+export const waitNextStage = new Step("wait next stage", async (actor) => {
+  await actor.page.getByTestId("stage-ongoing").waitFor({ timeout: 100000 });
+});
+
+export const waitGameFinished = new Step(
+  "wait game finished",
+  async (actor) => {
+    await actor.page.getByTestId("game-finished").waitFor({ timeout: 100000 });
+  }
+);
+
 function playerReceivedPrinter(actor) {
   const scopes = new Map();
   const receive = chalk.gray("←");