diff --git a/PLAYTEST_NOTES.md b/PLAYTEST_NOTES.md
index 57b9fe7c..de5ab473 100644
--- a/PLAYTEST_NOTES.md
+++ b/PLAYTEST_NOTES.md
@@ -4,6 +4,41 @@ This file is the durable record of runtime behavior, regressions, and the
evidence required before calling a visual bug fixed. Update it whenever scene,
camera, input, physics, mob-rendering, or asset-loading code changes.
+## 2026-08-18 GM Manastorm administration - COMPLETE
+
+- Server-authorized `Phenom` access, revisioned SQLite configuration, safe
+ all-Needs-tested defaults, public/offline caching, optimistic conflicts, and
+ denial/revision logging were exercised through the production HTTP surface.
+- The GM hub exposed all 406 deduplicated boss records, readiness and runnable
+ state, pool filters, six global switches, dungeon entry, placement editing,
+ and GM tests. A fresh revision correctly reported zero Ready bosses.
+- Live Wailing Caverns authoring captured and nudged the shared group anchor,
+ displayed derived party, boss, portal, and exact linked-mob data, and saved a
+ three-mob / two-kill Chaotic Link stage. The desktop Save control was moved
+ above the Tactical control after the playtest found their hit targets
+ overlapping; a normal semantic click then published the next revision.
+- Promoting an imported encounter directly to Ready initially exposed missing
+ stage materialization at the server boundary. The readiness transition now
+ persists its complete inherited stage. Cross-mode duplicates also merge
+ their mode memberships, so a boss imported for both leveling and end-game is
+ represented once and remains eligible in both modes.
+- Live pool acceptance promoted Lady Anacondra and Burning Felguard, entered a
+ level-1 public Manastorm, then marked the active Lady Anacondra record Not
+ ready from a parallel GM client. The existing run retained Lady Anacondra and
+ its two-stack Chaotic Link snapshot; after reload, the next run selected only
+ Burning Felguard. This verified new-run publication and active-run
+ immutability together.
+- Desktop and Thor-preview passes rendered the DOM editor over the dungeon,
+ retained camera/game separation while the panel was open, and exposed the GM
+ pause-menu entry. Console inspection found no errors and only the existing
+ third-party initialization deprecation warning.
+- Verification passed: server **7/7**, full Vitest **121 files / 699 tests**,
+ TypeScript, production build, and the KTX2 audit of 11,839 compressed textures
+ with zero fallbacks. The build retained the existing informational
+ large-chunk advisory.
+- Evidence: `playtest-artifacts/2026-08-18-gm-manastorm-admin/desktop-admin-hub.png`,
+ `desktop-world-editor-final.png`, and `thor-world-editor.png`.
+
## 2026-08-17 authentic combat VFX and audio - COMPLETE
- Player, party, and enemy combat actions now publish transient presentation
diff --git a/dungeon-pipeline/recipes/stormwind-stockade.json b/dungeon-pipeline/recipes/stormwind-stockade.json
index 51fc2f69..6fb96856 100644
--- a/dungeon-pipeline/recipes/stormwind-stockade.json
+++ b/dungeon-pipeline/recipes/stormwind-stockade.json
@@ -8,6 +8,7 @@
"clientBuild": "3.3.5a-Ascension",
"mapDirectory": "World/Maps/StormwindJail",
"environmentMode": "global-wmo",
+ "globalWmoAlignment": "source",
"difficultyVariants": [
{
"id": "normal",
diff --git a/package-lock.json b/package-lock.json
index ef8693dc..2ec41294 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "healer-man",
- "version": "0.1.4",
+ "version": "0.1.5",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "healer-man",
- "version": "0.1.4",
+ "version": "0.1.5",
"dependencies": {
"@capacitor/android": "8.4.1",
"@capacitor/core": "8.4.1",
@@ -21,6 +21,7 @@
},
"devDependencies": {
"@capacitor/cli": "8.4.1",
+ "@dimforge/rapier3d-compat": "0.19.2",
"@gltf-transform/cli": "^4.4.1",
"@gltf-transform/core": "^4.4.2",
"@recast-navigation/core": "0.43.1",
diff --git a/package.json b/package.json
index 31c97b80..0d579b29 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
{
"name": "healer-man",
"private": true,
- "version": "0.1.4",
+ "version": "0.1.5",
"type": "module",
"scripts": {
"dev": "vite --host 0.0.0.0",
@@ -118,6 +118,7 @@
},
"devDependencies": {
"@capacitor/cli": "8.4.1",
+ "@dimforge/rapier3d-compat": "0.19.2",
"@gltf-transform/cli": "^4.4.1",
"@gltf-transform/core": "^4.4.2",
"@recast-navigation/core": "0.43.1",
diff --git a/release-version.json b/release-version.json
index 478658d5..840a105e 100644
--- a/release-version.json
+++ b/release-version.json
@@ -1,4 +1,4 @@
{
- "versionName": "0.1.4",
- "versionCode": 1004
+ "versionName": "0.1.5",
+ "versionCode": 1005
}
diff --git a/scripts/dungeon-pipeline/compile-campaign-catalog.mjs b/scripts/dungeon-pipeline/compile-campaign-catalog.mjs
index c02c0668..5c7a1450 100644
--- a/scripts/dungeon-pipeline/compile-campaign-catalog.mjs
+++ b/scripts/dungeon-pipeline/compile-campaign-catalog.mjs
@@ -201,6 +201,7 @@ const ADT_SOURCE_BASES = new Set([
"z-y-negative-x",
]);
const GLOBAL_WMO_SOURCE_BASES = new Set(["draft", "flip-x"]);
+const GLOBAL_WMO_ALIGNMENTS = new Set(["player-anchor", "source"]);
function sourceBasisFor(recipe, environmentMode) {
if (environmentMode !== "adt-hybrid") {
@@ -220,6 +221,15 @@ function sourceBasisFor(recipe, environmentMode) {
return basis;
}
+function coordinateAlignmentFor(recipe, environmentMode) {
+ if (environmentMode !== "global-wmo") return "player-anchor";
+ const alignment = recipe.globalWmoAlignment ?? "player-anchor";
+ if (!GLOBAL_WMO_ALIGNMENTS.has(alignment)) {
+ throw new Error(`${recipe.slug}: unsupported global WMO alignment ${alignment}.`);
+ }
+ return alignment;
+}
+
/**
* Runtime drafts retain the original pipeline convention. wow.export ADT
* packages have an additional horizontal basis change baked into their GLBs.
@@ -238,7 +248,10 @@ function sourceToPackageBasis(position, environmentMode, sourceBasis) {
: point;
}
-function coordinateMapper(draft, environmentMode, playerAnchor, sourceBasis) {
+function coordinateMapper(draft, environmentMode, playerAnchor, sourceBasis, alignment) {
+ if (alignment === "source") {
+ return (position) => sourceToPackageBasis(position, environmentMode, sourceBasis);
+ }
const sourceEntrance = draft?.entrance
?? draft?.spawns?.[0]?.position
?? playerAnchor.position;
@@ -764,6 +777,7 @@ async function compile() {
}
const environmentMode = inferEnvironmentMode(recipe, assetPackage);
const sourceBasis = sourceBasisFor(recipe, environmentMode);
+ const coordinateAlignment = coordinateAlignmentFor(recipe, environmentMode);
const playerAnchor = assetPackage.anchors.find((anchor) => anchor.kind === "player");
const trashAnchor = assetPackage.anchors.find((anchor) => anchor.kind === "trash");
const bossAnchor = assetPackage.anchors.find((anchor) => anchor.kind === "boss");
@@ -794,6 +808,12 @@ async function compile() {
environmentMode,
playerAnchor,
sourceBasis,
+ coordinateAlignment,
+ );
+ const entrancePosition = mapPosition(
+ draft?.entrance
+ ?? draft?.spawns?.[0]?.position
+ ?? playerAnchor.position,
);
const sourceEntities = (draft?.entities ?? [])
.filter((entity) => (
@@ -966,7 +986,7 @@ async function compile() {
});
for (let index = 0; index < 15; index += 1) {
const segment = index < 6
- ? interpolate(playerAnchor.position, trashAnchor.position, 0.25 + index * 0.1)
+ ? interpolate(entrancePosition, trashAnchor.position, 0.25 + index * 0.1)
: interpolate(trashAnchor.position, bossAnchor.position, 0.08 + (index - 6) * 0.085);
staticSpawns.push({
id: `generated-trash-${index + 1}`,
@@ -979,7 +999,7 @@ async function compile() {
}
const allPoints = [
- playerAnchor.position,
+ entrancePosition,
trashAnchor.position,
bossAnchor.position,
...staticSpawns.map((spawn) => spawn.position),
@@ -1010,7 +1030,9 @@ async function compile() {
modelCoverageWarning,
...(syntheticTrash
? ["Trash identities and placements are procedural; boss identities come from the installed Ascension encounter catalog."]
- : [`Server positions were aligned to the packaged ${environmentMode} environment at its reviewed player anchor.`]),
+ : coordinateAlignment === "source"
+ ? [`Server positions use the packaged ${environmentMode} environment's native world coordinates.`]
+ : [`Server positions were aligned to the packaged ${environmentMode} environment at its reviewed player anchor.`]),
];
definitions.push({
@@ -1034,12 +1056,12 @@ async function compile() {
bounds,
entrance: {
name: `${recipe.title} Entrance`,
- footPosition: vector(playerAnchor.position),
+ footPosition: vector(entrancePosition),
forward: [Math.sin(entranceYaw), 0, Math.cos(entranceYaw)],
yaw: entranceYaw,
},
areas: [
- { id: "entrance", name: `${recipe.title} Entrance`, center: vector(playerAnchor.position), radius: 35 },
+ { id: "entrance", name: `${recipe.title} Entrance`, center: vector(entrancePosition), radius: 35 },
...bosses.map((boss) => ({
id: `area-${slugPart(boss.name)}`,
name: `${boss.name}'s Encounter`,
@@ -1068,6 +1090,10 @@ async function compile() {
? sourceBasis === "z-y-negative-x"
? "three(x,y,z)=(wow.y,wow.z,wow.x)"
: "three(x,y,z)=(-wow.y,wow.z,wow.x)"
+ : coordinateAlignment === "source"
+ ? sourceBasis === "flip-x"
+ ? "three(x,y,z)=(-draft.x,draft.y,draft.z)"
+ : "three(x,y,z)=draft(x,y,z)"
: sourceBasis === "flip-x"
? "three(x,y,z)=(-draft.x,draft.y,draft.z)+package-anchor-translation"
: "three(x,y,z)=draft(x,y,z)+package-anchor-translation",
diff --git a/server/database.mjs b/server/database.mjs
index 68322408..58c04daf 100644
--- a/server/database.mjs
+++ b/server/database.mjs
@@ -3,6 +3,10 @@ import { mkdirSync } from "node:fs";
import path from "node:path";
import { promisify } from "node:util";
import { DatabaseSync } from "node:sqlite";
+import {
+ cloneDefaultManastormAdminConfig,
+ normalizeManastormAdminConfig,
+} from "./manastorm-config.mjs";
const scrypt = promisify(scryptCallback);
@@ -33,8 +37,19 @@ async function derivePassword(password, salt) {
return Buffer.from(await scrypt(password, salt, 64));
}
+const GM_USERNAME_KEYS = new Set(["phenom"]);
+
+function accountRoles(username) {
+ return GM_USERNAME_KEYS.has(String(username ?? "").trim().toLowerCase()) ? ["gm"] : [];
+}
+
function publicAccount(row) {
- return { id: row.id, username: row.username, createdAt: Number(row.created_at) };
+ return {
+ id: row.id,
+ username: row.username,
+ createdAt: Number(row.created_at ?? row.createdAt),
+ roles: accountRoles(row.username),
+ };
}
export function openGameDatabase(options = {}) {
@@ -62,7 +77,21 @@ export function openGameDatabase(options = {}) {
account_id TEXT PRIMARY KEY REFERENCES accounts(id) ON DELETE CASCADE,
revision INTEGER NOT NULL, data_json TEXT NOT NULL, updated_at INTEGER NOT NULL
) STRICT;
+ CREATE TABLE IF NOT EXISTS manastorm_admin_config (
+ id INTEGER PRIMARY KEY CHECK (id = 1),
+ schema_version INTEGER NOT NULL,
+ revision INTEGER NOT NULL,
+ config_json TEXT NOT NULL,
+ updated_by_account_id TEXT REFERENCES accounts(id) ON DELETE SET NULL,
+ updated_by_username TEXT,
+ updated_at INTEGER
+ ) STRICT;
`);
+ database.prepare(`
+ INSERT OR IGNORE INTO manastorm_admin_config (
+ id, schema_version, revision, config_json, updated_by_account_id, updated_by_username, updated_at
+ ) VALUES (1, 1, 0, ?, NULL, NULL, NULL)
+ `).run(JSON.stringify(cloneDefaultManastormAdminConfig()));
const statements = {
accountByUsername: database.prepare("SELECT * FROM accounts WHERE username_key = ?"),
@@ -82,6 +111,18 @@ export function openGameDatabase(options = {}) {
data_json = excluded.data_json, updated_at = excluded.updated_at
RETURNING revision, updated_at
`),
+ manastormConfig: database.prepare("SELECT * FROM manastorm_admin_config WHERE id = 1"),
+ updateManastormConfig: database.prepare(`
+ UPDATE manastorm_admin_config
+ SET schema_version = 1,
+ revision = revision + 1,
+ config_json = ?,
+ updated_by_account_id = ?,
+ updated_by_username = ?,
+ updated_at = ?
+ WHERE id = 1 AND revision = ?
+ RETURNING revision, updated_at
+ `),
};
function issueSession(accountId) {
@@ -110,7 +151,7 @@ export function openGameDatabase(options = {}) {
}
throw error;
}
- return { account, ...issueSession(account.id) };
+ return { account: publicAccount(account), ...issueSession(account.id) };
}
async function login(usernameInput, password) {
@@ -160,6 +201,58 @@ export function openGameDatabase(options = {}) {
return { revision: Number(row.revision), updatedAt: Number(row.updated_at), data };
}
+ function isGameMaster(account) {
+ // Recompute authority from the server allowlist for every privileged call.
+ return accountRoles(account?.username).includes("gm");
+ }
+
+ function getManastormConfig() {
+ const row = statements.manastormConfig.get();
+ try {
+ return {
+ revision: Number(row?.revision ?? 0),
+ updatedAt: row?.updated_at == null ? null : Number(row.updated_at),
+ updatedBy: row?.updated_by_username ?? null,
+ config: normalizeManastormAdminConfig(JSON.parse(row?.config_json ?? "null")),
+ };
+ } catch (error) {
+ console.error("Healer Man Manastorm configuration is corrupt; using safe defaults", error);
+ return { revision: 0, updatedAt: null, updatedBy: null, config: cloneDefaultManastormAdminConfig() };
+ }
+ }
+
+ function putManastormConfig(account, expectedRevision, config) {
+ if (!isGameMaster(account)) {
+ throw new GameDatabaseError("Game Master access is required.", 403, "gm_required");
+ }
+ if (!Number.isInteger(expectedRevision) || expectedRevision < 0) {
+ throw new GameDatabaseError("A valid expected revision is required.", 400, "invalid_revision");
+ }
+ let normalized;
+ try {
+ normalized = normalizeManastormAdminConfig(config);
+ } catch (error) {
+ throw new GameDatabaseError(error instanceof Error ? error.message : "Invalid Manastorm configuration.", 400, "invalid_manastorm_config");
+ }
+ const now = Date.now();
+ const row = statements.updateManastormConfig.get(
+ JSON.stringify(normalized),
+ account.id,
+ account.username,
+ now,
+ expectedRevision,
+ );
+ if (!row) {
+ throw new GameDatabaseError("The Manastorm configuration changed. Reload and try again.", 409, "revision_conflict");
+ }
+ return {
+ revision: Number(row.revision),
+ updatedAt: Number(row.updated_at),
+ updatedBy: account.username,
+ config: normalized,
+ };
+ }
+
return {
databasePath,
register,
@@ -168,6 +261,9 @@ export function openGameDatabase(options = {}) {
logout: (token) => { if (typeof token === "string" && token) statements.deleteSession.run(tokenHash(token)); },
getCloudSave,
putCloudSave,
+ isGameMaster,
+ getManastormConfig,
+ putManastormConfig,
pruneExpiredSessions: () => Number(statements.deleteExpiredSessions.run(Date.now()).changes),
close: () => database.close(),
};
diff --git a/server/database.test.mjs b/server/database.test.mjs
index 845aae3d..05c1fc3d 100644
--- a/server/database.test.mjs
+++ b/server/database.test.mjs
@@ -3,6 +3,7 @@ import { mkdtempSync, rmSync } from "node:fs";
import os from "node:os";
import path from "node:path";
import test from "node:test";
+import { DatabaseSync } from "node:sqlite";
import { GameDatabaseError, openGameDatabase } from "./database.mjs";
function withDatabase(run) {
@@ -52,3 +53,72 @@ test("persists opaque cloud roster data with increasing revisions", () => withDa
assert.equal(second.revision, 2);
assert.equal(database.getCloudSave(registered.account.id).data.characters[0].name, "Mendbetter");
}));
+
+test("derives GM authority from the hardcoded Phenom account", () => withDatabase(async (database) => {
+ const gm = await database.register("Phenom", "storm-admin");
+ const player = await database.register("Ordinary", "storm-player");
+ assert.deepEqual(gm.account.roles, ["gm"]);
+ assert.deepEqual((await database.login("pHeNoM", "storm-admin")).account.roles, ["gm"]);
+ assert.equal(database.isGameMaster(database.authenticate(gm.token)), true);
+ assert.equal(database.isGameMaster(database.authenticate(player.token)), false);
+ assert.equal(database.isGameMaster({ ...player.account, roles: ["gm"] }), false);
+}));
+
+test("recovers Manastorm configuration after restart and falls back safely from corrupt data", async () => {
+ const directory = mkdtempSync(path.join(os.tmpdir(), "healer-man-db-restart-test-"));
+ const databasePath = path.join(directory, "game.db");
+ try {
+ const first = openGameDatabase({ databasePath });
+ const gm = await first.register("Phenom", "storm-admin");
+ const current = first.getManastormConfig();
+ first.putManastormConfig(first.authenticate(gm.token), 0, {
+ ...current.config,
+ global: { ...current.config.global, enabled: false },
+ });
+ first.close();
+
+ const restarted = openGameDatabase({ databasePath });
+ assert.equal(restarted.getManastormConfig().revision, 1);
+ assert.equal(restarted.getManastormConfig().config.global.enabled, false);
+ restarted.close();
+
+ const raw = new DatabaseSync(databasePath);
+ raw.prepare("UPDATE manastorm_admin_config SET config_json = ? WHERE id = 1").run("{corrupt");
+ raw.close();
+ const recovered = openGameDatabase({ databasePath });
+ assert.equal(recovered.getManastormConfig().revision, 0);
+ assert.deepEqual(recovered.getManastormConfig().config.bosses, {});
+ recovered.close();
+ } finally {
+ rmSync(directory, { recursive: true, force: true });
+ }
+});
+
+test("persists revisioned Manastorm GM configuration and rejects stale or unauthorized writes", () => withDatabase(async (database) => {
+ const gm = await database.register("Phenom", "storm-admin");
+ const player = await database.register("Ordinary", "storm-player");
+ const gmAccount = database.authenticate(gm.token);
+ const playerAccount = database.authenticate(player.token);
+ const initial = database.getManastormConfig();
+ assert.equal(initial.revision, 0);
+ assert.deepEqual(initial.config.bosses, {});
+
+ const configured = {
+ ...initial.config,
+ global: { ...initial.config.global, affixesEnabled: false },
+ };
+ const saved = database.putManastormConfig(gmAccount, 0, configured);
+ assert.equal(saved.revision, 1);
+ assert.equal(saved.config.global.affixesEnabled, false);
+ assert.equal(database.getManastormConfig().updatedBy, "Phenom");
+ assert.throws(() => database.putManastormConfig(gmAccount, 0, configured), (error) => (
+ error instanceof GameDatabaseError && error.status === 409
+ ));
+ assert.throws(() => database.putManastormConfig(playerAccount, 1, configured), (error) => (
+ error instanceof GameDatabaseError && error.status === 403
+ ));
+ assert.throws(() => database.putManastormConfig(gmAccount, 1, {
+ ...configured,
+ bosses: { "boss:incomplete": { status: "ready" } },
+ }), (error) => error instanceof GameDatabaseError && error.status === 400);
+}));
diff --git a/server/manastorm-config.mjs b/server/manastorm-config.mjs
new file mode 100644
index 00000000..5c89d582
--- /dev/null
+++ b/server/manastorm-config.mjs
@@ -0,0 +1,161 @@
+export const MANASTORM_ADMIN_CONFIG_SCHEMA_VERSION = 1;
+
+export const DEFAULT_MANASTORM_ADMIN_CONFIG = Object.freeze({
+ schemaVersion: MANASTORM_ADMIN_CONFIG_SCHEMA_VERSION,
+ global: Object.freeze({
+ enabled: true,
+ levelingEnabled: true,
+ endgameEnabled: true,
+ affixesEnabled: true,
+ chaoticLinkEnabled: true,
+ milestoneEncountersEnabled: true,
+ }),
+ dungeonSpawns: Object.freeze({}),
+ bosses: Object.freeze({}),
+});
+
+const BOSS_STATUSES = new Set(["ready", "needs-tested", "not-ready"]);
+const MAX_RECORDS = 10_000;
+const MAX_ID_LENGTH = 256;
+
+function invalid(message) {
+ const error = new Error(message);
+ error.code = "invalid_manastorm_config";
+ return error;
+}
+
+function record(value, label) {
+ if (!value || typeof value !== "object" || Array.isArray(value)) {
+ throw invalid(`${label} must be an object.`);
+ }
+ return value;
+}
+
+function identifier(value, label) {
+ if (typeof value !== "string" || !value.trim() || value.length > MAX_ID_LENGTH) {
+ throw invalid(`${label} must be a non-empty string no longer than ${MAX_ID_LENGTH} characters.`);
+ }
+ return value.trim();
+}
+
+function optionalIdentifier(value, label) {
+ return value === undefined || value === null ? undefined : identifier(value, label);
+}
+
+function finiteNumber(value, label) {
+ if (typeof value !== "number" || !Number.isFinite(value)) {
+ throw invalid(`${label} must be a finite number.`);
+ }
+ return value;
+}
+
+function vector(value, label) {
+ if (!Array.isArray(value) || value.length !== 3) {
+ throw invalid(`${label} must contain exactly three coordinates.`);
+ }
+ return value.map((coordinate, index) => finiteNumber(coordinate, `${label}[${index}]`));
+}
+
+function worldSpawn(value, label) {
+ const input = record(value, label);
+ return {
+ footPosition: vector(input.footPosition, `${label}.footPosition`),
+ yaw: finiteNumber(input.yaw, `${label}.yaw`),
+ };
+}
+
+function boolean(value, label) {
+ if (typeof value !== "boolean") throw invalid(`${label} must be a boolean.`);
+ return value;
+}
+
+function normalizeGlobal(value) {
+ const input = record(value, "config.global");
+ return {
+ enabled: boolean(input.enabled, "config.global.enabled"),
+ levelingEnabled: boolean(input.levelingEnabled, "config.global.levelingEnabled"),
+ endgameEnabled: boolean(input.endgameEnabled, "config.global.endgameEnabled"),
+ affixesEnabled: boolean(input.affixesEnabled, "config.global.affixesEnabled"),
+ chaoticLinkEnabled: boolean(input.chaoticLinkEnabled, "config.global.chaoticLinkEnabled"),
+ milestoneEncountersEnabled: boolean(
+ input.milestoneEncountersEnabled,
+ "config.global.milestoneEncountersEnabled",
+ ),
+ };
+}
+
+function normalizeStage(value, label) {
+ const input = record(value, label);
+ const linkedMobRuntimeIds = Array.isArray(input.linkedMobRuntimeIds)
+ ? input.linkedMobRuntimeIds.map((id, index) => identifier(id, `${label}.linkedMobRuntimeIds[${index}]`))
+ : (() => { throw invalid(`${label}.linkedMobRuntimeIds must be an array.`); })();
+ if (new Set(linkedMobRuntimeIds).size !== linkedMobRuntimeIds.length) {
+ throw invalid(`${label}.linkedMobRuntimeIds must not contain duplicates.`);
+ }
+ const requiredKillCount = finiteNumber(input.requiredKillCount, `${label}.requiredKillCount`);
+ if (!Number.isInteger(requiredKillCount) || requiredKillCount < 0 || requiredKillCount > linkedMobRuntimeIds.length) {
+ throw invalid(`${label}.requiredKillCount must be an integer between zero and the linked mob count.`);
+ }
+ const mapId = finiteNumber(input.mapId, `${label}.mapId`);
+ if (!Number.isInteger(mapId) || mapId <= 0) throw invalid(`${label}.mapId must be a positive integer.`);
+ return {
+ dungeonId: identifier(input.dungeonId, `${label}.dungeonId`),
+ mapId,
+ bossRuntimeId: identifier(input.bossRuntimeId, `${label}.bossRuntimeId`),
+ bossEntityId: identifier(input.bossEntityId, `${label}.bossEntityId`),
+ bossName: identifier(input.bossName, `${label}.bossName`),
+ ...(optionalIdentifier(input.baseStageId, `${label}.baseStageId`)
+ ? { baseStageId: optionalIdentifier(input.baseStageId, `${label}.baseStageId`) }
+ : {}),
+ ...(optionalIdentifier(input.assetPackageId, `${label}.assetPackageId`)
+ ? { assetPackageId: optionalIdentifier(input.assetPackageId, `${label}.assetPackageId`) }
+ : {}),
+ bossPosition: vector(input.bossPosition, `${label}.bossPosition`),
+ bossYaw: finiteNumber(input.bossYaw, `${label}.bossYaw`),
+ groupSpawn: worldSpawn(input.groupSpawn, `${label}.groupSpawn`),
+ portalPosition: vector(input.portalPosition, `${label}.portalPosition`),
+ linkedMobRuntimeIds,
+ requiredKillCount,
+ };
+}
+
+function normalizeDictionary(value, label, normalizeValue) {
+ const input = record(value, label);
+ const entries = Object.entries(input);
+ if (entries.length > MAX_RECORDS) throw invalid(`${label} contains too many records.`);
+ return Object.fromEntries(entries.map(([key, entry]) => [
+ identifier(key, `${label} key`),
+ normalizeValue(entry, `${label}.${key}`),
+ ]));
+}
+
+export function normalizeManastormAdminConfig(value) {
+ const input = record(value, "config");
+ if (input.schemaVersion !== MANASTORM_ADMIN_CONFIG_SCHEMA_VERSION) {
+ throw invalid(`Unsupported Manastorm admin config schema ${String(input.schemaVersion)}.`);
+ }
+ const dungeonSpawns = normalizeDictionary(input.dungeonSpawns, "config.dungeonSpawns", worldSpawn);
+ const bosses = normalizeDictionary(input.bosses, "config.bosses", (rawBoss, label) => {
+ const boss = record(rawBoss, label);
+ if (!BOSS_STATUSES.has(boss.status)) throw invalid(`${label}.status is invalid.`);
+ if (boss.status === "ready" && (boss.stage === undefined || boss.stage === null)) {
+ throw invalid(`${label} cannot be Ready without a complete stage.`);
+ }
+ return {
+ status: boss.status,
+ ...(boss.stage === undefined || boss.stage === null
+ ? {}
+ : { stage: normalizeStage(boss.stage, `${label}.stage`) }),
+ };
+ });
+ return {
+ schemaVersion: MANASTORM_ADMIN_CONFIG_SCHEMA_VERSION,
+ global: normalizeGlobal(input.global),
+ dungeonSpawns,
+ bosses,
+ };
+}
+
+export function cloneDefaultManastormAdminConfig() {
+ return JSON.parse(JSON.stringify(DEFAULT_MANASTORM_ADMIN_CONFIG));
+}
diff --git a/server/server.mjs b/server/server.mjs
index 5e6f37c0..6ea48962 100644
--- a/server/server.mjs
+++ b/server/server.mjs
@@ -209,6 +209,27 @@ export function createGameServer(options = {}) {
json(response, 200, gameDatabase.putCloudSave(account.id, body.data));
return;
}
+ if (url.pathname === "/api/manastorm-config" && request.method === "GET") {
+ const current = gameDatabase.getManastormConfig();
+ json(response, 200, {
+ revision: current.revision,
+ updatedAt: current.updatedAt,
+ config: current.config,
+ });
+ return;
+ }
+ if (url.pathname === "/api/gm/manastorm-config" && request.method === "PUT") {
+ const account = gameDatabase.authenticate(bearerToken(request));
+ if (!gameDatabase.isGameMaster(account)) {
+ console.warn(`Denied Manastorm GM write for ${account.username} (${account.id})`);
+ throw new GameDatabaseError("Game Master access is required.", 403, "gm_required");
+ }
+ const body = await readJson(request, bodyLimit);
+ const result = gameDatabase.putManastormConfig(account, body.expectedRevision, body.config);
+ console.info(`Manastorm configuration revision ${result.revision} published by ${account.username}`);
+ json(response, 200, result);
+ return;
+ }
if (url.pathname.startsWith("/api/")) {
json(response, 404, { error: "API route not found.", code: "not_found" });
return;
diff --git a/server/server.test.mjs b/server/server.test.mjs
index 4c3d9731..c74b2278 100644
--- a/server/server.test.mjs
+++ b/server/server.test.mjs
@@ -53,6 +53,37 @@ test("serves the game and authenticated cloud-save API", async () => {
});
assert.equal(saved.status, 200);
assert.equal((await saved.json()).revision, 1);
+
+ const publicConfig = await fetch(`${origin}/api/manastorm-config`);
+ assert.equal(publicConfig.status, 200);
+ assert.equal((await publicConfig.json()).revision, 0);
+
+ const denied = await fetch(`${origin}/api/gm/manastorm-config`, {
+ method: "PUT",
+ headers: { "Content-Type": "application/json", Authorization: `Bearer ${auth.token}` },
+ body: JSON.stringify({ expectedRevision: 0, config: { schemaVersion: 1 } }),
+ });
+ assert.equal(denied.status, 403);
+
+ const gmRegistration = await fetch(`${origin}/api/auth/register`, {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ username: "Phenom", password: "storm-admin" }),
+ });
+ assert.equal(gmRegistration.status, 201);
+ const gmAuth = await gmRegistration.json();
+ assert.deepEqual(gmAuth.account.roles, ["gm"]);
+ const current = await (await fetch(`${origin}/api/manastorm-config`)).json();
+ const published = await fetch(`${origin}/api/gm/manastorm-config`, {
+ method: "PUT",
+ headers: { "Content-Type": "application/json", Authorization: `Bearer ${gmAuth.token}` },
+ body: JSON.stringify({
+ expectedRevision: current.revision,
+ config: { ...current.config, global: { ...current.config.global, chaoticLinkEnabled: false } },
+ }),
+ });
+ assert.equal(published.status, 200);
+ assert.equal((await published.json()).config.global.chaoticLinkEnabled, false);
} finally {
await new Promise((resolve) => runtime.server.close(resolve));
rmSync(directory, { recursive: true, force: true });
diff --git a/src/App.tsx b/src/App.tsx
index 5956fe59..2b96e666 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,5 +1,6 @@
-import { lazy, Suspense } from "react";
+import { lazy, Suspense, useEffect } from "react";
import { useShellStore } from "./app/shellStore";
+import { useManastormAdminStore } from "./game/manastormAdminStore";
import { useAuthoritativeDualScreenSync, useForcedThorDisplays } from "./platform/useThorDualScreen";
import { LoginScreen } from "./ui/LoginScreen";
@@ -10,6 +11,7 @@ const ClassHallScreen = lazy(() => import("./ui/ClassHallScreen").then((module)
const DungeonSelectScreen = lazy(() => import("./ui/DungeonSelectScreen").then((module) => ({ default: module.DungeonSelectScreen })));
const MainMenuScreen = lazy(() => import("./ui/MainMenuScreen").then((module) => ({ default: module.MainMenuScreen })));
const ManastormSelectScreen = lazy(() => import("./ui/ManastormSelectScreen").then((module) => ({ default: module.ManastormSelectScreen })));
+const GmAdminScreen = lazy(() => import("./ui/GmAdminScreen").then((module) => ({ default: module.GmAdminScreen })));
function ShellTransition() {
return HMOpening expeditionPreparing the next screen...
;
@@ -19,6 +21,12 @@ export default function App() {
useForcedThorDisplays();
useAuthoritativeDualScreenSync();
const phase = useShellStore((state) => state.phase);
+ const sessionOwnerId = useShellStore((state) => state.session?.ownerId ?? null);
+ const refreshManastormConfig = useManastormAdminStore((state) => state.refresh);
+
+ useEffect(() => {
+ void refreshManastormConfig();
+ }, [refreshManastormConfig, sessionOwnerId]);
if (phase === "login") return ;
if (phase === "characters") return }>;
@@ -27,6 +35,7 @@ export default function App() {
if (phase === "class-hall") return }>;
if (phase === "dungeons") return }>;
if (phase === "manastorms") return }>;
+ if (phase === "gm-admin") return }>;
if (phase !== "game") return null;
return (
}>
diff --git a/src/GameRuntime.tsx b/src/GameRuntime.tsx
index bbeb79f5..a2bc7998 100644
--- a/src/GameRuntime.tsx
+++ b/src/GameRuntime.tsx
@@ -19,6 +19,7 @@ import { GameplayPanels } from "./ui/GameplayPanels";
import { MapPanel } from "./ui/MapPanel";
import { PauseMenu } from "./ui/PauseMenu";
import { SceneErrorBoundary } from "./ui/SceneErrorBoundary";
+import { GmWorldEditor } from "./ui/GmWorldEditor";
function InputBridge() {
const overlay = useGameStore((state) => state.overlay);
@@ -88,6 +89,7 @@ export default function GameRuntime() {
+
}
bottom={}
diff --git a/src/app/accountRepository.test.ts b/src/app/accountRepository.test.ts
index 8186bdc0..e0b4f706 100644
--- a/src/app/accountRepository.test.ts
+++ b/src/app/accountRepository.test.ts
@@ -7,6 +7,7 @@ import {
listCharacters,
loadCombatPresentationSettings,
loginLocalAccount,
+ restoreSession,
updateCharacterActionBindings,
updateCharacterEquipment,
updateCharacterInventory,
@@ -86,6 +87,17 @@ describe("local profile repository", () => {
expect(listCharacters("offline-roster", storage)).toEqual([]);
});
+ it("drops spoofed GM roles from offline sessions", () => {
+ const storage = new MemoryStorage();
+ storage.setItem(PROFILE_STORAGE_KEYS.session, JSON.stringify({
+ kind: "offline",
+ ownerId: "offline-roster",
+ displayName: "Offline",
+ roles: ["gm"],
+ }));
+ expect(restoreSession(storage)?.roles).toEqual([]);
+ });
+
it("normalizes legacy profiles and persists progression atomically", () => {
const storage = new MemoryStorage();
storage.setItem(PROFILE_STORAGE_KEYS.database, JSON.stringify({
diff --git a/src/app/accountRepository.ts b/src/app/accountRepository.ts
index 71968eac..4f2acc88 100644
--- a/src/app/accountRepository.ts
+++ b/src/app/accountRepository.ts
@@ -374,7 +374,11 @@ export function restoreSession(storage: StorageLike | null = browserSessionStora
if (session.kind === "account"
&& typeof session.accessToken !== "string"
&& !readDatabase().accounts.some((account) => account.id === session.ownerId)) return null;
- return session as PlayerSession;
+ return {
+ ...(session as PlayerSession),
+ // Session storage is client-controlled. /api/me re-derives online roles.
+ roles: [],
+ };
} catch {
return null;
}
diff --git a/src/app/gmManastormRuntime.ts b/src/app/gmManastormRuntime.ts
new file mode 100644
index 00000000..c72d1eef
--- /dev/null
+++ b/src/app/gmManastormRuntime.ts
@@ -0,0 +1,102 @@
+import { touchCharacter } from "./accountRepository";
+import { useShellStore } from "./shellStore";
+import { registerGeneratedManastormStageAssets } from "../game/manastormAssetRegistry";
+import {
+ isGameMasterSession,
+ resolvedBossAdminCatalog,
+} from "../game/manastormAdminConfig";
+import { useManastormAdminStore } from "../game/manastormAdminStore";
+import { INSTALLED_MANASTORM_RUNTIME_CATALOG } from "../game/manastormInstalledCatalog";
+import { installedManastormStageBinding } from "../game/manastormInstalledStages";
+import { registerManastormStageBindingResolver } from "../game/manastormStagePopulation";
+import { activateManastormStage } from "../game/manastormStageLoader";
+import { manastormModeForCharacterLevel, setManastormCatalog } from "../game/manastorm";
+import { createEmptyManastormProgress, manastormModeProgress } from "../game/manastormProgress";
+import { manastormActiveSpellLoadoutModel } from "../game/manastormSpellLoadout";
+import { useManastormStore } from "../game/manastormStore";
+import { defaultPartyRoleForClass } from "../game/partyRoles";
+import { useGameStore } from "../game/store";
+
+export function enterGmManastormTest(bossKey: string): boolean {
+ const shell = useShellStore.getState();
+ if (!isGameMasterSession(shell.session) || !shell.selectedCharacterId) {
+ useShellStore.setState({ notice: "Game Master access is required." });
+ return false;
+ }
+ const activeCharacter = touchCharacter(shell.session!.ownerId, shell.selectedCharacterId)
+ ?? shell.characters.find((character) => character.id === shell.selectedCharacterId)
+ ?? null;
+ if (!activeCharacter) {
+ useShellStore.setState({ notice: "Select a character before testing a boss." });
+ return false;
+ }
+ const adminConfig = useManastormAdminStore.getState().config;
+ const entry = resolvedBossAdminCatalog(adminConfig).find((candidate) => candidate.key === bossKey);
+ if (!entry || entry.status === "not-ready" || !entry.runnable || !entry.stage) {
+ useShellStore.setState({ notice: entry?.validationIssues[0] ?? "That boss is not available for GM testing." });
+ return false;
+ }
+
+ registerGeneratedManastormStageAssets();
+ registerManastormStageBindingResolver(installedManastormStageBinding);
+ const modeId = manastormModeForCharacterLevel(activeCharacter.level, INSTALLED_MANASTORM_RUNTIME_CATALOG);
+ const { milestoneLevel: _milestoneLevel, ...stageWithoutMilestone } = entry.stage;
+ const testStage = Object.freeze({
+ ...stageWithoutMilestone,
+ modeIds: [modeId],
+ stageKind: "standard" as const,
+ unlockLevel: 1,
+ chaoticLinkEnabled: adminConfig.global.chaoticLinkEnabled,
+ });
+ const testCatalog = Object.freeze({
+ ...INSTALLED_MANASTORM_RUNTIME_CATALOG,
+ stages: [testStage],
+ fallbackPolicy: "none" as const,
+ runtimeOptions: Object.freeze({ ...adminConfig.global }),
+ });
+ setManastormCatalog(testCatalog);
+ useManastormStore.getState().resetRun();
+ const progress = activeCharacter.manastormProgress ?? createEmptyManastormProgress();
+ const modeProgress = manastormModeProgress(progress, modeId);
+ const spellLoadout = manastormActiveSpellLoadoutModel(
+ activeCharacter.classId,
+ activeCharacter.level,
+ activeCharacter.talentRanks,
+ );
+ let encounter;
+ try {
+ encounter = useManastormStore.getState().startRun({
+ partySize: 5,
+ startingLevel: 1,
+ unlockedThroughLevel: 1,
+ modeId,
+ activeSpellLoadout: {
+ available: spellLoadout.options,
+ selectedIds: progress.loadout,
+ maxSelections: spellLoadout.maxSelections,
+ provenance: spellLoadout.provenance,
+ },
+ cacheMeter: modeProgress.cacheMeter,
+ rewardCaches: modeProgress.rewardCaches,
+ random: () => 0,
+ });
+ } catch {
+ useShellStore.setState({ notice: "The configured boss could not be prepared for testing." });
+ return false;
+ }
+ if (!activateManastormStage(encounter, undefined, false, true).activated) {
+ useManastormStore.getState().resetRun();
+ useShellStore.setState({ notice: "The configured dungeon or stage package is not loadable." });
+ return false;
+ }
+
+ useGameStore.getState().setCompanionOpen(false);
+ useShellStore.setState({
+ phase: "game",
+ activeCharacter,
+ activeDungeonId: encounter.dungeonId,
+ activeDungeonRole: defaultPartyRoleForClass(activeCharacter.classId),
+ notice: `GM test: ${entry.name}`,
+ });
+ return true;
+}
diff --git a/src/app/manastormShellRuntime.ts b/src/app/manastormShellRuntime.ts
index b1e47bbf..9dda6257 100644
--- a/src/app/manastormShellRuntime.ts
+++ b/src/app/manastormShellRuntime.ts
@@ -14,6 +14,8 @@ import { useGameStore } from "../game/store";
import { useManastormStore } from "../game/manastormStore";
import { manastormModeForCharacterLevel, setManastormCatalog } from "../game/manastorm";
import { INSTALLED_MANASTORM_RUNTIME_CATALOG } from "../game/manastormInstalledCatalog";
+import { effectiveManastormCatalog } from "../game/manastormAdminConfig";
+import { useManastormAdminStore } from "../game/manastormAdminStore";
import { registerGeneratedManastormStageAssets } from "../game/manastormAssetRegistry";
import { installedManastormStageBinding } from "../game/manastormInstalledStages";
import { registerManastormStageBindingResolver } from "../game/manastormStagePopulation";
@@ -71,11 +73,28 @@ function enterManastorm(
const partySize = isManastormPartySize(requestedPartySize) ? requestedPartySize : 5;
registerGeneratedManastormStageAssets();
- setManastormCatalog(INSTALLED_MANASTORM_RUNTIME_CATALOG);
+ const adminConfig = useManastormAdminStore.getState().config;
+ if (!adminConfig.global.enabled) {
+ useShellStore.setState({ notice: "Manastorms are currently disabled by a Game Master." });
+ return false;
+ }
+ const effectiveCatalog = effectiveManastormCatalog(adminConfig, INSTALLED_MANASTORM_RUNTIME_CATALOG);
const modeId = manastormModeForCharacterLevel(
activeCharacter.level,
- INSTALLED_MANASTORM_RUNTIME_CATALOG,
+ effectiveCatalog,
);
+ if (
+ (modeId === 0 && !adminConfig.global.levelingEnabled)
+ || (modeId === 2 && !adminConfig.global.endgameEnabled)
+ ) {
+ useShellStore.setState({ notice: `${modeId === 2 ? "End-game" : "Leveling"} Manastorms are currently disabled.` });
+ return false;
+ }
+ if (!effectiveCatalog.stages?.length) {
+ useShellStore.setState({ notice: "No bosses are currently marked Ready for Manastorms." });
+ return false;
+ }
+ setManastormCatalog(effectiveCatalog);
const storedProgress = activeCharacter.manastormProgress ?? createEmptyManastormProgress();
const progress = modeId === 2
? applyManastormEndgameHandoff(storedProgress)
@@ -106,20 +125,26 @@ function enterManastorm(
const startingLevel = requestedStartingLevel === 1
? 1
: availableCheckpoint;
- const encounter = useManastormStore.getState().startRun({
- partySize,
- startingLevel,
- unlockedThroughLevel: Math.max(startingLevel, savedParty.highestLevel + 1),
- modeId,
- activeSpellLoadout: {
- available: spellLoadoutModel.options,
- selectedIds: progress.loadout,
- maxSelections: spellLoadoutModel.maxSelections,
- provenance: spellLoadoutModel.provenance,
- },
- cacheMeter: modeProgress.cacheMeter,
- rewardCaches: modeProgress.rewardCaches,
- });
+ let encounter;
+ try {
+ encounter = useManastormStore.getState().startRun({
+ partySize,
+ startingLevel,
+ unlockedThroughLevel: Math.max(startingLevel, savedParty.highestLevel + 1),
+ modeId,
+ activeSpellLoadout: {
+ available: spellLoadoutModel.options,
+ selectedIds: progress.loadout,
+ maxSelections: spellLoadoutModel.maxSelections,
+ provenance: spellLoadoutModel.provenance,
+ },
+ cacheMeter: modeProgress.cacheMeter,
+ rewardCaches: modeProgress.rewardCaches,
+ });
+ } catch {
+ useShellStore.setState({ notice: "No Ready boss is eligible for this Manastorm level and party size." });
+ return false;
+ }
if (!activateManastormStage(encounter, undefined, false).activated) {
useManastormStore.getState().resetRun();
useShellStore.setState({ notice: "The first Manastorm could not be opened." });
diff --git a/src/app/onlineAccountClient.ts b/src/app/onlineAccountClient.ts
index c649831c..6c8e11e1 100644
--- a/src/app/onlineAccountClient.ts
+++ b/src/app/onlineAccountClient.ts
@@ -11,7 +11,7 @@ const NATIVE_API_ORIGIN = "https://iwanttoheal.phenomrom.com";
const SAVE_DEBOUNCE_MS = 500;
interface AuthResponse {
- account: { id: string; username: string };
+ account: { id: string; username: string; roles?: readonly "gm"[] };
token: string;
}
@@ -21,6 +21,10 @@ interface CloudSaveResponse {
data: { version?: number; characters?: unknown };
}
+interface MeResponse {
+ account: { id: string; username: string; roles?: readonly "gm"[] };
+}
+
class OnlineApiError extends Error {
constructor(message: string, readonly status: number) {
super(message);
@@ -40,7 +44,7 @@ function apiOrigin(): string {
return Capacitor.isNativePlatform() ? NATIVE_API_ORIGIN : "";
}
-async function requestJson(pathname: string, init: RequestInit = {}, token?: string): Promise {
+export async function requestOnlineJson(pathname: string, init: RequestInit = {}, token?: string): Promise {
const headers = new Headers(init.headers);
headers.set("Accept", "application/json");
if (init.body !== undefined) headers.set("Content-Type", "application/json");
@@ -63,6 +67,7 @@ function accountResult(response: AuthResponse): AccountResult {
kind: "account",
ownerId: response.account.id,
displayName: response.account.username,
+ roles: response.account.roles ?? [],
accessToken: response.token,
},
};
@@ -70,7 +75,7 @@ function accountResult(response: AuthResponse): AccountResult {
async function authenticate(pathname: string, username: string, password: string): Promise {
try {
- const response = await requestJson(pathname, {
+ const response = await requestOnlineJson(pathname, {
method: "POST",
body: JSON.stringify({ username, password }),
});
@@ -94,7 +99,7 @@ function flushCloudSave(): void {
pendingCharacters = null;
if (!session?.accessToken || !characters) return;
saveQueue = saveQueue.then(async () => {
- await requestJson("/api/cloud-save", {
+ await requestOnlineJson("/api/cloud-save", {
method: "PUT",
body: JSON.stringify({ data: { version: 1, characters } }),
}, session.accessToken);
@@ -122,7 +127,7 @@ export function activateOnlineSession(session: PlayerSession): void {
export async function hydrateOnlineSession(session: PlayerSession): Promise {
if (!session.accessToken) return listCharacters(session.ownerId);
activateOnlineSession(session);
- const cloud = await requestJson("/api/cloud-save", {}, session.accessToken);
+ const cloud = await requestOnlineJson("/api/cloud-save", {}, session.accessToken);
suppressUpload = true;
try {
return replaceCharactersForOwner(session.ownerId, cloud.data?.characters ?? []);
@@ -131,6 +136,17 @@ export async function hydrateOnlineSession(session: PlayerSession): Promise {
+ if (!session.accessToken) return { ...session, roles: [] };
+ const response = await requestOnlineJson("/api/me", {}, session.accessToken);
+ return {
+ ...session,
+ ownerId: response.account.id,
+ displayName: response.account.username,
+ roles: response.account.roles ?? [],
+ };
+}
+
export async function logoutOnlineSession(session: PlayerSession | null): Promise {
if (saveTimer) {
clearTimeout(saveTimer);
@@ -139,7 +155,7 @@ export async function logoutOnlineSession(session: PlayerSession | null): Promis
}
if (session?.accessToken) {
await saveQueue;
- await requestJson("/api/auth/logout", { method: "POST" }, session.accessToken).catch(() => undefined);
+ await requestOnlineJson("/api/auth/logout", { method: "POST" }, session.accessToken).catch(() => undefined);
}
if (activeSession?.ownerId === session?.ownerId) activeSession = null;
}
diff --git a/src/app/shellStore.test.ts b/src/app/shellStore.test.ts
index 83bcb25f..2d847040 100644
--- a/src/app/shellStore.test.ts
+++ b/src/app/shellStore.test.ts
@@ -14,6 +14,12 @@ import {
mergeManastormUnlockedContent,
setManastormLoadout,
} from "../game/manastormProgress";
+import {
+ DEFAULT_MANASTORM_ADMIN_CONFIG,
+ UNIFIED_MANASTORM_BOSS_CATALOG,
+ resolveBossAdminEntry,
+} from "../game/manastormAdminConfig";
+import { useManastormAdminStore } from "../game/manastormAdminStore";
installDungeonShellRuntime();
installManastormShellRuntime();
@@ -37,6 +43,29 @@ const character = {
lastPlayedAt: 1,
};
+function readyBossForMode(modeId: number) {
+ return UNIFIED_MANASTORM_BOSS_CATALOG.find((entry) => (
+ (entry.baseStage?.unlockLevel ?? 1) <= 1
+ && (entry.baseStage?.minimumPartySize ?? 1) <= 1
+ && (entry.baseStage?.maximumPartySize ?? 5) >= 5
+ && (!entry.baseStage?.modeIds?.length || entry.baseStage.modeIds.includes(modeId))
+ && resolveBossAdminEntry(entry, {
+ ...DEFAULT_MANASTORM_ADMIN_CONFIG,
+ bosses: { [entry.key]: { status: "ready" } },
+ }).runnable
+ ));
+}
+const readyLevelingBoss = readyBossForMode(0);
+const readyEndgameBoss = readyBossForMode(2);
+if (!readyLevelingBoss || !readyEndgameBoss) throw new Error("Shell tests require runnable Manastorm bosses for both modes.");
+const readyTestConfig = {
+ ...DEFAULT_MANASTORM_ADMIN_CONFIG,
+ bosses: {
+ [readyLevelingBoss.key]: { status: "ready" as const },
+ [readyEndgameBoss.key]: { status: "ready" as const },
+ },
+};
+
function prepareSelectedCharacter(): void {
useShellStore.setState({
phase: "characters",
@@ -61,6 +90,7 @@ describe("shell store", () => {
});
useGameStore.getState().resetAtEntrance();
useManastormStore.getState().resetRun();
+ useManastormAdminStore.setState({ config: readyTestConfig, draft: readyTestConfig, dirty: false });
});
it("does not open the character hub or a dungeon without a selected character", () => {
diff --git a/src/app/shellStore.ts b/src/app/shellStore.ts
index d3a0f7d0..98bb86fe 100644
--- a/src/app/shellStore.ts
+++ b/src/app/shellStore.ts
@@ -51,7 +51,9 @@ import {
activateOnlineSession,
hydrateOnlineSession,
logoutOnlineSession,
+ refreshOnlineSession,
} from "./onlineAccountClient";
+import { isGameMasterSession } from "../game/manastormAdminConfig";
export interface ShellState {
phase: ShellPhase;
@@ -77,6 +79,7 @@ export interface ShellState {
openMainMenu: () => boolean;
openDungeons: () => boolean;
openManastorms: () => boolean;
+ openGmAdmin: () => boolean;
openClassHall: () => boolean;
chooseRomSecondaryClass: (classId: RomClassId) => boolean;
swapSelectedRomClasses: () => boolean;
@@ -294,6 +297,19 @@ export const useShellStore = create((set, get) => ({
set({ phase: "manastorms", activeCharacter: null, notice: "" });
return true;
},
+ openGmAdmin: () => {
+ const { session, selectedCharacterId, characters } = get();
+ if (!isGameMasterSession(session)) {
+ set({ notice: "Game Master access is required." });
+ return false;
+ }
+ if (!selectedCharacterId || !characters.some((character) => character.id === selectedCharacterId)) {
+ set({ phase: "characters", notice: "Select a character before opening GM Tools." });
+ return false;
+ }
+ set({ phase: "gm-admin", activeCharacter: null, notice: "" });
+ return true;
+ },
openClassHall: () => {
const { session, selectedCharacterId, characters } = get();
const character = characters.find((entry) => entry.id === selectedCharacterId);
@@ -500,10 +516,15 @@ export function selectedCharacter(state: ShellState): CharacterProfile | null {
if (restored.session?.accessToken) {
activateOnlineSession(restored.session);
- void hydrateOnlineSession(restored.session).then((characters) => {
+ void Promise.all([
+ hydrateOnlineSession(restored.session),
+ refreshOnlineSession(restored.session),
+ ]).then(([characters, refreshedSession]) => {
const current = useShellStore.getState().session;
if (current?.ownerId !== restored.session?.ownerId) return;
+ saveSession(refreshedSession);
useShellStore.setState({
+ session: refreshedSession,
characters,
selectedCharacterId: characters.some((character) => character.id === useShellStore.getState().selectedCharacterId)
? useShellStore.getState().selectedCharacterId
diff --git a/src/app/types.ts b/src/app/types.ts
index 8e158abe..5456c9c7 100644
--- a/src/app/types.ts
+++ b/src/app/types.ts
@@ -5,13 +5,15 @@ import type { EquipmentAssignments } from "../game/equipment";
import type { GameplaySettings } from "../game/combatStore";
import type { ManastormProgress } from "../game/manastormProgress";
-export type ShellPhase = "login" | "characters" | "create-character" | "main-menu" | "class-hall" | "dungeons" | "manastorms" | "game";
+export type ShellPhase = "login" | "characters" | "create-character" | "main-menu" | "class-hall" | "dungeons" | "manastorms" | "gm-admin" | "game";
export type SessionKind = "account" | "offline";
+export type AccountRole = "gm";
export interface PlayerSession {
kind: SessionKind;
ownerId: string;
displayName: string;
+ roles?: readonly AccountRole[];
/** Present for server-backed accounts; kept in session storage only. */
accessToken?: string;
}
diff --git a/src/game/CombatBridge.tsx b/src/game/CombatBridge.tsx
index 4536b0c3..17d52622 100644
--- a/src/game/CombatBridge.tsx
+++ b/src/game/CombatBridge.tsx
@@ -1,12 +1,10 @@
import { useEffect, useRef } from "react";
import { useShellStore } from "../app/shellStore";
import { useCombatStore } from "./combatStore";
-import { respawnDefeatedPlayer } from "./deathRespawn";
import { advanceDungeonPartyCombat } from "./partyRuntime";
import { useGameStore } from "./store";
import { activateManastormActiveSpellLoadout } from "./manastormSpellLoadout";
import { useManastormStore } from "./manastormStore";
-import { resolveManastormActorDown } from "./manastormSession";
import { useWailingEncounterStore } from "./wailingCavernsEncounter";
/**
@@ -126,16 +124,6 @@ export function CombatBridge() {
epochNow,
);
}
- if (useCombatStore.getState().health <= 0 && game.gameMode === "manastorm") {
- const resolution = resolveManastormActorDown({ kind: "player" });
- if (resolution === "failed") useShellStore.getState().failActiveManastorm();
- return;
- }
- if (respawnDefeatedPlayer()) {
- // resetAtEntrance increments this revision. Mark it consumed because
- // respawnDefeatedPlayer already reset combat atomically.
- mountedResetRevision.current = useGameStore.getState().resetRevision;
- }
}
}, 100);
return () => window.clearInterval(timer);
diff --git a/src/game/ManastormBridge.tsx b/src/game/ManastormBridge.tsx
index 0a334fb8..17953981 100644
--- a/src/game/ManastormBridge.tsx
+++ b/src/game/ManastormBridge.tsx
@@ -18,6 +18,7 @@ import { preloadManastormStage } from "./manastormStageLoader";
/** Connects staged combat, party sizing, and shared resurrections to Manastorm state. */
export function ManastormBridge() {
const gameMode = useGameStore((state) => state.gameMode);
+ const gmTestMode = useGameStore((state) => state.gmTestMode);
const status = useManastormStore((state) => state.status);
const partySize = useManastormStore((state) => state.partySize);
const encounter = useManastormStore((state) => state.currentEncounter);
@@ -103,7 +104,7 @@ export function ManastormBridge() {
useEffect(() => {
if (!characterId) return;
return useManastormStore.subscribe((state, previous) => {
- if (useGameStore.getState().gameMode !== "manastorm") return;
+ if (useGameStore.getState().gameMode !== "manastorm" || useGameStore.getState().gmTestMode) return;
const character = useShellStore.getState().activeCharacter;
if (!character || character.id !== characterId) return;
const result = synchronizeManastormProgress(
@@ -116,7 +117,7 @@ export function ManastormBridge() {
useShellStore.getState().saveActiveManastormProgress(result.progress);
}
});
- }, [characterId]);
+ }, [characterId, gmTestMode]);
return null;
}
diff --git a/src/game/combatStore.test.ts b/src/game/combatStore.test.ts
index 7fcbf94b..ee9f4dc7 100644
--- a/src/game/combatStore.test.ts
+++ b/src/game/combatStore.test.ts
@@ -124,6 +124,20 @@ describe("combat store", () => {
expect(useCombatStore.getState().setActionBinding("primary", "face-bottom", abilityId)).toBe(false);
});
+ it("requires an explicit resurrection action to restore a defeated player", () => {
+ const maxHealth = useCombatStore.getState().maxHealth;
+ useCombatStore.getState().damagePlayer(maxHealth * 10);
+
+ expect(useCombatStore.getState().health).toBe(0);
+ expect(useCombatStore.getState().healPlayer(maxHealth)).toBe(0);
+ expect(useCombatStore.getState().health).toBe(0);
+
+ const restored = useCombatStore.getState().revivePlayer(0.35);
+ expect(restored).toBe(Math.max(1, Math.round(maxHealth * 0.35)));
+ expect(useCombatStore.getState().health).toBe(restored);
+ expect(useCombatStore.getState().revivePlayer(1)).toBe(0);
+ });
+
it("starts with attribute-derived pools including racial and automatic class passives", () => {
const gnomeMage = deriveCharacterStats("mage", 1, EMPTY_ITEM_STATS, "gnome");
useCombatStore.getState().initializeCharacter({ classId: "mage", raceId: "gnome", level: 1 });
diff --git a/src/game/combatStore.ts b/src/game/combatStore.ts
index 160a56fc..d7dcdc22 100644
--- a/src/game/combatStore.ts
+++ b/src/game/combatStore.ts
@@ -520,6 +520,7 @@ export interface CombatState {
tauntMob: (id: string, source: ThreatSource, durationMs: number, now?: number) => boolean;
damagePlayer: (amount: number, school?: DamageSchool, attackerLevel?: number) => number;
healPlayer: (amount: number) => number;
+ revivePlayer: (percentMaxHealth?: number) => number;
cancelCast: (message?: string) => boolean;
engageNearbyMobs: (now?: number, playerPosition?: CombatPosition) => number;
advanceMobCombat: (now?: number, playerPosition?: CombatPosition) => number;
@@ -3851,6 +3852,9 @@ export const useCombatStore = create((set, get) => ({
healPlayer: (amount) => {
const state = get();
+ // Ordinary healing and lingering HoTs must not raise a defeated player.
+ // Resurrection is an explicit combat action handled by revivePlayer.
+ if (state.health <= 0) return 0;
const modified = resolveAuraHealingValue(
amount,
aurasForEntity(state.auras, PLAYER_AURA_ENTITY_ID),
@@ -3867,6 +3871,22 @@ export const useCombatStore = create((set, get) => ({
return healed;
},
+ revivePlayer: (percentMaxHealth = 0.35) => {
+ const state = get();
+ if (state.health > 0 || state.maxHealth <