94 lines
5.1 KiB
JavaScript
94 lines
5.1 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { Worker } from 'node:worker_threads';
|
|
import { generateMap } from '../src/mapPipeline.js';
|
|
import { createWorldMap } from '../src/worldMap.js';
|
|
import { buildMaximumProductionLasso, derivePatchSeed } from './production-fixtures.mjs';
|
|
|
|
const initial = generateMap(114514);
|
|
const world = createWorldMap(initial);
|
|
const rect = buildMaximumProductionLasso(world);
|
|
const terrainType = initial.terrainTemplate?.terrainType || initial.terrainDebug?.terrainType || 'auto';
|
|
const candidatePlan = [0, 1, 2].map((variant, index) => ({
|
|
candidateId: `r11.6-large:${variant}`,
|
|
candidateOrdinal: index + 1,
|
|
variant,
|
|
seed: derivePatchSeed(world.seed, terrainType, variant),
|
|
}));
|
|
|
|
const worker = new Worker(new URL('./browser-worker-node-shim.mjs', import.meta.url), { type: 'module' });
|
|
const startedAt = performance.now();
|
|
const result = await new Promise((resolve, reject) => {
|
|
const timeoutMs = 540_000;
|
|
const timer = setTimeout(() => {
|
|
reject(new Error(`r11.6 max-range best-of timed out after ${timeoutMs / 1000} seconds`));
|
|
void worker.terminate().catch(() => {});
|
|
}, timeoutMs);
|
|
worker.on('message', (message) => {
|
|
if (message.id !== 1 || message.type === 'progress') return;
|
|
clearTimeout(timer);
|
|
if (!message.ok) reject(new Error(message.error || message.code || 'worker failed'));
|
|
else resolve(message.result);
|
|
});
|
|
worker.on('error', (error) => { clearTimeout(timer); reject(error); });
|
|
worker.postMessage({
|
|
id: 1,
|
|
world,
|
|
rect,
|
|
options: {
|
|
patchMode: 'expansion', terrainType, variant: 0, seed: candidatePlan[0].seed,
|
|
maxQualityRetries: 0, qualityTerrainAttempts: 1,
|
|
acceptBestAvailableQuality: false, includeSeamVisualization: false,
|
|
},
|
|
search: {
|
|
searchId: 'r11.6-large-bestof-quality', operationId: 'r11.6-large-bestof-quality',
|
|
committedRevision: 1, workerEpoch: 1, executionAttempt: 1,
|
|
totalCandidateCount: 3, selectBestCandidate: true, draftSelection: true,
|
|
parallelDrafts: false, candidatePlan,
|
|
},
|
|
});
|
|
});
|
|
const elapsedMs = performance.now() - startedAt;
|
|
|
|
assert.equal(result?.ok, true, 'max-range best-of must produce a publishable full-production candidate');
|
|
assert.equal(result?.bestOfCandidates, true, 'multiple-candidate highest-quality selection remains enabled');
|
|
assert.equal(result?.candidateQuality?.hardPass, true, 'selected candidate must pass full quality');
|
|
assert.equal(result?.candidateQuality?.finalMerge?.hardPass, true, 'selected whole-selection merge must pass');
|
|
assert.equal(result?.seamDiagnostics?.hardPass, true, 'selected candidate must pass seam audit');
|
|
|
|
const attempts = result.searchAttempts || [];
|
|
const fullAttempts = attempts.filter((a) => ['evaluated', 'success'].includes(a.status));
|
|
assert.equal(fullAttempts.length, 3, 'overlapping admissible bounds compare all three complete candidates');
|
|
assert.equal(result?.draftSelection?.fullGenerationPassCount, 3, 'winner publication must not perform a fourth rematerialization generation');
|
|
const maxScore = Math.max(...fullAttempts.map((a) => Number(a.candidateQuality?.finalMerge?.score ?? -Infinity)));
|
|
assert(Math.abs(Number(result.candidateQuality.finalMerge.score) - maxScore) < 1e-12, 'selected candidate must be the highest final-production quality among full candidates');
|
|
assert(['admissible-bound-cached-winner', 'admissible-bound-winner-live'].includes(result?.draftSelection?.selectionReason), 'winner must publish either directly from the live exact Production state or from retained exact replay state, never by a fourth full regeneration');
|
|
|
|
const req = result.candidateQuality.finalMerge.transportRequirements || {};
|
|
const cls = result.candidateQuality.finalMerge.transportClasses || {};
|
|
for (const key of ['national', 'expressway', 'railTrunk']) {
|
|
if (!req[key]?.demand) continue;
|
|
assert((cls[key]?.cells || 0) >= (req[key]?.minCells || 0), `${key}: routed coverage floor must be met`);
|
|
assert((cls[key]?.paths || 0) > 0, `${key}: demanded class must exist`);
|
|
}
|
|
assert(Object.entries(req).some(([key, value]) => value?.demand && (cls[key]?.paths || 0) < (value?.minPaths || 0) && (cls[key]?.cells || 0) >= (value?.minCells || 0)),
|
|
'fixture must exercise representation-independent quality: fewer merged paths than diagnostic minPaths while routed coverage still passes');
|
|
|
|
const compactReq = fullAttempts.find((a) => a.candidateQuality?.finalMerge?.transportRequirements)?.candidateQuality?.finalMerge?.transportRequirements || {};
|
|
for (const value of Object.values(compactReq)) {
|
|
assert.equal(value.required, value.demand, 'compact Worker diagnostics must mirror the real demand field');
|
|
}
|
|
|
|
console.log(JSON.stringify({
|
|
ok: true,
|
|
elapsedMs: Math.round(elapsedMs),
|
|
selectedVariant: result.actualVariant,
|
|
selectedScore: result.candidateQuality.finalMerge.score,
|
|
scores: fullAttempts.map((a) => ({ variant: a.variant, score: a.candidateQuality?.finalMerge?.score })),
|
|
fullGenerationPassCount: result.draftSelection.fullGenerationPassCount,
|
|
selectionReason: result.draftSelection.selectionReason,
|
|
transportClasses: cls,
|
|
transportRequirements: req,
|
|
}, null, 2));
|
|
|
|
await worker.terminate();
|
|
process.exit(0);
|