833 lines
58 KiB
JavaScript
833 lines
58 KiB
JavaScript
const { spawnSync } = require('node:child_process');
|
|
const crypto = require('node:crypto');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const {
|
|
FULL_STOCKADE_DUNGEON_ID,
|
|
FULL_STOCKADE_DUNGEON_TITLE,
|
|
FULL_STOCKADE_BOSS,
|
|
} = require('./playtest-defaults.cjs');
|
|
|
|
const projectRoot = path.resolve(__dirname, '..');
|
|
const contentSourceDirectory = path.join(projectRoot, 'content');
|
|
const contentManifestPath = path.join(contentSourceDirectory, 'manifest.json');
|
|
const sourceHarnessPath = path.join(projectRoot, 'scripts', 'playtest-campaign-boss-pass.cjs');
|
|
const sourceHarness = fs.readFileSync(sourceHarnessPath, 'utf8');
|
|
const prepareOnly = process.argv.includes('--prepare-only');
|
|
const frozenBuildAuthorized = process.argv.includes('--frozen-build-authorized');
|
|
const runId = new Date().toISOString().replace(/[-:.]/g, '').replace('T', '-').replace('Z', '');
|
|
const outputDirectory = path.join(projectRoot, 'playtest-artifacts', 'stockade-stances-blocking', runId);
|
|
const childOutputDirectory = path.join(outputDirectory, 'campaign');
|
|
const runtimeHarnessPath = path.join(__dirname, `.playtest-stockade-stances-blocking-${process.pid}.cjs`);
|
|
const requestedBuildDirectory = process.env.HEALER_MAN_STOCKADE_DIST?.trim()
|
|
? path.resolve(process.env.HEALER_MAN_STOCKADE_DIST.trim()) : null;
|
|
const buildDirectory = requestedBuildDirectory ?? path.join(projectRoot, 'dist');
|
|
const expectedBuildSha256Argument = process.argv.find((value) => value.startsWith('--expected-build-sha256='))
|
|
?.slice('--expected-build-sha256='.length);
|
|
const expectedBuildSha256 = expectedBuildSha256Argument
|
|
?? process.env.HEALER_MAN_STOCKADE_DIST_SHA256?.trim() ?? null;
|
|
|
|
function sha256(bytes) {
|
|
return crypto.createHash('sha256').update(bytes).digest('hex');
|
|
}
|
|
|
|
function replaceExactlyOnce(source, marker, replacement, label) {
|
|
const count = source.split(marker).length - 1;
|
|
if (count !== 1) throw new Error(`${label} must occur exactly once in the source harness; found ${count}.`);
|
|
return source.replace(marker, replacement);
|
|
}
|
|
|
|
function replaceFirstOccurrence(source, marker, replacement, label) {
|
|
if (!source.includes(marker)) throw new Error(`${label} marker was not found in the source harness.`);
|
|
return source.replace(marker, replacement);
|
|
}
|
|
|
|
function collectBuildManifest() {
|
|
if (!fs.existsSync(buildDirectory) || !fs.statSync(buildDirectory).isDirectory()) {
|
|
throw new Error(`Frozen build directory is missing or is not a directory: ${buildDirectory}`);
|
|
}
|
|
const files = [];
|
|
function visit(directory, relativeDirectory = '') {
|
|
for (const entry of fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
|
|
const relativePath = path.posix.join(relativeDirectory, entry.name);
|
|
const absolutePath = path.join(directory, entry.name);
|
|
if (entry.isDirectory()) visit(absolutePath, relativePath);
|
|
else if (entry.isFile()) {
|
|
const bytes = fs.readFileSync(absolutePath);
|
|
files.push({ path: relativePath, bytes: bytes.length, sha256: sha256(bytes) });
|
|
}
|
|
}
|
|
}
|
|
visit(buildDirectory);
|
|
const canonicalManifest = files.map((file) => `${file.path}\t${file.bytes}\t${file.sha256}\n`).join('');
|
|
const bundleModuleReport = files.find((file) => file.path === 'bundle-module-report.json');
|
|
return {
|
|
capturedAt: new Date().toISOString(),
|
|
directory: buildDirectory,
|
|
fileCount: files.length,
|
|
aggregateSha256: sha256(canonicalManifest),
|
|
bundleModuleReportSha256: bundleModuleReport?.sha256 ?? null,
|
|
files,
|
|
};
|
|
}
|
|
|
|
function collectContentManifestSnapshot() {
|
|
const bytes = fs.readFileSync(contentManifestPath);
|
|
const manifest = JSON.parse(bytes.toString('utf8'));
|
|
return {
|
|
capturedAt: new Date().toISOString(),
|
|
directory: contentSourceDirectory,
|
|
manifestPath: contentManifestPath,
|
|
manifestBytes: bytes.length,
|
|
manifestSha256: sha256(bytes),
|
|
manifestVersion: manifest.version ?? null,
|
|
schemaVersion: manifest.schemaVersion ?? null,
|
|
packIds: Array.isArray(manifest.packs) ? manifest.packs.map((pack) => pack.id).sort() : [],
|
|
fileCount: manifest.files && typeof manifest.files === 'object' ? Object.keys(manifest.files).length : null,
|
|
};
|
|
}
|
|
|
|
function collectLoadedContentObjectEvidence(responses) {
|
|
const objectResponses = responses.filter((response) => response?.pathname?.startsWith('/content/objects/'));
|
|
const responseCountsByPath = objectResponses.reduce((counts, response) => {
|
|
counts.set(response.pathname, (counts.get(response.pathname) ?? 0) + 1);
|
|
return counts;
|
|
}, new Map());
|
|
const uniqueObjects = [...new Map(objectResponses.map((response) => [response.pathname, {
|
|
...response,
|
|
responseCount: responseCountsByPath.get(response.pathname),
|
|
}])).values()];
|
|
return uniqueObjects.map((response) => {
|
|
const relativeObjectPath = decodeURIComponent(response.pathname.slice('/content/'.length));
|
|
const absoluteObjectPath = path.resolve(contentSourceDirectory, relativeObjectPath);
|
|
const relativeCheck = path.relative(contentSourceDirectory, absoluteObjectPath);
|
|
if (relativeCheck.startsWith('..') || path.isAbsolute(relativeCheck)) {
|
|
return { ...response, localObjectPath: null, localBytes: null, localSha256: null,
|
|
objectIntegrity: 'unsafe-path-refused' };
|
|
}
|
|
if (!fs.existsSync(absoluteObjectPath) || !fs.statSync(absoluteObjectPath).isFile()) {
|
|
return { ...response, localObjectPath: path.relative(projectRoot, absoluteObjectPath),
|
|
localBytes: null, localSha256: null, objectIntegrity: 'not-found-on-content-source' };
|
|
}
|
|
const bytes = fs.readFileSync(absoluteObjectPath);
|
|
const actualSha256 = sha256(bytes);
|
|
const urlObjectSha256 = /^([a-f0-9]{64})(?:\.|$)/i.exec(path.basename(absoluteObjectPath))?.[1]?.toLowerCase() ?? null;
|
|
return {
|
|
...response,
|
|
localObjectPath: path.relative(projectRoot, absoluteObjectPath),
|
|
localBytes: bytes.length,
|
|
localSha256: actualSha256,
|
|
urlObjectSha256,
|
|
objectIntegrity: response.status === 200 && urlObjectSha256
|
|
? actualSha256 === urlObjectSha256 ? 'served-file-matches-hash-address' : 'served-file-hash-mismatch'
|
|
: response.status === 200 ? 'served-without-hash-address' : 'http-not-successful',
|
|
};
|
|
});
|
|
}
|
|
|
|
function createInstrumentedHarness() {
|
|
if (FULL_STOCKADE_DUNGEON_ID !== 'stormwind-stockade'
|
|
|| FULL_STOCKADE_DUNGEON_TITLE !== 'Stormwind Stockade') {
|
|
throw new Error(`Full Stockade fixture changed unexpectedly: ${FULL_STOCKADE_DUNGEON_ID} / ${FULL_STOCKADE_DUNGEON_TITLE}`);
|
|
}
|
|
|
|
const mobMarker = ' schoolLockedUntil: mob.schoolLockedUntil ?? {},';
|
|
const outputMarker = "const artifactRoot = path.resolve('playtest-artifacts/campaign-boss-pass');";
|
|
const runtimeRelativeOutput = path.relative(projectRoot, childOutputDirectory).replace(/\\/g, '/');
|
|
|
|
let transformed = sourceHarness;
|
|
transformed = replaceExactlyOnce(transformed, outputMarker,
|
|
`const artifactRoot = path.resolve(${JSON.stringify(runtimeRelativeOutput)});`, 'Campaign output directory');
|
|
transformed = replaceExactlyOnce(transformed, mobMarker, ` attacks: (mob.attacks ?? []).map((attack) => ({
|
|
id: attack.id, name: attack.name, spellId: attack.spellId ?? null,
|
|
school: attack.school ?? null, castTimeMs: attack.castTimeMs ?? 0,
|
|
cooldownMs: attack.cooldownMs ?? 0, interruptible: attack.interruptible !== false,
|
|
})),
|
|
auras: mob.auras ?? [],
|
|
combatAuraTelemetry: (combatState.auras ?? []).filter((aura) => aura.targetId === mob.id).map((aura) => ({
|
|
instanceId: aura.instanceId ?? null,
|
|
definitionId: aura.definition?.id ?? null,
|
|
definitionName: aura.definition?.name ?? null,
|
|
sourceId: aura.sourceId ?? null,
|
|
targetId: aura.targetId ?? null,
|
|
appliedAt: aura.appliedAt ?? null,
|
|
expiresAt: aura.expiresAt ?? null,
|
|
stacks: aura.stacks ?? null,
|
|
definition: aura.definition ?? null,
|
|
})),
|
|
schoolLockedUntil: mob.schoolLockedUntil ?? {},`, 'Mob telemetry projection');
|
|
|
|
transformed = replaceExactlyOnce(transformed,
|
|
" combatAuras: (combatState.auras ?? []).filter((aura) => aura.definition?.id === 'rom-priest-vow-of-silence')\n .map((aura) => ({ instanceId: aura.instanceId, definitionId: aura.definition.id,\n sourceId: aura.sourceId, targetId: aura.targetId, appliedAt: aura.appliedAt,\n expiresAt: aura.expiresAt })),",
|
|
" combatAuras: (combatState.auras ?? []).filter((aura) => aura.definition?.id === 'rom-priest-vow-of-silence')\n .map((aura) => ({ instanceId: aura.instanceId, definitionId: aura.definition.id,\n sourceId: aura.sourceId, targetId: aura.targetId, appliedAt: aura.appliedAt,\n expiresAt: aura.expiresAt })),\n stanceBlockingAuraTelemetry: (combatState.auras ?? []).filter((aura) => /^enemy-source-spell-(?:7164|7165|3419)$/.test(aura.definition?.id ?? '')).map((aura) => ({\n instanceId: aura.instanceId ?? null, definitionId: aura.definition?.id ?? null,\n definitionName: aura.definition?.name ?? null, sourceId: aura.sourceId ?? null,\n targetId: aura.targetId ?? null, appliedAt: aura.appliedAt ?? null,\n expiresAt: aura.expiresAt ?? null, stacks: aura.stacks ?? null,\n })),",
|
|
'stance and Improved Blocking aura telemetry');
|
|
|
|
transformed = replaceExactlyOnce(transformed,
|
|
" partySelection: {\n selectedMemberId: partyState.selectedMemberId ?? null,\n selfSelected: Boolean(partyState.selfSelected),\n },",
|
|
" partySelection: {\n selectedMemberId: partyState.selectedMemberId ?? null,\n selfSelected: Boolean(partyState.selfSelected),\n },\n partyCommand: partyState.command ?? null,",
|
|
'read-only party command sampling');
|
|
|
|
transformed = replaceExactlyOnce(transformed,
|
|
" classId: combatState.classId,\n secondaryClassId: combatState.secondaryClassId,\n level: combatState.level,",
|
|
" classId: combatState.classId,\n secondaryClassId: combatState.secondaryClassId,\n specializationId: combatState.specializationId ?? null,\n level: combatState.level,",
|
|
'player specialization telemetry');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
" activeCast: combatState.activeCast?.abilityId ?? null,",
|
|
" activeCast: combatState.activeCast?.abilityId ?? null,\n lastCombatResult: combatState.lastCombatResult ? { ...combatState.lastCombatResult } : null,",
|
|
'read-only last combat result telemetry');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
" classId: member.classId,\n secondaryClassId: member.secondaryClassId,\n role: member.role,",
|
|
" classId: member.classId,\n secondaryClassId: member.secondaryClassId,\n specializationId: member.specializationId ?? null,\n role: member.role,",
|
|
'party specialization telemetry');
|
|
|
|
const distPathReplacements = [
|
|
["fs.readFileSync('dist/bundle-module-report.json', 'utf8')",
|
|
"fs.readFileSync(path.join(process.env.HEALER_MAN_STOCKADE_DIST, 'bundle-module-report.json'), 'utf8')",
|
|
'bundle module report path'],
|
|
["path.join('dist/assets', dungeonRunStoreAssetFile)",
|
|
"path.join(process.env.HEALER_MAN_STOCKADE_DIST, 'assets', dungeonRunStoreAssetFile)",
|
|
'dungeon run module verification path'],
|
|
["fs.readdirSync('dist/assets')",
|
|
"fs.readdirSync(path.join(process.env.HEALER_MAN_STOCKADE_DIST, 'assets'))",
|
|
'module asset enumeration path'],
|
|
["const runtime = createGameServer({ dataDir: dataDirectory, enableShelvedModes: false });",
|
|
"const runtime = createGameServer({ dataDir: dataDirectory, staticDir: process.env.HEALER_MAN_STOCKADE_DIST, contentDir: path.resolve('content'), enableShelvedModes: false });\n if (path.resolve(runtime.staticDir) !== path.resolve(process.env.HEALER_MAN_STOCKADE_DIST)) {\n throw new Error(`Playtest server resolved an unexpected static directory: ${runtime.staticDir}`);\n }\n if (path.resolve(runtime.contentDir) !== path.resolve('content')) {\n throw new Error(`Playtest server resolved an unexpected read-only content source: ${runtime.contentDir}`);\n }",
|
|
'static server document root'],
|
|
[" const pageErrors = [];\n const consoleErrors = [];",
|
|
" const pageErrors = [];\n const consoleErrors = [];\n const contentSourceResponses = [];",
|
|
'content source response telemetry'],
|
|
[" page.on('pageerror', (error) => pageErrors.push(error.message));",
|
|
" page.on('pageerror', (error) => pageErrors.push(error.message));\n page.on('response', (response) => {\n try {\n const url = new URL(response.url());\n if (url.pathname !== '/content/manifest.json' && !url.pathname.startsWith('/content/objects/')) return;\n const headers = response.headers();\n contentSourceResponses.push({\n observedAt: new Date().toISOString(),\n method: response.request().method(),\n url: response.url(),\n pathname: url.pathname,\n status: response.status(),\n contentType: headers['content-type'] ?? null,\n contentLength: headers['content-length'] ?? null,\n contentEncoding: headers['content-encoding'] ?? null,\n cacheControl: headers['cache-control'] ?? null,\n });\n } catch (error) {\n contentSourceResponses.push({ observedAt: new Date().toISOString(), instrumentationError: String(error) });\n }\n });",
|
|
'content source response listener'],
|
|
["Expected built game assets were not found in dist/assets: ${moduleFiles.join(', ')}",
|
|
"Expected built game assets were not found in the frozen Stockade distribution: ${moduleFiles.join(', ')}",
|
|
'asset failure message'],
|
|
];
|
|
for (const [marker, replacement, label] of distPathReplacements) {
|
|
transformed = replaceExactlyOnce(transformed, marker, replacement, label);
|
|
}
|
|
transformed = replaceExactlyOnce(transformed,
|
|
' const routeResult = await runRouteSegment(page, route, entry, profile);',
|
|
' const routeResult = await runRouteSegment(page, route, entry, profile);\n routeResult.contentSourceResponses = contentSourceResponses.slice();',
|
|
'route content source evidence');
|
|
|
|
transformed = replaceExactlyOnce(transformed,
|
|
" await page.locator('.creator-category-tabs button').filter({ hasText: 'RoM' }).click();\n await page.locator('.class-option').filter({ hasText: /^Priest/ }).click();",
|
|
" await page.locator('.creator-category-tabs button').filter({ hasText: 'WoW' }).click();\n await page.locator('.class-option').filter({ hasText: /^Priest/ }).click();\n await page.locator('.creator-specializations button').filter({ hasText: 'Discipline' }).click();",
|
|
'normal WoW Discipline Priest character creation');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
" if (!character || character.classId !== 'rom-priest') throw new Error('UI-created RoM Priest profile is missing.');\n shell.setState({ activeCharacter: character });\n shell.getState().saveActiveProgression(30, 0, character.talentRanks);\n shell.setState({ activeCharacter: null });\n if (!shell.getState().chooseRomSecondaryClass('rom-knight')) throw new Error('Priest/Knight pairing was not accepted.');\n const updated = shell.getState().characters.find((entry) => entry.id === character.id);\n return { id: updated.id, name: updated.name, classId: updated.classId,\n secondaryClassId: updated.secondaryClassId, level: updated.level, categoryId: updated.categoryId };",
|
|
" if (!character || character.classId !== 'priest' || character.specializationId !== 'priest:discipline') {\n throw new Error('UI-created WoW Discipline Priest profile is missing.');\n }\n shell.setState({ activeCharacter: character });\n shell.getState().saveActiveProgression(30, 0, character.talentRanks);\n shell.setState({ activeCharacter: null });\n const updated = shell.getState().characters.find((entry) => entry.id === character.id);\n return { id: updated.id, name: updated.name, classId: updated.classId, specializationId: updated.specializationId,\n secondaryClassId: updated.secondaryClassId, level: updated.level, categoryId: updated.categoryId };",
|
|
'profile creation and level setup');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
" assert.equal(profile.classId, 'rom-priest');\n assert.equal(profile.secondaryClassId, 'rom-knight');",
|
|
" assert.equal(profile.classId, 'priest');\n assert.equal(profile.specializationId, 'priest:discipline');\n assert.equal(profile.level, 30);",
|
|
'Discipline profile assertions');
|
|
transformed = transformed.replaceAll('roster-priest-knight-level-30.png', 'roster-discipline-priest-level-30.png')
|
|
.replaceAll('roster-compact-priest-knight-level-30.png', 'roster-compact-discipline-priest-level-30.png');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
" assert.equal(state.player.classId, 'rom-priest');\n assert.equal(state.player.secondaryClassId, 'rom-knight');\n assert(state.player.level >= minimumLevel,\n `${route.title} entry level remains at least the UI-created profile's level ${minimumLevel}`);\n assert.equal(state.party.length, 4, 'the UI-created Priest has four NPC companions');\n assert(state.party.every((member) => member.classId.startsWith('rom-') && member.statRuleset === 'rom'),\n 'all four companions use native RoM identities and rules');",
|
|
" assert.equal(state.player.classId, 'priest');\n assert.equal(state.player.specializationId, 'priest:discipline');\n assert(state.player.level >= minimumLevel,\n `${route.title} entry level remains at least the UI-created profile's level ${minimumLevel}`);\n assert.equal(state.party.length, 4, 'the UI-created Discipline Priest has four NPC companions');\n const readySpecializationIds = new Set(['warrior:protection', 'priest:discipline',\n 'hunter:marksmanship', 'mage:fire', 'rogue:assassination']);\n assert(state.party.every((member) => readySpecializationIds.has(member.specializationId)),\n `all four companions use Ready WoW specializations: ${JSON.stringify(state.party.map((member) => member.specializationId))}`);",
|
|
'Ready WoW companion assertions');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
' activeCast: mob.activeCast, position: mob.position })) });',
|
|
' activeCast: mob.activeCast, attacks: mob.attacks ?? [], auras: mob.auras ?? [],\n combatAuraTelemetry: mob.combatAuraTelemetry ?? [], abilityCastCounts: mob.abilityCastCounts ?? {},\n statuses: mob.statuses ?? [], position: mob.position })) });',
|
|
'compact route sample enemy mechanics telemetry');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
" activeCast: mob.activeCast, attacks: mob.attacks ?? [], auras: mob.auras ?? [],\n combatAuraTelemetry: mob.combatAuraTelemetry ?? [], abilityCastCounts: mob.abilityCastCounts ?? {},\n statuses: mob.statuses ?? [], position: mob.position })) });",
|
|
" activeCast: mob.activeCast, attacks: mob.attacks ?? [], auras: mob.auras ?? [],\n combatAuraTelemetry: mob.combatAuraTelemetry ?? [], abilityCastCounts: mob.abilityCastCounts ?? {},\n statuses: mob.statuses ?? [], position: mob.position })),\n stanceBlockingAuraTelemetry: current.stanceBlockingAuraTelemetry ?? [] });",
|
|
'compact route sample stance and blocking telemetry');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
' movement: [], targeting: [], actions: [], samples: [], observedCombatEvents: [],',
|
|
' movement: [], targeting: [], actions: [], samples: [], observedCombatEvents: [],\n observedStanceBlockingAuraObservations: [], observedBlockResultObservations: [],',
|
|
'stance and block result observations');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
' const seenEventKeys = initialEventKeys;\n const observedDeadMobs = new Map();',
|
|
' const seenEventKeys = initialEventKeys;\n const observedStanceBlockingAurasById = new Map();\n const seenBlockResultKeys = new Set();\n const observedDeadMobs = new Map();',
|
|
'read-only observation deduplication state');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
' const collect = (snapshot) => {',
|
|
` let lastProgressSnapshotAt = 0;
|
|
let progressSnapshotCount = 0;
|
|
const recordSnapshot = (snapshot) => {
|
|
if (lastProgressSnapshotAt && snapshot.now - lastProgressSnapshotAt < 30_000) return;
|
|
lastProgressSnapshotAt = snapshot.now;
|
|
progressSnapshotCount += 1;
|
|
const checkpointIndex = result.activeNavigationCheckpointIndex ?? null;
|
|
const checkpoint = Number.isInteger(checkpointIndex)
|
|
? result.navigationGuidance.checkpoints[checkpointIndex] ?? null : null;
|
|
const killedBossIds = snapshot.dungeonRun?.killedBossIds ?? [];
|
|
const killedBossIdSet = new Set(killedBossIds);
|
|
const objectiveCount = result.objectives.length;
|
|
const clearedObjectiveIds = result.objectives.filter((objective) => killedBossIdSet.has(objective.id))
|
|
.map((objective) => objective.id);
|
|
const mobs = snapshot.mobs.map((mob) => ({ id: mob.id, name: mob.name,
|
|
health: mob.health, maxHealth: mob.maxHealth, dead: mob.dead, engaged: mob.engaged,
|
|
boss: mob.boss ?? false, activeCast: mob.activeCast, position: mob.position }));
|
|
const progress = {
|
|
snapshotNumber: progressSnapshotCount,
|
|
updatedAt: new Date(snapshot.now).toISOString(),
|
|
elapsedMs: snapshot.now - result.segmentStartedAt,
|
|
checkpoint: checkpoint ? { index: checkpointIndex, total: result.navigationGuidance.checkpoints.length,
|
|
routePercent: Math.floor((checkpointIndex + 1) / result.navigationGuidance.checkpoints.length * 100),
|
|
objectiveId: checkpoint.objectiveId ?? null, name: checkpoint.name ?? null,
|
|
position: checkpoint.position ?? null,
|
|
distance3d: distance3(snapshot.player.position, checkpoint.position) } : null,
|
|
position: snapshot.player.position,
|
|
player: { classId: snapshot.player.classId, specializationId: snapshot.player.specializationId,
|
|
health: snapshot.player.health, maxHealth: snapshot.player.maxHealth,
|
|
mana: snapshot.player.resource, maxMana: snapshot.player.maxResource,
|
|
resourceType: snapshot.player.resourceType, resourceName: snapshot.player.resourceName,
|
|
activeCast: snapshot.player.activeCast, selectedTargetId: snapshot.player.selectedTargetId,
|
|
controlMechanic: snapshot.player.controlMechanic,
|
|
actionBlockedByControl: snapshot.player.actionBlockedByControl },
|
|
party: snapshot.party.map((member) => ({ id: member.id, name: member.name,
|
|
specializationId: member.specializationId ?? null, role: member.role,
|
|
health: member.health, maxHealth: member.maxHealth, status: member.status,
|
|
activeCast: member.activeCast, position: member.position })),
|
|
deaths: { player: result.playerDeathTransitions.length, party: partyCasualties.length,
|
|
partyMembers: partyCasualties.map((casualty) => ({ id: casualty.id, name: casualty.name,
|
|
observedAt: casualty.observedAt, recoveredAt: casualty.recoveredAt })) },
|
|
partyCommand: { current: snapshot.partyCommand ?? null,
|
|
recordedInputs: [result.partyCommand, result.partyCommandAfterOpeningTarget,
|
|
...(result.partyCommands ?? [])].filter(Boolean) },
|
|
mobs: { liveCount: mobs.filter((mob) => !mob.dead && mob.health > 0).length,
|
|
deadCount: mobs.filter((mob) => mob.dead || mob.health <= 0).length,
|
|
engagedCount: mobs.filter((mob) => mob.engaged && !mob.dead && mob.health > 0).length,
|
|
entries: mobs },
|
|
objectives: { count: objectiveCount, clearedCount: clearedObjectiveIds.length,
|
|
clearedIds: clearedObjectiveIds, killedBossIds },
|
|
recentEvents: (snapshot.events ?? []).slice(-20),
|
|
recentMovement: result.movement.slice(-4).map((step) => ({ at: step.at,
|
|
from: step.from, to: step.to, planarDisplacement: step.planarDisplacement,
|
|
requestedDurationMs: step.requestedDurationMs, durationMs: step.durationMs })),
|
|
lastRecovery: result.playerRecoveryActions.at(-1) ?? null,
|
|
};
|
|
const progressPath = process.env.HEALER_MAN_STOCKADE_PROGRESS_PATH
|
|
?? path.join(outputDirectory, 'progress.json');
|
|
fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2));
|
|
};
|
|
const collect = (snapshot) => {`,
|
|
'periodic read-only live progress snapshots');
|
|
transformed = replaceFirstOccurrence(transformed,
|
|
' result.observedCombatEvents.push(event);\n }\n };',
|
|
` result.observedCombatEvents.push(event);\n }\n for (const aura of snapshot.stanceBlockingAuraTelemetry ?? []) {\n const auraKey = [aura.instanceId ?? '', aura.appliedAt ?? '', aura.definitionId ?? '',\n aura.sourceId ?? '', aura.targetId ?? ''].join('|');\n const existing = observedStanceBlockingAurasById.get(auraKey);\n if (existing) existing.lastObservedAt = snapshot.now;\n else {\n const observation = { firstObservedAt: snapshot.now, lastObservedAt: snapshot.now, ...aura };\n observedStanceBlockingAurasById.set(auraKey, observation);\n result.observedStanceBlockingAuraObservations.push(observation);\n }\n }\n const lastCombatResult = snapshot.player.lastCombatResult;\n if (lastCombatResult?.outcome === 'block') {\n const latestDamageEvent = [...snapshot.events].reverse().find((event) => event.kind === 'damage');\n const matchedLatestBlockEvent = latestDamageEvent?.outcome === 'block'\n && Number(latestDamageEvent.rawAmount) === Number(lastCombatResult.rawDamage)\n ? latestDamageEvent : null;\n const resultKey = matchedLatestBlockEvent?.id != null ? 'event:' + matchedLatestBlockEvent.id\n : 'unmatched:' + JSON.stringify(lastCombatResult);\n if (!seenBlockResultKeys.has(resultKey)) {\n seenBlockResultKeys.add(resultKey);\n result.observedBlockResultObservations.push({ observedAt: snapshot.now,\n correlation: matchedLatestBlockEvent ? 'latest-damage-event-outcome-and-raw-amount-match' : 'no-matching-latest-damage-event-sampled',\n event: matchedLatestBlockEvent, combatResult: { ...lastCombatResult } });\n }\n }\n };`,
|
|
'read-only block result collection');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
'\n };\n const deadline = Date.now() + maxCampaignDurationMs;',
|
|
'\n recordSnapshot(snapshot);\n };\n const deadline = Date.now() + maxCampaignDurationMs;',
|
|
'write periodic route observations');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
' const firstTarget = await selectHostileWithTab(page, result, 8);',
|
|
' collect(entryState);\n const firstTarget = await selectHostileWithTab(page, result, 8);',
|
|
'entry aura and combat-state snapshot');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
' const beforePosition = current.player.position;\n const beforeDistance = distance3(beforePosition, checkpoint.position);\n const planarRemaining = distancePlanar(beforePosition, checkpoint.position);\n const speedEstimate = ordinaryMovementSpeedEstimate(result.movement);\n const durationMs = Math.max(45, Math.min(350, Math.floor(planarRemaining * 0.58 / speedEstimate * 1_000)));\n const moved = await walkToward(page, result, checkpoint.position, durationMs);\n if (!moved) {\n routeBlocked = { kind: \'no-directional-input\', checkpointIndex, checkpoint, position: current.player.position };',
|
|
' const beforePosition = current.player.position;\n const beforeDistance = distance3(beforePosition, checkpoint.position);\n const planarRemaining = distancePlanar(beforePosition, checkpoint.position);\n const speedEstimate = ordinaryMovementSpeedEstimate(result.movement);\n const recentResponseScales = result.movement.slice(-8)\n .filter((step) => Number(step.requestedDurationMs) > 0 && Number(step.durationMs) >= Number(step.requestedDurationMs)\n && Number(step.planarDisplacement) >= 0.08)\n .map((step) => Number(step.durationMs) / Number(step.requestedDurationMs)).sort((left, right) => left - right);\n const movementResponseScale = recentResponseScales.length\n ? recentResponseScales[Math.floor(recentResponseScales.length / 2)] : 1;\n const plannedDurationMs = planarRemaining * 0.58 / speedEstimate * 1_000 / movementResponseScale;\n const nearCheckpointLimitMs = planarRemaining < 1.5 ? 55 : 350;\n const durationMs = Math.max(25, Math.min(nearCheckpointLimitMs, 350, Math.floor(plannedDurationMs)));\n const moved = await walkToward(page, result, checkpoint.position, durationMs);\n if (!moved) {\n routeBlocked = { kind: \'no-directional-input\', checkpointIndex, checkpoint, position: current.player.position };',
|
|
'adaptive ordinary movement timing from measured response');
|
|
transformed = replaceExactlyOnce(transformed,
|
|
' buildAssets: moduleFiles, error: error.stack ?? error.message, pageErrors, consoleErrors,',
|
|
' buildAssets: moduleFiles, error: error.stack ?? error.message, pageErrors, consoleErrors,\n contentSourceResponses,',
|
|
'failure content source evidence');
|
|
if (/['"`]dist\/(?:assets|bundle-module-report)/.test(transformed)) {
|
|
throw new Error('A hard-coded campaign harness distribution path survived frozen-build instrumentation.');
|
|
}
|
|
return transformed;
|
|
}
|
|
|
|
function summarizeEnemyEvidence(route) {
|
|
const mobSamples = [];
|
|
const rawCombatEvents = route.observedCombatEvents ?? [];
|
|
function visit(value, sourcePath = '$') {
|
|
if (!value || typeof value !== 'object') return;
|
|
if (Array.isArray(value.mobs)) {
|
|
const at = value.at ?? value.now ?? value.observedAt ?? null;
|
|
for (const mob of value.mobs) {
|
|
if (!mob || typeof mob !== 'object') continue;
|
|
mobSamples.push({
|
|
sampledAt: at,
|
|
sourcePath,
|
|
id: mob.id ?? null,
|
|
name: mob.name ?? null,
|
|
serverEntry: mob.serverEntry ?? null,
|
|
health: mob.health ?? null,
|
|
maxHealth: mob.maxHealth ?? null,
|
|
dead: mob.dead ?? null,
|
|
engaged: mob.engaged ?? null,
|
|
activeCast: mob.activeCast ?? null,
|
|
abilityCastCounts: mob.abilityCastCounts ?? null,
|
|
attacks: mob.attacks ?? [],
|
|
auras: mob.auras ?? [],
|
|
combatAuraTelemetry: mob.combatAuraTelemetry ?? [],
|
|
statuses: mob.statuses ?? [],
|
|
});
|
|
}
|
|
}
|
|
if (Array.isArray(value)) value.forEach((child, index) => visit(child, `${sourcePath}[${index}]`));
|
|
else for (const [key, child] of Object.entries(value)) visit(child, `${sourcePath}.${key}`);
|
|
}
|
|
visit(route);
|
|
const enemyActorIds = new Set(mobSamples.map((sample) => sample.id).filter(Boolean));
|
|
const enemyNameById = new Map(mobSamples.filter((sample) => sample.id && sample.name)
|
|
.map((sample) => [sample.id, sample.name]));
|
|
const combatAuraSamples = mobSamples.filter((sample) => sample.combatAuraTelemetry.length > 0)
|
|
.map((sample) => ({ sampledAt: sample.sampledAt, sourcePath: sample.sourcePath,
|
|
enemyId: sample.id, enemyName: sample.name, auras: sample.combatAuraTelemetry }));
|
|
const enemyBuffAuraApplications = [...new Map(combatAuraSamples.flatMap((sample) => sample.auras
|
|
.filter((aura) => enemyActorIds.has(aura.sourceId) && enemyActorIds.has(aura.targetId)
|
|
&& aura.definition?.disposition === 'buff')
|
|
.map((aura) => [aura.instanceId, {
|
|
instanceId: aura.instanceId,
|
|
definitionId: aura.definitionId,
|
|
definitionName: aura.definitionName,
|
|
sourceId: aura.sourceId,
|
|
sourceName: enemyNameById.get(aura.sourceId) ?? null,
|
|
targetId: aura.targetId,
|
|
targetName: enemyNameById.get(aura.targetId) ?? null,
|
|
appliedAt: aura.appliedAt,
|
|
expiresAt: aura.expiresAt,
|
|
stacks: aura.stacks,
|
|
}]))).filter(([instanceId]) => Boolean(instanceId))].map(([, aura]) => aura);
|
|
|
|
const enemyDamageEvents = rawCombatEvents.filter((event) => enemyActorIds.has(event.sourceActorId)
|
|
&& event.kind === 'damage').map((event) => ({ ...event,
|
|
sourceEnemyName: enemyNameById.get(event.sourceActorId) ?? null }));
|
|
const rendDamageEvents = enemyDamageEvents.filter((event) => /(?:^|\D)(?:6547|16509)(?:\D|$)/
|
|
.test(String(event.abilityId ?? event.spellId ?? event.attackId ?? ''))
|
|
|| /rend/i.test(String(event.abilityName ?? event.name ?? '')));
|
|
const chainLightningCastSamples = mobSamples.filter((sample) => sample.name === FULL_STOCKADE_BOSS
|
|
&& sample.activeCast && (Number(sample.activeCast.spellId) === 421
|
|
|| /(?:^|\D)421(?:\D|$)/.test(String(sample.activeCast.attackId ?? ''))
|
|
|| /chain\s*lightning/i.test(String(sample.activeCast.name ?? ''))));
|
|
const rendCastSamples = mobSamples.filter((sample) => sample.activeCast
|
|
&& (Number(sample.activeCast.spellId) === 6547 || Number(sample.activeCast.spellId) === 16509
|
|
|| /rend/i.test(String(sample.activeCast.name ?? ''))
|
|
|| /(?:^|\D)(?:6547|16509)(?:\D|$)/.test(String(sample.activeCast.attackId ?? ''))));
|
|
const demoralizingShoutCastWindows = [...new Map(mobSamples.filter((sample) => sample.activeCast
|
|
&& (Number(sample.activeCast.spellId) === 13730 || Number(sample.activeCast.spellId) === 16244
|
|
|| /demoralizing\s*shout/i.test(String(sample.activeCast.name ?? '')))
|
|
).map((sample) => [`${sample.id}|${sample.activeCast.attackId}|${sample.activeCast.startedAt}`, {
|
|
enemyId: sample.id,
|
|
enemyName: sample.name,
|
|
attackId: sample.activeCast.attackId ?? null,
|
|
spellId: sample.activeCast.spellId ?? null,
|
|
startedAt: sample.activeCast.startedAt ?? null,
|
|
completesAt: sample.activeCast.completesAt ?? null,
|
|
interruptible: sample.activeCast.interruptible ?? null,
|
|
}])).values()];
|
|
const rendAttacks = mobSamples.flatMap((sample) => (sample.attacks ?? []).filter((attack) => (
|
|
Number(attack.spellId) === 6547 || Number(attack.spellId) === 16509
|
|
|| /rend/i.test(String(attack.name ?? ''))
|
|
|| /(?:^|\D)(?:6547|16509)(?:\D|$)/.test(String(attack.id ?? ''))
|
|
)).map((attack) => ({ enemyId: sample.id, enemyName: sample.name, ...attack })));
|
|
const enemyAuraObservations = mobSamples.filter((sample) => Array.isArray(sample.auras) && sample.auras.length > 0)
|
|
.map((sample) => ({ sampledAt: sample.sampledAt, sourcePath: sample.sourcePath,
|
|
enemyId: sample.id, enemyName: sample.name, auras: sample.auras }));
|
|
return {
|
|
definitions: {
|
|
rawCombatEvents: 'Unmodified combatStore event objects collected by the campaign harness; timestamps and amount fields retain source values.',
|
|
enemyDamageEvents: 'Raw damage events whose source actor id appeared in observed mob snapshots.',
|
|
rendDamageEvents: 'Raw enemy damage events whose source ability id/name matches Rend 6547 or 16509.',
|
|
mobSamples: 'Read-only snapshots extended with each mob attack definition and mob aura state.',
|
|
combatAuraSamples: 'Read-only combatStore auras filtered to the sampled mob id, retaining definition, owner, source, apply, expiry, and stack fields.',
|
|
enemyBuffAuraApplications: 'Unique enemy-source buff auras whose source and target actor ids both appeared in sampled mobs; deduplicated by aura instance id.',
|
|
chainLightningMatch: 'Hamhock active cast matches spellId 421, attackId containing 421, or source cast name Chain Lightning.',
|
|
rendCastMatch: 'Mob active cast matches spellId 6547/16509, attackId containing either ID, or source cast name Rend.',
|
|
demoralizingShoutCastWindows: 'Unique active cast windows for enemy spell 13730/16244 or a Demoralizing Shout-named cast, keyed by enemy id, attack id, and startedAt.',
|
|
rendMatch: 'Mob attack definition matches spellId 6547/16509, attack name Rend, or attack id containing one of those IDs.',
|
|
},
|
|
counts: {
|
|
mobSamples: mobSamples.length,
|
|
rawCombatEvents: rawCombatEvents.length,
|
|
enemyDamageEvents: enemyDamageEvents.length,
|
|
rendDamageEvents: rendDamageEvents.length,
|
|
chainLightningCastSamples: chainLightningCastSamples.length,
|
|
rendCastSamples: rendCastSamples.length,
|
|
demoralizingShoutCastWindows: demoralizingShoutCastWindows.length,
|
|
rendAttackDefinitions: rendAttacks.length,
|
|
enemyAuraObservations: enemyAuraObservations.length,
|
|
combatAuraSamples: combatAuraSamples.length,
|
|
enemyBuffAuraApplications: enemyBuffAuraApplications.length,
|
|
},
|
|
enemyDamageEvents,
|
|
rendDamageEvents,
|
|
chainLightningCastSamples,
|
|
rendCastSamples,
|
|
demoralizingShoutCastWindows,
|
|
rendAttackDefinitions: [...new Map(rendAttacks.map((attack) => [
|
|
`${attack.enemyId}|${attack.id}|${attack.spellId}`, attack,
|
|
])).values()],
|
|
enemyAuraObservations,
|
|
combatAuraSamples,
|
|
enemyBuffAuraApplications,
|
|
mobSamples,
|
|
rawCombatEvents,
|
|
};
|
|
}
|
|
|
|
function summarizeStanceBlockingEvidence(route) {
|
|
const partyActors = new Map();
|
|
const hostileActors = new Map();
|
|
const partyName = route.profile?.name ?? route.playerAtEntry?.name ?? 'Player';
|
|
partyActors.set('__player__', { id: '__player__', name: partyName, role: 'healer', actorKind: 'player' });
|
|
|
|
function addPartyActor(actor) {
|
|
if (!actor?.id) return;
|
|
partyActors.set(actor.id, { id: actor.id, name: actor.name ?? null,
|
|
role: actor.role ?? null, classId: actor.classId ?? null,
|
|
specializationId: actor.specializationId ?? null, actorKind: 'companion' });
|
|
}
|
|
function addHostileActor(actor) {
|
|
if (!actor?.id) return;
|
|
hostileActors.set(actor.id, { id: actor.id, name: actor.name ?? null,
|
|
serverEntry: actor.serverEntry ?? null, actorKind: 'hostile-mob' });
|
|
}
|
|
function visitActorCollections(value) {
|
|
if (!value || typeof value !== 'object') return;
|
|
if (Array.isArray(value)) {
|
|
value.forEach(visitActorCollections);
|
|
return;
|
|
}
|
|
if (Array.isArray(value.party)) value.party.forEach(addPartyActor);
|
|
if (Array.isArray(value.mobs)) value.mobs.forEach(addHostileActor);
|
|
for (const child of Object.values(value)) visitActorCollections(child);
|
|
}
|
|
route.partyAtEntry?.forEach(addPartyActor);
|
|
visitActorCollections(route.samples ?? []);
|
|
visitActorCollections(route.packEncounters ?? []);
|
|
visitActorCollections(route.bossEncounters ?? []);
|
|
|
|
const actorName = (id) => partyActors.get(id)?.name ?? hostileActors.get(id)?.name ?? null;
|
|
const actorSide = (id) => partyActors.has(id) ? 'party' : hostileActors.has(id) ? 'hostile' : 'unresolved';
|
|
const sampledAuraObservations = (route.samples ?? []).flatMap((sample) =>
|
|
(sample.stanceBlockingAuraTelemetry ?? []).map((aura) => ({
|
|
...aura, firstObservedAt: sample.at, lastObservedAt: sample.at,
|
|
})));
|
|
const auraApplicationsById = new Map();
|
|
for (const aura of [...(route.observedStanceBlockingAuraObservations ?? []), ...sampledAuraObservations]) {
|
|
const spellIdMatch = /(?:^|-)(7164|7165|3419)$/.exec(String(aura.definitionId ?? ''));
|
|
const spellId = spellIdMatch ? Number(spellIdMatch[1]) : null;
|
|
if (![7164, 7165, 3419].includes(spellId)) continue;
|
|
const applicationId = [aura.instanceId ?? '', aura.appliedAt ?? '', aura.definitionId ?? '',
|
|
aura.sourceId ?? '', aura.targetId ?? ''].join('|');
|
|
const current = auraApplicationsById.get(applicationId);
|
|
if (!current || Number(aura.lastObservedAt ?? 0) > Number(current.lastObservedAt ?? 0)) {
|
|
auraApplicationsById.set(applicationId, { ...aura, spellId });
|
|
}
|
|
}
|
|
const auraApplications = [...auraApplicationsById.values()].map((aura) => ({
|
|
instanceId: aura.instanceId ?? null,
|
|
spellId: aura.spellId,
|
|
definitionId: aura.definitionId ?? null,
|
|
name: aura.definitionName ?? (aura.spellId === 7164 ? 'Defensive Stance'
|
|
: aura.spellId === 7165 ? 'Battle Stance' : 'Improved Blocking'),
|
|
sourceActorId: aura.sourceId ?? null,
|
|
sourceActorName: actorName(aura.sourceId),
|
|
sourceActorSide: actorSide(aura.sourceId),
|
|
targetActorId: aura.targetId ?? null,
|
|
targetActorName: actorName(aura.targetId),
|
|
targetActorSide: actorSide(aura.targetId),
|
|
appliedAt: aura.appliedAt ?? null,
|
|
expiresAt: aura.expiresAt ?? null,
|
|
stacks: aura.stacks ?? null,
|
|
firstObservedAt: aura.firstObservedAt ?? null,
|
|
lastObservedAt: aura.lastObservedAt ?? null,
|
|
telemetry: 'active combatStore aura state from collector observations and route samples, deduplicated by instanceId + appliedAt',
|
|
}));
|
|
const stanceAuraApplications = auraApplications.filter((aura) => aura.spellId === 7164 || aura.spellId === 7165);
|
|
const improvedBlockingAuraApplications = auraApplications.filter((aura) => aura.spellId === 3419);
|
|
|
|
const blockResultByEventId = new Map();
|
|
const unmatchedBlockResultObservations = [];
|
|
for (const observation of route.observedBlockResultObservations ?? []) {
|
|
const eventId = observation.event?.id;
|
|
if (eventId != null) blockResultByEventId.set(eventId, observation);
|
|
else unmatchedBlockResultObservations.push(observation);
|
|
}
|
|
const rawBlockEvents = (route.observedCombatEvents ?? []).filter((event) => event.kind === 'damage'
|
|
&& event.outcome === 'block');
|
|
const blockEvents = rawBlockEvents.map((event) => {
|
|
const sourceActorSide = actorSide(event.sourceActorId);
|
|
const targetActorSide = actorSide(event.targetActorId);
|
|
const direction = sourceActorSide === 'hostile' && targetActorSide === 'party'
|
|
? 'hostile-attack-blocked-by-party'
|
|
: sourceActorSide === 'party' && targetActorSide === 'hostile'
|
|
? 'party-attack-blocked-by-hostile' : 'actor-team-unresolved';
|
|
const resultObservation = blockResultByEventId.get(event.id) ?? null;
|
|
return {
|
|
eventId: event.id ?? null,
|
|
occurredAt: event.occurredAt ?? null,
|
|
direction,
|
|
sourceActorId: event.sourceActorId ?? null,
|
|
sourceActorName: actorName(event.sourceActorId),
|
|
sourceActorSide,
|
|
targetActorId: event.targetActorId ?? null,
|
|
targetActorName: actorName(event.targetActorId),
|
|
targetActorSide,
|
|
abilityId: event.abilityId ?? null,
|
|
school: event.school ?? null,
|
|
outcome: event.outcome ?? null,
|
|
rawAmount: event.rawAmount ?? null,
|
|
effectiveAmount: event.effectiveAmount ?? null,
|
|
absorbed: event.absorbed ?? null,
|
|
blockedAmount: resultObservation?.combatResult?.blockedAmount ?? null,
|
|
blockResultCorrelation: resultObservation?.correlation ?? 'event outcome only; no matched lastCombatResult amount sample',
|
|
lastCombatResult: resultObservation?.combatResult ?? null,
|
|
};
|
|
});
|
|
const partyDefenseBlockEvents = blockEvents.filter((event) => event.direction === 'hostile-attack-blocked-by-party');
|
|
const partyAttackBlockedEvents = blockEvents.filter((event) => event.direction === 'party-attack-blocked-by-hostile');
|
|
return {
|
|
definitions: {
|
|
stanceAuraApplications: 'Unique active aura applications for source spells 7164 Defensive Stance and 7165 Battle Stance, keyed by aura instance id; application/source/target timestamps and expiry are preserved.',
|
|
improvedBlockingAuraApplications: 'Unique active aura applications for source spell 3419 Improved Blocking, keyed by aura instance id plus appliedAt and reconstructed from collector observations plus route samples.',
|
|
blockEvents: 'Raw read-only combatStore damage events with outcome=block. Direction is classified from party actor IDs and sampled hostile mob IDs.',
|
|
blockedAmount: 'Copied from sampled lastCombatResult only when its outcome and raw damage amount match the latest damage event in that snapshot; unmatched block outcomes remain recorded with blockedAmount=null.',
|
|
samplingLimit: 'Aura telemetry and lastCombatResult are sampled when the campaign harness reads live state; short intervals may be missed if they begin and expire between reads.',
|
|
},
|
|
counts: {
|
|
stanceAuraApplications: stanceAuraApplications.length,
|
|
defensiveStanceApplications: stanceAuraApplications.filter((aura) => aura.spellId === 7164).length,
|
|
battleStanceApplications: stanceAuraApplications.filter((aura) => aura.spellId === 7165).length,
|
|
improvedBlockingAuraApplications: improvedBlockingAuraApplications.length,
|
|
rawBlockEvents: rawBlockEvents.length,
|
|
partyDefenseBlockEvents: partyDefenseBlockEvents.length,
|
|
partyAttackBlockedEvents: partyAttackBlockedEvents.length,
|
|
actorTeamUnresolvedBlockEvents: blockEvents.filter((event) => event.direction === 'actor-team-unresolved').length,
|
|
matchedBlockedAmountEvents: blockEvents.filter((event) => event.blockedAmount !== null).length,
|
|
unmatchedBlockResultObservations: unmatchedBlockResultObservations.length,
|
|
},
|
|
partyActors: [...partyActors.values()],
|
|
hostileActors: [...hostileActors.values()],
|
|
auraApplications,
|
|
stanceAuraApplications,
|
|
improvedBlockingAuraApplications,
|
|
blockEvents,
|
|
unmatchedBlockResultObservations,
|
|
rawBlockEvents,
|
|
};
|
|
}
|
|
|
|
function writeJson(filePath, value) {
|
|
fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
|
|
}
|
|
|
|
function main() {
|
|
const instrumentedHarness = createInstrumentedHarness();
|
|
fs.writeFileSync(runtimeHarnessPath, instrumentedHarness, 'utf8');
|
|
try {
|
|
const syntax = spawnSync(process.execPath, ['--check', runtimeHarnessPath], {
|
|
cwd: projectRoot,
|
|
encoding: 'utf8',
|
|
windowsHide: true,
|
|
});
|
|
if (syntax.status !== 0) throw new Error(`Instrumented campaign harness syntax check failed: ${syntax.stderr || syntax.error}`);
|
|
|
|
if (prepareOnly) {
|
|
console.log('Prepared scoped Stockade stance/blocking harness; source and transformed syntax are valid; no distribution scan, server, or browser was started.');
|
|
return;
|
|
}
|
|
if (!process.argv.includes('--full-stockade')) {
|
|
throw new Error('This source-specific full-campaign harness requires explicit --full-stockade opt-in.');
|
|
}
|
|
if (!frozenBuildAuthorized) {
|
|
throw new Error('Live mode is locked until the owner authorizes the frozen build. Use --prepare-only for static preparation.');
|
|
}
|
|
if (!requestedBuildDirectory) {
|
|
throw new Error('Live mode requires HEALER_MAN_STOCKADE_DIST to point to the immutable task-specific distribution.');
|
|
}
|
|
if (!expectedBuildSha256 || !/^[a-f0-9]{64}$/i.test(expectedBuildSha256)) {
|
|
throw new Error('Live mode requires --expected-build-sha256=<64 hex chars> or HEALER_MAN_STOCKADE_DIST_SHA256.');
|
|
}
|
|
if (!fs.existsSync(requestedBuildDirectory) || !fs.statSync(requestedBuildDirectory).isDirectory()) {
|
|
throw new Error(`Task-specific frozen distribution is missing: ${requestedBuildDirectory}`);
|
|
}
|
|
const projectDistRealPath = fs.realpathSync(path.join(projectRoot, 'dist'));
|
|
const requestedDistRealPath = fs.realpathSync(requestedBuildDirectory);
|
|
if (requestedDistRealPath === projectDistRealPath) {
|
|
throw new Error('Live mode requires the isolated frozen distribution copy, not the mutable project dist directory.');
|
|
}
|
|
|
|
fs.mkdirSync(outputDirectory, { recursive: true });
|
|
const beforeManifest = collectBuildManifest();
|
|
const contentManifestBefore = collectContentManifestSnapshot();
|
|
writeJson(path.join(outputDirectory, 'build-manifest-before.json'), beforeManifest);
|
|
writeJson(path.join(outputDirectory, 'content-manifest-before.json'), contentManifestBefore);
|
|
const runRecord = {
|
|
status: 'running',
|
|
runId,
|
|
startedAt: new Date().toISOString(),
|
|
dungeon: { id: FULL_STOCKADE_DUNGEON_ID, title: FULL_STOCKADE_DUNGEON_TITLE },
|
|
profilePlan: { creation: 'normal offline WoW character-creation UI', classId: 'priest',
|
|
specializationId: 'priest:discipline', role: 'healer', level: 30,
|
|
companions: 'four NPC companions, each asserted against the five Ready specialization IDs' },
|
|
entryAndPlay: 'normal full Stockade picker and Discipline healer-role entry; campaign harness ordinary WASD, target selection, attack/support healing/party commands; no Boss Testing, teleport, collision bypass, enemy/damage/aura/health/cast seeding, or combat store writes',
|
|
campaignHarness: path.relative(projectRoot, sourceHarnessPath),
|
|
instrumentation: ['active enemy-source aura applications for spells 7164/7165/3419 with owner, target, apply/expiry, and stack fields',
|
|
'raw observed combat events with block outcomes and actor direction',
|
|
'read-only lastCombatResult block amount snapshots correlated to matching damage events',
|
|
'read-only live-state progress.json snapshots at 30-second intervals'],
|
|
requestedMaximumCampaignSeconds: 1800,
|
|
frozenBuildDirectory: requestedDistRealPath,
|
|
expectedBuildSha256: expectedBuildSha256.toLowerCase(),
|
|
readOnlyContentSourceDirectory: contentSourceDirectory,
|
|
contentManifestBeforeSha256: contentManifestBefore.manifestSha256,
|
|
childOutputDirectory: path.relative(projectRoot, childOutputDirectory),
|
|
progressFile: path.relative(projectRoot, path.join(outputDirectory, 'progress.json')),
|
|
progressSnapshotIntervalSeconds: 30,
|
|
buildManifestBeforeSha256: beforeManifest.aggregateSha256,
|
|
loadedBuildAssets: [],
|
|
statusNotes: [],
|
|
};
|
|
writeJson(path.join(outputDirectory, 'run-record.json'), runRecord);
|
|
|
|
if (beforeManifest.aggregateSha256.toLowerCase() !== expectedBuildSha256.toLowerCase()) {
|
|
runRecord.status = 'not-started-frozen-build-fingerprint-mismatch';
|
|
runRecord.executionStatus = 'browser-not-started';
|
|
runRecord.statusNotes.push('Expected aggregate SHA-256 did not match the supplied frozen distribution; no game server or browser was started.');
|
|
writeJson(path.join(outputDirectory, 'run-record.json'), runRecord);
|
|
console.error(`Frozen-build fingerprint mismatch; preserved preflight evidence at ${path.relative(projectRoot, outputDirectory)}`);
|
|
process.exitCode = 1;
|
|
return;
|
|
}
|
|
|
|
const child = spawnSync(process.execPath, [runtimeHarnessPath,
|
|
'--campaign-boss-route', `--route=${FULL_STOCKADE_DUNGEON_ID}`, '--max-campaign-seconds=1800'], {
|
|
cwd: projectRoot,
|
|
env: { ...process.env, HEALER_MAN_STOCKADE_DIST: requestedDistRealPath,
|
|
HEALER_MAN_STOCKADE_PROGRESS_PATH: path.join(outputDirectory, 'progress.json') },
|
|
stdio: 'inherit',
|
|
timeout: 2_100_000,
|
|
windowsHide: true,
|
|
});
|
|
|
|
const afterManifest = collectBuildManifest();
|
|
const contentManifestAfter = collectContentManifestSnapshot();
|
|
writeJson(path.join(outputDirectory, 'build-manifest-after.json'), afterManifest);
|
|
writeJson(path.join(outputDirectory, 'content-manifest-after.json'), contentManifestAfter);
|
|
const candidateDirectories = fs.existsSync(childOutputDirectory)
|
|
? fs.readdirSync(childOutputDirectory, { withFileTypes: true })
|
|
.filter((entry) => entry.isDirectory()).map((entry) => path.join(childOutputDirectory, entry.name)).sort()
|
|
: [];
|
|
const campaignDirectory = candidateDirectories.at(-1) ?? null;
|
|
const routePath = campaignDirectory
|
|
? path.join(campaignDirectory, `${FULL_STOCKADE_DUNGEON_ID}-campaign-boss-route.json`) : null;
|
|
const routeResultPath = campaignDirectory
|
|
? path.join(campaignDirectory, `${FULL_STOCKADE_DUNGEON_ID}-route.json`) : null;
|
|
const resultsPath = campaignDirectory ? path.join(campaignDirectory, 'results.json') : null;
|
|
const route = routePath && fs.existsSync(routePath) ? JSON.parse(fs.readFileSync(routePath, 'utf8')) : null;
|
|
const routeResult = routeResultPath && fs.existsSync(routeResultPath)
|
|
? JSON.parse(fs.readFileSync(routeResultPath, 'utf8')) : null;
|
|
const results = resultsPath && fs.existsSync(resultsPath) ? JSON.parse(fs.readFileSync(resultsPath, 'utf8')) : null;
|
|
const evidence = route ? summarizeStanceBlockingEvidence(route) : null;
|
|
if (evidence) writeJson(path.join(outputDirectory, 'stances-blocking-evidence.json'), evidence);
|
|
const failurePath = campaignDirectory ? path.join(campaignDirectory, 'failure.json') : null;
|
|
const failure = failurePath && fs.existsSync(failurePath)
|
|
? JSON.parse(fs.readFileSync(failurePath, 'utf8')) : null;
|
|
const contentSourceResponses = route?.contentSourceResponses ?? routeResult?.contentSourceResponses
|
|
?? failure?.contentSourceResponses ?? [];
|
|
const loadedContentObjects = collectLoadedContentObjectEvidence(contentSourceResponses);
|
|
const contentSourceEvidence = {
|
|
sourceDirectory: contentSourceDirectory,
|
|
manifestBefore: contentManifestBefore,
|
|
manifestAfter: contentManifestAfter,
|
|
manifestUnchanged: contentManifestBefore.manifestSha256 === contentManifestAfter.manifestSha256,
|
|
responses: contentSourceResponses,
|
|
loadedObjects: loadedContentObjects,
|
|
counts: {
|
|
manifestResponses: contentSourceResponses.filter((response) => response?.pathname === '/content/manifest.json').length,
|
|
successfulManifestResponses: contentSourceResponses.filter((response) => response?.pathname === '/content/manifest.json'
|
|
&& response.status === 200).length,
|
|
objectResponses: contentSourceResponses.filter((response) => response?.pathname?.startsWith('/content/objects/')).length,
|
|
successfulObjectResponses: contentSourceResponses.filter((response) => response?.pathname?.startsWith('/content/objects/')
|
|
&& response.status === 200).length,
|
|
verifiedHashAddressedObjects: loadedContentObjects.filter((object) => object.objectIntegrity === 'served-file-matches-hash-address').length,
|
|
objectIntegrityFailures: loadedContentObjects.filter((object) => object.objectIntegrity === 'served-file-hash-mismatch'
|
|
|| object.objectIntegrity === 'not-found-on-content-source' || object.objectIntegrity === 'unsafe-path-refused').length,
|
|
},
|
|
};
|
|
writeJson(path.join(outputDirectory, 'content-source-evidence.json'), contentSourceEvidence);
|
|
|
|
runRecord.endedAt = new Date().toISOString();
|
|
runRecord.executionStatus = child.error ? 'failed-to-complete' : child.status === 0 ? 'complete' : 'failed';
|
|
runRecord.childExitCode = child.status;
|
|
runRecord.childSignal = child.signal ?? null;
|
|
runRecord.childError = child.error ? { message: child.error.message, code: child.error.code ?? null } : null;
|
|
runRecord.campaignDirectory = campaignDirectory ? path.relative(projectRoot, campaignDirectory) : null;
|
|
runRecord.campaignRoutePath = routePath && fs.existsSync(routePath) ? path.relative(projectRoot, routePath) : null;
|
|
runRecord.loadedBuildAssets = results?.buildAssets ?? [];
|
|
runRecord.actualAssetUrls = route?.actualAssetUrls ?? [];
|
|
runRecord.campaignResultStatus = results?.status ?? null;
|
|
const expectedBossIds = route?.bossProgress?.orderedBossIds ?? [];
|
|
const killedBossIds = new Set(route?.bossProgress?.latestKilledBossIds ?? []);
|
|
const fiveRequiredBossesVerified = expectedBossIds.length === 5
|
|
&& expectedBossIds.every((bossId) => killedBossIds.has(bossId));
|
|
const fullClearRequirementsVerified = Boolean(results?.status === 'verified-full-clear'
|
|
&& results?.campaignFullClearVerified === true
|
|
&& route?.fullClearStatus === 'native-full-dungeon-clear-and-all-required-killed-boss-ids-observed'
|
|
&& route?.dungeonResult?.fullClearVisible === true
|
|
&& route?.dungeonResult?.requiredKilledBossIdsComplete === true
|
|
&& fiveRequiredBossesVerified);
|
|
runRecord.campaignHarnessFullClearVerified = results?.campaignFullClearVerified ?? false;
|
|
runRecord.fullClearRequirementsVerified = fullClearRequirementsVerified;
|
|
runRecord.requiredBossIds = expectedBossIds;
|
|
runRecord.killedBossIds = [...killedBossIds];
|
|
runRecord.fullClearVerified = fullClearRequirementsVerified;
|
|
runRecord.bossProgress = route?.bossProgress ?? null;
|
|
runRecord.dungeonResult = route?.dungeonResult ?? null;
|
|
runRecord.stanceBlockingEvidenceCounts = evidence?.counts ?? null;
|
|
runRecord.contentManifestAfterSha256 = contentManifestAfter.manifestSha256;
|
|
runRecord.contentManifestUnchanged = contentSourceEvidence.manifestUnchanged;
|
|
runRecord.contentSourceResponseCounts = contentSourceEvidence.counts;
|
|
runRecord.contentSourceEvidencePath = path.relative(projectRoot, path.join(outputDirectory, 'content-source-evidence.json'));
|
|
runRecord.buildManifestAfterSha256 = afterManifest.aggregateSha256;
|
|
runRecord.buildManifestUnchanged = beforeManifest.aggregateSha256 === afterManifest.aggregateSha256
|
|
&& afterManifest.aggregateSha256.toLowerCase() === expectedBuildSha256.toLowerCase();
|
|
runRecord.pageErrors = results?.pageErrors ?? null;
|
|
runRecord.consoleErrors = results?.consoleErrors ?? null;
|
|
runRecord.screenshots = campaignDirectory
|
|
? fs.readdirSync(campaignDirectory).filter((file) => file.toLowerCase().endsWith('.png'))
|
|
.map((file) => path.relative(projectRoot, path.join(campaignDirectory, file))).sort()
|
|
: [];
|
|
if (route && !evidence?.counts.stanceAuraApplications) {
|
|
runRecord.statusNotes.push('No live application of Defensive Stance 7164 or Battle Stance 7165 was captured; aura outcomes are not observed in this run.');
|
|
}
|
|
if (route && !evidence?.counts.improvedBlockingAuraApplications) {
|
|
runRecord.statusNotes.push('No live Improved Blocking 3419 application was captured; aura outcomes are not observed in this run.');
|
|
}
|
|
if (route && !evidence?.counts.rawBlockEvents) {
|
|
runRecord.statusNotes.push('No damage event with outcome=block was captured; intermittent live sampling limits negative conclusions.');
|
|
} else if (route && evidence?.counts.matchedBlockedAmountEvents < evidence?.counts.rawBlockEvents) {
|
|
runRecord.statusNotes.push(`${evidence.counts.rawBlockEvents - evidence.counts.matchedBlockedAmountEvents} block outcome event(s) had no matching sampled lastCombatResult amount; the outcome is retained without inferring a blocked amount.`);
|
|
}
|
|
if (route && evidence?.counts.actorTeamUnresolvedBlockEvents) {
|
|
runRecord.statusNotes.push(`${evidence.counts.actorTeamUnresolvedBlockEvents} block event(s) could not be assigned to party-versus-hostile direction from sampled actor IDs.`);
|
|
}
|
|
if (!runRecord.fullClearVerified && runRecord.executionStatus === 'complete' && route) {
|
|
runRecord.statusNotes.push('Campaign process exited successfully, but results UI plus all five required boss IDs were not verified; this remains a partial live attempt.');
|
|
}
|
|
if (!runRecord.buildManifestUnchanged) {
|
|
runRecord.statusNotes.push('The frozen distribution fingerprint changed during the run; preserve the evidence but do not attribute it to one immutable build.');
|
|
}
|
|
if (!runRecord.contentManifestUnchanged) {
|
|
runRecord.statusNotes.push('The read-only content manifest changed during the run; content source provenance is inconclusive.');
|
|
}
|
|
runRecord.status = runRecord.executionStatus === 'complete' && route
|
|
? runRecord.fullClearVerified ? 'complete' : 'partial-full-clear-unverified' : 'failed';
|
|
if (!runRecord.buildManifestUnchanged && runRecord.status === 'complete') runRecord.status = 'inconclusive-build-mutated';
|
|
writeJson(path.join(outputDirectory, 'run-record.json'), runRecord);
|
|
console.log(`Stockade stance/blocking QA ${runRecord.status}: ${path.relative(projectRoot, outputDirectory)}`);
|
|
if (runRecord.status !== 'complete') process.exitCode = child.status || 1;
|
|
} finally {
|
|
fs.rmSync(runtimeHarnessPath, { force: true });
|
|
}
|
|
}
|
|
|
|
try {
|
|
main();
|
|
} catch (error) {
|
|
fs.rmSync(runtimeHarnessPath, { force: true });
|
|
console.error(error.stack ?? error.message);
|
|
process.exitCode = 1;
|
|
}
|