Update Healer Man server

src/app/biteSizedDungeonRuntime.test.ts

@@ -1,5 +1,8 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { BITE_SIZED_STOCKADES_DUNGEON_ID } from "../game/dungeonContentSource";
+import {
+  BITE_SIZED_STOCKADES_DUNGEON_ID,
+  RANDOMIZED_BITE_SIZED_STOCKADES_DUNGEON_ID,
+} from "../game/dungeonContentSource";
 import type { DungeonRunProgress } from "../game/dungeonRunTypes";
 import { canStartAnotherBiteSizedDungeon, startAnotherBiteSizedDungeon } from "./biteSizedDungeonRuntime";
 import { useOnlineGroupStore } from "./onlineGroupStore";
@@ -52,6 +55,36 @@ describe("bite-sized replay", () => {
       difficultyId: "normal",
       bossDifficulty: 1,
       freshRun: true,
+      runId: expect.any(String),
+    });
+  });
+
+  it("replays randomized mode with a new seed and prepares that seed's creature assets", async () => {
+    const enterDungeon = vi.fn(() => true);
+    const saveCheckpoint = vi.fn();
+    const prepareRandomizedContent = vi.fn(async () => undefined);
+    useShellStore.setState({
+      session: { kind: "offline", ownerId: "local-owner", displayName: "Tester" },
+      activeDungeonRole: "healer",
+      enterDungeon,
+      saveActiveDungeonRunCheckpoint: saveCheckpoint,
+    });
+    const randomizedProgress = { ...progress, dungeonId: RANDOMIZED_BITE_SIZED_STOCKADES_DUNGEON_ID };
+
+    await expect(startAnotherBiteSizedDungeon(randomizedProgress, {
+      random: () => 0,
+      createRunId: () => "next-randomized-seed",
+      contentIsUsable: () => true,
+      prepareRandomizedContent,
+    })).resolves.toBe(true);
+
+    expect(prepareRandomizedContent).toHaveBeenCalledWith("next-randomized-seed");
+    expect(saveCheckpoint).toHaveBeenCalledWith(null);
+    expect(enterDungeon).toHaveBeenCalledWith(RANDOMIZED_BITE_SIZED_STOCKADES_DUNGEON_ID, "healer", {
+      difficultyId: "normal",
+      bossDifficulty: 1,
+      freshRun: true,
+      runId: "next-randomized-seed",
     });
   });
 
@@ -91,4 +124,31 @@ describe("bite-sized replay", () => {
     useShellStore.setState({ session: { kind: "account", ownerId: "follower", displayName: "Follower", accessToken: "test-token" } });
     expect(canStartAnotherBiteSizedDungeon()).toBe(false);
   });
+
+  it("publishes another randomized activity instead of crossing an online group into regular Bite-Sized", async () => {
+    const startActivity = vi.fn(async () => true);
+    useShellStore.setState({
+      session: { kind: "account", ownerId: "leader", displayName: "Leader", accessToken: "test-token" },
+      saveActiveDungeonRunCheckpoint: vi.fn(),
+    });
+    useOnlineGroupStore.setState({
+      startActivity,
+      snapshot: { invitations: [], group: { id: "group", leaderAccountId: "leader", members: [], activity: null,
+        activityRevision: 2, createdAt: 1, updatedAt: 2 } },
+    });
+
+    await expect(startAnotherBiteSizedDungeon(
+      { ...progress, dungeonId: RANDOMIZED_BITE_SIZED_STOCKADES_DUNGEON_ID },
+      { random: () => 0, createRunId: () => "unused-local-seed", contentIsUsable: () => true,
+        prepareRandomizedContent: vi.fn() },
+    )).resolves.toBe(true);
+
+    expect(startActivity).toHaveBeenCalledWith(expect.objectContaining({ ownerId: "leader" }), {
+      type: "dungeon",
+      contentId: RANDOMIZED_BITE_SIZED_STOCKADES_DUNGEON_ID,
+      difficultyId: "normal",
+      bossDifficulty: 1,
+      partySize: 5,
+    });
+  });
 });