Connect normal Spice Banker deferred bank income

Fresh classic banker-income profile preserves actual bank legs, physical once-phase use and original-faction atomic Mentat collection. Provisional earned custody stays explicit; public/old/combined modes unchanged. Final check: types/lint and 6487 offline cases; focused 140; guide 10; build; native18/four legal budgets; two original six-seat CLI/human390px rooms and82 saved seats25rooms. Final two reviews no findings. Local HTTP49/55 six known upstream503 failures, not green. No reset or deployed claim.
This commit is contained in:
Quintine committed 2026-10-02 06:45:21 +10:00
1 parent 13c46450a9
commit 6785e622a7
18 files changed
+2767 -13

No files matched your search

+794
View File
@@ -0,0 +1,794 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import type { DatabaseSync, SQLOutputValue } from 'node:sqlite';
import { applyAction, viewGame, type Action, type Game } from '../game/engine';
import { createLeaderSkills } from '../game/leader-skills';
import type { RoomsClock, SeatAuth } from '../db/rooms';
import type * as Rooms from '../db/rooms';
import { startPrototypeRoom } from '../tools/prototype-room';
import { unitStore } from './fixture-nexus-room-store';
import {
createSpiceBankerIncomeFixture,
createSpiceBankerIncomeReassignmentFixture,
nextSpiceBankerIncomeNativeStep,
quoteSpiceBankerIncomeBattleEconomics,
stageSpiceBankerIncomeTrainerBattle,
withSpiceBankerIncomeSetupRandomness,
type SpiceBankerIncomeFixture,
type SpiceBankerIncomeFixtureOptions as Options,
} from './fixture-spice-banker-income';
type SqlRow = Record<string, SQLOutputValue>;
interface Fixture extends SpiceBankerIncomeFixture {
sqlite: DatabaseSync;
restart(): typeof Rooms;
hooks: { beforeWrite?: () => Promise<void> };
tokens: string[];
auths: SeatAuth[];
code: string;
unrelatedCode: string;
unrelatedToken: string;
protectedRows: Record<string, SqlRow[]>;
stock: string[];
save(game: Game): void;
}
const clock: RoomsClock = { now: () => 10000, sleep: async () => {} };
function records(sqlite: DatabaseSync, excludedRoom?: string) {
const result: Record<string, SqlRow[]> = {};
for (const row of sqlite.prepare("SELECT name FROM sqlite_schema WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name").all()) {
assert.equal(typeof row.name, 'string');
const table = String(row.name).replaceAll('"', '""');
result[String(row.name)] = sqlite.prepare(`SELECT * FROM "${table}"`).all()
.filter(value => !(row.name === 'rooms' && value.code === excludedRoom));
}
return result;
}
function player(game: Game, id: string) {
const value = game.players.find(seat => seat.id === id);
assert.ok(value);
return value;
}
function physical(game: Game) {
const cards = [...game.deck, ...game.discard, ...game.players.flatMap(seat => seat.hand),
...(game.auction?.cards.slice(game.auction.index + Number(game.currentAuctionSale?.origin === 'normal')) ?? [])];
const ids = cards.map(card => card.id).sort();
assert.equal(new Set(ids).size, ids.length, 'one physical custodian per original Treachery Card');
return ids;
}
async function authenticate(f: Fixture, id: string) {
const index = f.auths.findIndex(auth => auth.playerId === id);
assert.ok(index >= 0);
const auth = await f.restart().authenticate(f.code, f.tokens[index]);
assert.equal(auth.playerId, id);
return auth;
}
async function act(f: Fixture, game: Game, actor: string, action: Action) {
await f.restart().act(f.code, await authenticate(f, actor), game.version, action, clock);
if (action.type === 'advanceBots') await f.restart().continueRoomAutomatic(f.code, clock);
return f.restart().readRoom(f.code);
}
async function fixture(t: test.TestContext, options: Options = {}): Promise<Fixture> {
const store = unitStore();
t.after(() => store.sqlite.close());
const bankerFaction = options.bankerFaction ?? 'atreides';
const made = await store.rooms.createRoom('Original Banker faction', bankerFaction, options.advanced ?? true, []);
const code = made.view.code;
const tokens = [made.token];
const factions = [bankerFaction === 'harkonnen' ? 'atreides' : 'harkonnen', 'beneGesserit'] as const;
for (const faction of [...factions, ...(options.guild ? ['guild'] as const : []),
...(options.emperor || options.kind === 'emperor-extra-revival' ? ['emperor'] as const : [])]) {
const joined = await store.rooms.joinRoom(code, faction, faction);
assert.ok(joined.token);
tokens.push(joined.token);
}
const auths = await Promise.all(tokens.map(token => store.rooms.authenticate(code, token)));
let lobby = await store.rooms.readRoom(code);
for (const auth of auths) {
await store.rooms.act(code, auth, lobby.version, { type: 'ready' }, clock);
lobby = await store.rooms.readRoom(code);
}
// BG keeps the entry's actual native setup undealt. The fixture consumes that
// original setup; it cannot reset already dealt cards or replace an offer.
withSpiceBankerIncomeSetupRandomness(() => startPrototypeRoom(store.sqlite, code, lobby.version, 'banker-income'));
const setup = await store.rooms.readRoom(code);
const native = createSpiceBankerIncomeFixture({ ...options, initial: setup });
assert.equal(native.beforePayment.code, code);
assert.equal(native.beforePayment.host, lobby.host);
assert.deepEqual(native.beforePayment.playerPositions, lobby.playerPositions);
assert.deepEqual(native.beforePayment.players.map(seat => [seat.id, seat.name, seat.faction]),
lobby.players.map(seat => [seat.id, seat.name, seat.faction]));
const save = (game: Game) => {
assert.equal(store.sqlite.prepare('UPDATE rooms SET state=?,version=? WHERE code=?')
.run(JSON.stringify(game), game.version, code).changes, 1);
};
save(native.beforePayment);
const unrelated = await store.rooms.createRoom('Unrelated private lobby', 'guild', false, []);
return { ...store, ...native, code, tokens, auths, save, unrelatedCode: unrelated.view.code,
unrelatedToken: unrelated.token, protectedRows: records(store.sqlite, code), stock: physical(native.beforePayment) };
}
async function restored(f: Fixture, game: Game) {
const before = records(f.sqlite);
for (const auth of f.auths) {
const view = await f.restart().readSeatView(f.code, await authenticate(f, auth.playerId));
assert.deepEqual(view, viewGame(game, auth.playerId));
assert.deepEqual(Object.keys(view.spiceBankerIncome!).sort(), ['deferred', 'usedThisPhase']);
assert.equal(Object.hasOwn(view, 'deck'), false);
assert.equal(Object.hasOwn(view, 'spiceBankerIncomePayment'), false);
const projected = JSON.stringify(view);
const income = JSON.stringify(view.spiceBankerIncome);
for (const receipt of game.spiceBankerIncome!.sources) {
assert.equal(projected.includes(receipt.source.event), false, 'native payment event stays private in the entire view');
assert.equal(projected.includes(receipt.signature), false, 'receipt consistency data stays private in the entire view');
assert.equal(income.includes(JSON.stringify(receipt.source.bankLegs)), false, 'actual payer legs stay server-only');
}
const pendingPayment = game.response?.spiceBankerIncomePayment;
if (pendingPayment) {
assert.equal(view.response!.spiceBankerIncomePayment, undefined);
assert.equal(projected.includes('"spiceBankerIncomePayment":'), false, 'serialized response has no private invoice field');
assert.equal(projected.includes(pendingPayment.event), false, 'pending native invoice event stays private');
assert.equal(projected.includes(pendingPayment.signature), false, 'pending invoice signature stays private');
assert.equal(projected.includes(JSON.stringify(pendingPayment.legs)), false, 'pending own and donor legs stay private');
}
for (const seat of view.players)
if (seat.id !== auth.playerId) assert.equal(seat.hand, undefined);
}
assert.deepEqual(await f.restart().readRoom(f.code), game);
assert.deepEqual(records(f.sqlite), before, 'authenticated projections never award, collect or repair');
assert.deepEqual(records(f.sqlite, f.code), f.protectedRows);
assert.deepEqual(physical(game), f.stock);
}
async function rejected(f: Fixture, game: Game, auth: SeatAuth, action: Action, version = game.version) {
const before = records(f.sqlite);
await assert.rejects(f.restart().act(f.code, auth, version, action, clock));
assert.deepEqual(records(f.sqlite), before, 'rejected action changes no currency, card, credential or room');
}
async function settlePayment(f: Fixture, before = f.beforePayment) {
let game = await act(f, before, f.actor, f.paymentAction);
for (let steps = 0; (game.response || game.decision?.kind === 'guildShipment') && steps < 30; steps++) {
const step = nextSpiceBankerIncomeNativeStep(game);
assert.ok(step);
game = await act(f, game, step.actor, step.action);
}
assert.equal(game.response, null);
return game;
}
async function finalCollectionStep(f: Fixture, initial: Game) {
let game = initial;
for (let steps = 0; steps < 500; steps++) {
assert.notEqual(game.phase, 8, 'the original final Collection action must still be pending');
const step = nextSpiceBankerIncomeNativeStep(game);
assert.ok(step, `native continuation is available in phase ${game.phase}`);
if (game.phase === 7 && applyAction(game, step.actor, step.action).phase === 8)
return { game, step };
game = await act(f, game, step.actor, step.action);
}
assert.fail('native Collection completion did not become available');
}
for (const advanced of [false, true]) {
void test(`SQLite ${advanced ? 'Advanced' : 'Basic'} original auction pays once, holds unavailable income through restart and collects at actual native Mentat`, async t => {
const f = await fixture(t, { advanced });
const before = f.beforePayment;
assert.ok(before.auction?.bidder);
const payer = before.auction.bidder;
const card = before.auction.cards[before.auction.index];
const payerSpice = player(before, payer).spice;
const ownerSpice = player(before, f.owner).spice;
const paid = await settlePayment(f);
assert.equal(player(paid, payer).spice, payerSpice - 4);
assert.equal(player(paid, payer).hand.filter(held => held.id === card.id).length, 1);
assert.equal(player(paid, f.owner).spice, ownerSpice);
assert.deepEqual(viewGame(paid, f.owner).spiceBankerIncome!.deferred, [{ owner: f.owner, amount: 1 }]);
assert.equal(paid.spiceBankerIncome!.sources.filter(source => source.grant).length, 1);
await restored(f, paid);
await rejected(f, paid, await authenticate(f, f.actor), f.paymentAction, before.version);
const final = await finalCollectionStep(f, paid);
await restored(f, final.game);
const funds = player(final.game, f.owner).spice;
const done = await act(f, final.game, final.step.actor, final.step.action);
assert.equal(done.phase, 8);
assert.equal(player(done, f.owner).spice, funds + 1);
assert.deepEqual(viewGame(done, f.owner).spiceBankerIncome!.deferred, []);
assert.equal(done.spiceBankerIncome!.collections.length, 1);
assert.deepEqual(done.spiceBankerIncome!.collections[0].credits, [{ owner: f.owner, amount: 1 }]);
await Promise.all([f.restart().continueRoomAutomatic(f.code, clock), f.restart().continueRoomAutomatic(f.code, clock)]);
assert.deepEqual(await f.restart().readRoom(f.code), done);
await rejected(f, done, await authenticate(f, final.step.actor), final.step.action, final.game.version);
await restored(f, done);
});
}
for (const options of [{ amount: 3 }, { ownerIsPayer: true }] satisfies Options[]) {
void test(`SQLite original auction ${options.amount === 3 ? 'below four' : 'by Banker owner'} cannot produce normal income`, async t => {
const f = await fixture(t, options);
const before = f.beforePayment;
assert.ok(before.auction?.bidder);
const payer = before.auction.bidder;
const amount = options.amount ?? 4;
const done = await settlePayment(f);
assert.equal(player(done, payer).spice, player(before, payer).spice - amount);
assert.deepEqual(viewGame(done, f.owner).spiceBankerIncome!.deferred, []);
assert.equal(done.spiceBankerIncome!.sources.filter(source => source.grant).length, 0);
await restored(f, done);
});
}
void test('SQLite duplicate original payment race admits one debit, one physical card and one deferred grant', async t => {
const f = await fixture(t);
const before = f.beforePayment;
assert.ok(before.auction?.bidder);
const payer = before.auction.bidder;
const card = before.auction.cards[before.auction.index];
const auth = await authenticate(f, f.actor);
let arrivals = 0;
let release!: () => void;
const gate = new Promise<void>(resolve => { release = resolve; });
f.hooks.beforeWrite = async () => { if (++arrivals === 2) release(); await gate; };
let results: PromiseSettledResult<unknown>[];
try {
results = await Promise.allSettled([f.restart(), f.restart()].map(rooms =>
rooms.act(f.code, auth, before.version, f.paymentAction, clock).finally(release)));
} finally { delete f.hooks.beforeWrite; }
assert.equal(results.filter(result => result.status === 'fulfilled').length, 1);
assert.equal(results.filter(result => result.status === 'rejected').length, 1);
const done = await f.restart().readRoom(f.code);
assert.equal(done.version, before.version + 1);
assert.equal(player(done, payer).spice, player(before, payer).spice - 4);
assert.equal(player(done, payer).hand.filter(held => held.id === card.id).length, 1);
assert.equal(done.spiceBankerIncome!.sources.filter(source => source.grant).length, 1);
await restored(f, done);
});
void test('SQLite lost original payment CAS cannot leak a speculative grant or retire the original card', async t => {
const f = await fixture(t);
const before = f.beforePayment;
const competing = structuredClone(before);
competing.version++;
f.hooks.beforeWrite = async () => {
delete f.hooks.beforeWrite;
f.save(competing);
};
await assert.rejects(f.restart().act(f.code, await authenticate(f, f.actor), before.version, f.paymentAction, clock));
assert.deepEqual(await f.restart().readRoom(f.code), competing);
assert.deepEqual(viewGame(competing, f.owner).spiceBankerIncome!.deferred, []);
await restored(f, competing);
const done = await settlePayment(f, competing);
assert.equal(done.spiceBankerIncome!.sources.filter(source => source.grant).length, 1);
await restored(f, done);
});
void test('SQLite racing final Collection readiness and automatic recovery credit the original owner atomically once', async t => {
const f = await fixture(t);
const paid = await settlePayment(f);
const { game, step } = await finalCollectionStep(f, paid);
const funds = player(game, f.owner).spice;
const auth = await authenticate(f, step.actor);
let arrivals = 0;
let release!: () => void;
const gate = new Promise<void>(resolve => { release = resolve; });
f.hooks.beforeWrite = async () => { if (++arrivals === 2) release(); await gate; };
let results: PromiseSettledResult<unknown>[];
try {
results = await Promise.allSettled([
f.restart().act(f.code, auth, game.version, step.action, clock).finally(release),
f.restart().act(f.code, auth, game.version, step.action, clock).finally(release),
f.restart().continueRoomAutomatic(f.code, clock),
f.restart().continueRoomAutomatic(f.code, clock),
]);
} finally { delete f.hooks.beforeWrite; }
assert.equal(results.slice(0, 2).filter(result => result.status === 'fulfilled').length, 1);
const done = await f.restart().readRoom(f.code);
assert.equal(done.phase, 8);
assert.equal(done.version, game.version + 1);
assert.equal(player(done, f.owner).spice, funds + 1);
assert.equal(done.spiceBankerIncome!.collections.length, 1);
assert.deepEqual(viewGame(done, f.owner).spiceBankerIncome!.deferred, []);
await Promise.all([f.restart().continueRoomAutomatic(f.code, clock), f.restart().continueRoomAutomatic(f.code, clock)]);
assert.deepEqual(await f.restart().readRoom(f.code), done);
await restored(f, done);
});
void test('SQLite foreign credentials, wrong native actor, stale version and forged automatic-income actions cannot mutate payment state', async t => {
const f = await fixture(t);
const before = records(f.sqlite);
const foreign = await f.restart().authenticate(f.unrelatedCode, f.unrelatedToken);
await assert.rejects(f.restart().authenticate(f.code, f.unrelatedToken));
await assert.rejects(f.restart().readSeatView(f.code, foreign));
await assert.rejects(f.restart().readSeatView(f.code, { playerId: f.actor, tokenHash: foreign.tokenHash }));
assert.deepEqual(records(f.sqlite), before);
for (const auth of [foreign, { playerId: f.actor, tokenHash: foreign.tokenHash },
await authenticate(f, f.auths.find(auth => auth.playerId !== f.actor)!.playerId)])
await rejected(f, f.beforePayment, auth, f.paymentAction);
const auth = await authenticate(f, f.actor);
await rejected(f, f.beforePayment, auth, f.paymentAction, f.beforePayment.version - 1);
for (const action of [{ type: 'spiceBankerIncome', amount: 1 }, { type: 'collectSpiceBankerIncome' },
{ ...f.paymentAction, actor: f.owner }, { ...f.paymentAction, bankerIncome: 1 },
{ ...f.paymentAction, paymentSource: 'bank' }])
await rejected(f, f.beforePayment, auth, action);
f.sqlite.prepare('UPDATE seats SET revoked=1 WHERE room_code=? AND player_id=?').run(f.code, f.actor);
f.protectedRows = records(f.sqlite, f.code);
await assert.rejects(f.restart().readSeatView(f.code, auth));
await rejected(f, f.beforePayment, auth, f.paymentAction);
});
void test('SQLite corrupt earned source, recipient, amount, stamps and collection history fail closed without read or recovery repair', async t => {
const f = await fixture(t);
const paid = await settlePayment(f);
const changes: ((game: Game) => void)[] = [
game => { game.spiceBankerIncome!.sources[0].source.bankLegs[0].amount++; },
game => { game.spiceBankerIncome!.sources[0].source.event += ':forged'; },
game => { game.spiceBankerIncome!.sources[0].grant!.owner = f.payer; },
game => { game.spiceBankerIncome!.sources[0].grant!.stamp += ':reset'; },
game => { game.spiceBankerIncome!.sources.push(structuredClone(game.spiceBankerIncome!.sources[0])); },
game => { game.spiceBankerIncome!.head += ':forged'; },
game => { game.spiceBankerIncome!.signature += ':forged'; },
];
const final = await finalCollectionStep(f, paid);
const collected = await act(f, final.game, final.step.actor, final.step.action);
const corruptCollection = structuredClone(collected);
corruptCollection.spiceBankerIncome!.collections[0].credits[0].amount++;
for (const corrupt of [...changes.map(change => { const game = structuredClone(paid); change(game); return game; }), corruptCollection]) {
f.save(corrupt);
const before = records(f.sqlite);
const snapshot = structuredClone(corrupt);
for (const auth of f.auths)
await assert.rejects(f.restart().readSeatView(f.code, await authenticate(f, auth.playerId)));
await rejected(f, corrupt, await authenticate(f, f.actor), { type: 'ready' });
await Promise.allSettled([f.restart().continueRoomAutomatic(f.code, clock), f.restart().continueRoomAutomatic(f.code, clock)]);
assert.deepEqual(records(f.sqlite), before);
assert.deepEqual(corrupt, snapshot);
}
});
void test('SQLite front-shield income cannot fund a native bid before Mentat collection', async t => {
const f = await fixture(t);
let game = await settlePayment(f);
for (let steps = 0; game.phase === 3 && game.auction?.active !== f.owner && steps < 30; steps++) {
const step = nextSpiceBankerIncomeNativeStep(game);
assert.ok(step);
game = await act(f, game, step.actor, step.action);
}
assert.equal(game.phase, 3);
assert.equal(game.auction?.active, f.owner);
assert.deepEqual(viewGame(game, f.owner).spiceBankerIncome!.deferred, [{ owner: f.owner, amount: 1 }]);
assert.equal(player(game, f.owner).hand.some(card => card.effect === 'karama'), false,
'this is an ordinary funded bid, not an authorized free Karama overbid');
await rejected(f, game, await authenticate(f, f.owner),
{ type: 'bid', amount: player(game, f.owner).spice + 1 });
await restored(f, game);
});
for (const guild of [false, true]) {
void test(`SQLite original shipment to ${guild ? 'native Guild' : 'Bank'} preserves its actual recipient and credits only the Bank case`, async t => {
const f = await fixture(t, { kind: 'shipment', guild });
const before = f.beforePayment;
const payer = player(before, f.payer);
const shipped = Number(f.paymentAction.amount ?? before.pendingShipment?.amount);
assert.ok(Number.isSafeInteger(shipped) && shipped > 0);
const recipient = before.players.find(seat => seat.faction === 'guild');
const done = await settlePayment(f);
assert.equal(player(done, f.payer).spice, payer.spice - f.amount);
assert.equal(player(done, f.payer).reserves, payer.reserves - shipped);
assert.equal(player(done, f.payer).shipped, true);
if (f.actor !== f.payer)
assert.equal(player(done, f.actor).reserves, player(before, f.actor).reserves,
'the native executor does not ship the economic payer’s reserves');
if (recipient) assert.equal(player(done, recipient.id).spice, recipient.spice + f.amount);
assert.deepEqual(viewGame(done, f.owner).spiceBankerIncome!.deferred,
guild ? [] : [{ owner: f.owner, amount: 1 }]);
await restored(f, done);
});
}
void test('SQLite genuine free force revival has zero bank payment and never manufactures income', async t => {
const f = await fixture(t, { kind: 'force-revival' });
const before = f.beforePayment;
const funds = player(before, f.actor).spice;
const tanks = player(before, f.actor).tanks;
const reserves = player(before, f.actor).reserves;
const done = await act(f, before, f.actor, { type: 'revive', amount: 1 });
assert.equal(player(done, f.actor).spice, funds);
assert.equal(player(done, f.actor).tanks, tanks - 1);
assert.equal(player(done, f.actor).reserves, reserves + 1);
assert.deepEqual(viewGame(done, f.owner).spiceBankerIncome!.deferred, []);
assert.equal(done.spiceBankerIncome!.sources.filter(source => source.grant).length, 0);
await restored(f, done);
});
void test('SQLite pending native Guild income keeps its funded own and donor invoice private and rejects invoice corruption without repair', async t => {
const f = await fixture(t, { kind: 'shipment', guild: true, amount: 5, allySplit: 1, stageIncomeCounter: true });
const before = f.beforePayment;
assert.ok(player(before, f.owner).hand.some(card => card.effect === 'karama'),
'an actual held counter keeps the original Guild income window eligible');
const donor = player(before, f.payer).ally;
const guild = before.players.find(seat => seat.faction === 'guild');
assert.ok(donor && guild);
let pending = await act(f, before, f.actor, f.paymentAction);
for (let steps = 0; (pending.decision?.kind === 'guildShipment' ||
pending.response?.kind === 'guildRate') && steps < 30; steps++) {
assert.equal(pending.phase, before.phase, 'only the original shipment’s native windows may continue');
const step = nextSpiceBankerIncomeNativeStep(pending);
assert.ok(step);
pending = await act(f, pending, step.actor, step.action);
}
assert.equal(pending.response?.kind, 'guildIncome');
const invoice = pending.response!.spiceBankerIncomePayment;
assert.ok(invoice);
assert.deepEqual(invoice.legs, [
{ payer: f.payer, amount: 4, recipient: 'player' },
{ payer: donor, amount: 1, recipient: 'player' },
]);
assert.equal(player(pending, f.payer).spice, player(before, f.payer).spice - 4);
assert.equal(player(pending, donor).spice, player(before, donor).spice, 'native donor escrow was paid before declaration');
assert.equal(player(pending, f.payer).reserves, player(before, f.payer).reserves - 5);
assert.equal(player(pending, guild.id).spice, guild.spice, 'original recipient is still awaiting its response');
assert.deepEqual(viewGame(pending, f.owner).spiceBankerIncome!.deferred, []);
await restored(f, pending);
assert.throws(() => viewGame(pending, 'spectator'));
const privateValues: readonly string[] = [invoice.event, invoice.signature, JSON.stringify(invoice.legs)];
for (const seat of pending.players) {
const publicView = viewGame(pending, seat.id);
assert.equal(publicView.response!.spiceBankerIncomePayment, undefined);
assert.equal(JSON.stringify(publicView).includes('"spiceBankerIncomePayment":'), false);
for (const privateValue of privateValues)
assert.equal(JSON.stringify(publicView).includes(privateValue), false);
}
const changes: ((game: Game) => void)[] = [
game => { delete game.response!.spiceBankerIncomePayment; },
game => { game.response!.spiceBankerIncomePayment!.event += ':forged'; },
game => { game.response!.spiceBankerIncomePayment!.signature += ':forged'; },
game => { game.response!.spiceBankerIncomePayment!.legs[0].amount++; },
game => { game.response!.spiceBankerIncomePayment!.legs[1].payer = f.payer; },
game => { game.response!.spiceBankerIncomePayment!.legs[0].recipient = 'bank'; },
game => { game.response!.spiceBankerIncomePayment!.kind = 'auction'; },
];
const continuation = nextSpiceBankerIncomeNativeStep(pending);
assert.ok(continuation);
for (const change of changes) {
const corrupt = structuredClone(pending);
change(corrupt);
f.save(corrupt);
const rows = records(f.sqlite);
for (const auth of f.auths)
await assert.rejects(f.restart().readSeatView(f.code, await authenticate(f, auth.playerId)));
await rejected(f, corrupt, await authenticate(f, continuation.actor), continuation.action);
await Promise.allSettled([f.restart().continueRoomAutomatic(f.code, clock), f.restart().continueRoomAutomatic(f.code, clock)]);
assert.deepEqual(records(f.sqlite), rows, 'corrupt pending invoices cannot be repaired by refresh or automatic recovery');
}
f.save(pending);
let paid = pending;
for (let steps = 0; paid.response && steps < 30; steps++) {
const step = nextSpiceBankerIncomeNativeStep(paid);
assert.ok(step);
paid = await act(f, paid, step.actor, step.action);
}
assert.equal(paid.response, null);
assert.equal(player(paid, guild.id).spice, guild.spice + 5);
assert.equal(player(paid, f.payer).spice, player(pending, f.payer).spice);
assert.deepEqual(player(paid, f.payer).forces, player(pending, f.payer).forces);
assert.deepEqual(viewGame(paid, f.owner).spiceBankerIncome!.deferred, []);
await restored(f, paid);
});
void test('SQLite competing original shipment declarations preserve only the winning tariff and delivered group', async t => {
const f = await fixture(t, { kind: 'shipment' });
const before = f.beforePayment;
const auth = await authenticate(f, f.actor);
const actions = [f.paymentAction, { ...f.paymentAction, amount: 5 }];
let arrivals = 0;
let release!: () => void;
const gate = new Promise<void>(resolve => { release = resolve; });
f.hooks.beforeWrite = async () => { if (++arrivals === 2) release(); await gate; };
let results: PromiseSettledResult<unknown>[];
try {
results = await Promise.allSettled(actions.map(action =>
f.restart().act(f.code, auth, before.version, action, clock).finally(release)));
} finally { delete f.hooks.beforeWrite; }
assert.equal(results.filter(result => result.status === 'fulfilled').length, 1);
const winner = results.findIndex(result => result.status === 'fulfilled');
const amount = winner === 0 ? 4 : 5;
const done = await f.restart().readRoom(f.code);
assert.equal(player(done, f.payer).spice, player(before, f.payer).spice - amount);
assert.equal(player(done, f.payer).reserves, player(before, f.payer).reserves - amount);
assert.equal(done.spiceBankerIncome!.sources.filter(source => source.grant).length, 1);
assert.deepEqual(viewGame(done, f.owner).spiceBankerIncome!.deferred, [{ owner: f.owner, amount: 1 }]);
await restored(f, done);
});
for (const fate of ['death', 'capture'] as const) {
void test(`SQLite original earned currency survives actual native trainer ${fate} and collects for the original faction under the local policy`, async t => {
const f = await fixture(t, { advanced: true });
const paid = await settlePayment(f);
const earned = structuredClone(paid.spiceBankerIncome);
// The fixture stages conserved battle pieces, then executes the genuine
// visibility, plans, survival and capture choices; it never edits income.
const changed = stageSpiceBankerIncomeTrainerBattle(paid, { [fate]: true });
const trainer = player(changed, f.owner).leaders.find(leader => leader.id === f.leader);
assert.ok(trainer);
if (fate === 'death') assert.equal(trainer.dead, true);
else assert.equal(trainer.capturedBy, changed.players.find(seat => seat.faction === 'harkonnen')!.id);
assert.deepEqual(changed.spiceBankerIncome, earned);
assert.deepEqual(viewGame(changed, f.owner).spiceBankerIncome!.deferred, [{ owner: f.owner, amount: 1 }]);
f.save(changed);
await restored(f, changed);
const { game, step } = await finalCollectionStep(f, changed);
const funds = game.players.map(seat => [seat.id, seat.spice] as const);
const done = await act(f, game, step.actor, step.action);
for (const [id, spice] of funds)
assert.equal(player(done, id).spice, spice + Number(id === f.owner));
assert.deepEqual(done.spiceBankerIncome!.collections[0].credits, [{ owner: f.owner, amount: 1 }]);
await Promise.all([f.restart().continueRoomAutomatic(f.code, clock), f.restart().continueRoomAutomatic(f.code, clock)]);
assert.deepEqual(await f.restart().readRoom(f.code), done);
await restored(f, done);
});
}
void test('SQLite two distinct native auction purchases retain both original costs but award only once in their phase', async t => {
const f = await fixture(t);
const firstPurchase = f.beforePayment.auction!.cards[f.beforePayment.auction!.index].id;
const firstBonus = f.beforePayment.deck[0].id;
const firstHand = player(f.beforePayment, f.payer).hand.map(card => card.id);
assert.equal(player(f.beforePayment, f.payer).faction, 'harkonnen');
const first = await settlePayment(f);
assert.equal(player(first, f.payer).spice, player(f.beforePayment, f.payer).spice - 4);
assert.notEqual(firstPurchase, firstBonus);
assert.deepEqual(player(first, f.payer).hand.map(card => card.id).sort(),
[...firstHand, firstPurchase, firstBonus].sort());
assert.deepEqual(first.deck.map(card => card.id), f.beforePayment.deck.slice(1).map(card => card.id));
let game = first;
for (let steps = 0; game.auction?.active !== f.payer && steps < 30; steps++) {
const step = nextSpiceBankerIncomeNativeStep(game);
assert.ok(step);
game = await act(f, game, step.actor, step.action);
}
assert.equal(game.phase, 3);
assert.equal(game.auction?.active, f.payer);
const funds = player(game, f.payer).spice;
const hand = player(game, f.payer).hand.map(card => card.id);
const acquired = game.auction!.cards[game.auction!.index].id;
const bonus = game.deck[0].id;
const deck = game.deck.map(card => card.id);
assert.equal(hand.includes(acquired), false);
assert.equal(hand.includes(bonus), false);
assert.notEqual(acquired, firstPurchase, 'the second purchase is a distinct original auction lot');
assert.notEqual(acquired, bonus);
game = await act(f, game, f.payer, { type: 'bid', amount: 4 });
for (let steps = 0; (!player(game, f.payer).hand.some(card => card.id === acquired) ||
game.response?.kind === 'harkonnenBonus') && steps < 30; steps++) {
if (game.decision?.kind === 'auctionPayment')
game = await act(f, game, f.payer, { type: 'decision', karama: false });
else {
const step = nextSpiceBankerIncomeNativeStep(game);
assert.ok(step);
game = await act(f, game, step.actor, step.action);
}
}
assert.equal(player(game, f.payer).spice, funds - 4);
assert.deepEqual(player(game, f.payer).hand.map(card => card.id).sort(), [...hand, acquired, bonus].sort());
assert.deepEqual(game.deck.map(card => card.id), deck.slice(1), 'the actual native bonus leaves its sole deck custodian once');
assert.equal(game.spiceBankerIncome!.sources.length, first.spiceBankerIncome!.sources.length + 1);
assert.equal(game.spiceBankerIncome!.sources.filter(source => source.grant).length, 1);
assert.notEqual(game.spiceBankerIncome!.sources[0].source.event, game.spiceBankerIncome!.sources[1].source.event);
assert.deepEqual(game.spiceBankerIncome!.sources.map(receipt => receipt.source.bankLegs),
[[{ payer: f.payer, amount: 4 }], [{ payer: f.payer, amount: 4 }]]);
assert.deepEqual(viewGame(game, f.owner).spiceBankerIncome!.deferred, [{ owner: f.owner, amount: 1 }]);
await restored(f, game);
});
void test('SQLite one funded auction split between actual payers never pools three and one into a qualifying payment', async t => {
const f = await fixture(t, { amount: 4, allySplit: 1 });
const before = f.beforePayment;
const donor = player(before, f.payer).ally;
assert.ok(donor);
const done = await settlePayment(f);
assert.equal(player(done, f.payer).spice, player(before, f.payer).spice - 3);
assert.equal(player(done, donor).spice, player(before, donor).spice, 'already committed donor escrow is not charged twice');
const source = done.spiceBankerIncome!.sources.at(-1);
assert.ok(source);
assert.deepEqual(source.source.bankLegs, [{ payer: f.payer, amount: 3 }, { payer: donor, amount: 1 }]);
assert.equal(source.grant, null);
assert.deepEqual(viewGame(done, f.owner).spiceBankerIncome!.deferred, []);
await restored(f, done);
});
void test('SQLite the actual returned Banker card can be legally revived and assigned to a different faction without transferring original earned currency', async t => {
const f = await fixture(t, { advanced: true });
const paid = await settlePayment(f);
const originalSource = structuredClone(paid.spiceBankerIncome!.sources[0]);
// Parent-approved entropy is scoped to the genuine native mutual-death return
// shuffle. The helper then follows real Mentat and next-turn Revival; it never
// reorders a started deck, fabricates an offer or edits an income receipt.
const lifecycle = createSpiceBankerIncomeReassignmentFixture(paid);
let game = lifecycle.beforeRevival;
assert.notEqual(lifecycle.actor, lifecycle.originalOwner);
assert.equal(game.turn, paid.turn + 1);
assert.equal(game.phase, 4);
assert.deepEqual(game.spiceBankerIncome!.sources[0], originalSource);
assert.deepEqual(game.spiceBankerIncome!.collections[0].credits, [{ owner: lifecycle.originalOwner, amount: 1 }]);
assert.deepEqual(viewGame(game, lifecycle.originalOwner).spiceBankerIncome!.deferred, []);
assert.equal(game.leaderSkills!.assignments.some(assignment => assignment.skill === 'spice-banker'), false);
f.save(game);
await restored(f, game);
const funds = player(game, lifecycle.actor).spice;
const originalFunds = player(game, lifecycle.originalOwner).spice;
const trainer = player(game, lifecycle.actor).leaders.find(leader => leader.id === lifecycle.leader);
assert.ok(trainer?.dead);
const price = trainer.strength;
game = await act(f, game, lifecycle.actor, lifecycle.revivalAction);
for (let steps = 0; game.response && steps < 30; steps++) {
const step = nextSpiceBankerIncomeNativeStep(game);
assert.ok(step);
game = await act(f, game, step.actor, step.action);
}
assert.equal(game.decision?.kind, 'leaderSkillRevival');
assert.equal(player(game, lifecycle.actor).spice, funds - price);
assert.equal(player(game, lifecycle.originalOwner).spice, originalFunds);
assert.equal(player(game, lifecycle.actor).leaders.find(leader => leader.id === lifecycle.leader)!.dead, false);
assert.equal(game.spiceBankerIncome!.sources.at(-1)!.grant, null, 'future skill assignment cannot award for the earlier revival payment');
await restored(f, game);
const event = game.decision!.event;
game = await act(f, game, lifecycle.actor, { type: 'leaderSkill', event, mode: 'draw' });
assert.ok(game.leaderSkills!.offers[lifecycle.actor].cards.includes('spice-banker'));
await restored(f, game);
const beforeSelection = game;
const select: Action = { type: 'leaderSkill', event, skill: 'spice-banker', leader: lifecycle.leader };
game = await act(f, game, lifecycle.actor, select);
assert.deepEqual(game.leaderSkills!.assignments.find(assignment => assignment.skill === 'spice-banker'),
{ owner: lifecycle.actor, leader: lifecycle.leader, skill: 'spice-banker' });
const skills = [...game.leaderSkills!.deck, ...Object.values(game.leaderSkills!.offers).flatMap(offer => offer.cards),
...game.leaderSkills!.assignments.map(assignment => assignment.skill)];
assert.deepEqual(skills.sort(), createLeaderSkills(() => 0.5).deck.sort(), 'all fourteen physical skills remain in one custodian');
assert.deepEqual(game.spiceBankerIncome!.sources[0], originalSource);
assert.deepEqual(game.spiceBankerIncome!.collections[0].credits, [{ owner: lifecycle.originalOwner, amount: 1 }]);
assert.equal(player(game, lifecycle.actor).spice, funds - price);
assert.equal(player(game, lifecycle.originalOwner).spice, originalFunds);
assert.deepEqual(viewGame(game, lifecycle.actor).spiceBankerIncome!.deferred, []);
await rejected(f, game, await authenticate(f, lifecycle.actor), select, beforeSelection.version);
await rejected(f, game, await authenticate(f, lifecycle.actor), select);
await Promise.all([f.restart().continueRoomAutomatic(f.code, clock), f.restart().continueRoomAutomatic(f.code, clock)]);
assert.deepEqual(await f.restart().readRoom(f.code), game);
await restored(f, game);
});
for (const kind of ['force-revival', 'leader-revival', 'kh-revival', 'emperor-extra-revival'] as const) {
void test(`SQLite actual paid ${kind} preserves native payer, revived beneficiary and allowance while retaining only qualifying bank income`, async t => {
const f = await fixture(t, { kind, advanced: true,
...(kind === 'force-revival' ? { payerFaction: 'emperor', emperor: true } : {}),
...(kind === 'kh-revival' ? { bankerFaction: 'harkonnen', payerFaction: 'atreides' } : {}) });
const before = f.beforePayment;
const payer = player(before, f.payer);
const beneficiary = kind === 'emperor-extra-revival' ? player(before, payer.ally!) : payer;
const trainer = player(before, f.owner).leaders.find(leader => leader.id === f.leader);
assert.ok(trainer && !trainer.dead && !trainer.capturedBy);
assert.notEqual(f.owner, payer.id, 'these are another real payer’s bank payment');
const paid = await settlePayment(f);
const revived = player(paid, beneficiary.id);
assert.equal(player(paid, payer.id).spice, payer.spice - f.amount);
assert.equal(player(paid, f.owner).spice, player(before, f.owner).spice);
if (kind === 'force-revival') {
assert.equal(payer.faction, 'emperor', 'native free-one revival leaves two paid forces');
assert.equal(f.amount, 4);
assert.equal(revived.reserves, beneficiary.reserves + 3);
assert.equal(revived.tanks, beneficiary.tanks - 3);
assert.equal(revived.revived, beneficiary.revived + 3);
assert.equal(revived.freeForcesRevived, (beneficiary.freeForcesRevived ?? 0) + 1);
} else if (kind === 'leader-revival') {
const target = beneficiary.leaders.find(leader => leader.id === f.paymentAction.leader);
assert.ok(target?.dead);
assert.equal(revived.leaders.find(leader => leader.id === target.id)!.dead, false);
assert.equal(revived.leaderRevived, true);
assert.equal(paid.decision?.kind, 'leaderSkillRevival');
} else if (kind === 'kh-revival') {
assert.equal(f.amount, 2, 'KH is its actual native two-spice price, never a fabricated four');
assert.equal(beneficiary.kwisatz?.dead, true);
assert.equal(revived.kwisatz?.dead, false);
assert.equal(revived.kwisatz?.revivalCycle, Math.max(revived.revivalCycle, beneficiary.kwisatz!.revivalCycle ?? 1) + 1);
assert.equal(revived.leaderRevived, true);
} else {
assert.notEqual(payer.id, beneficiary.id);
assert.equal(payer.faction, 'emperor');
assert.equal(revived.spice, beneficiary.spice, 'the revived ally does not pay the Emperor’s debit');
assert.equal(revived.reserves, beneficiary.reserves + 2);
assert.equal(revived.tanks, beneficiary.tanks - 2);
assert.equal(revived.revived, beneficiary.revived, 'extra revivals do not consume the normal allowance');
assert.equal(revived.freeForcesRevived, beneficiary.freeForcesRevived);
assert.equal(paid.emperorExtra[beneficiary.id], (before.emperorExtra[beneficiary.id] ?? 0) + 2);
}
const source = paid.spiceBankerIncome!.sources.at(-1);
assert.ok(source);
assert.equal(paid.spiceBankerIncome!.sources.length, before.spiceBankerIncome!.sources.length + 1);
assert.equal(source.source.kind, kind);
assert.equal(source.source.turn, before.turn);
assert.equal(source.source.phase, 4);
assert.deepEqual(source.source.bankLegs, [{ payer: payer.id, amount: f.amount }]);
assert.equal(source.source.trainer?.resolved, true, 'the source authority denotes committed native payment');
assert.deepEqual(viewGame(paid, f.owner).spiceBankerIncome!.deferred,
kind === 'kh-revival' ? [] : [{ owner: f.owner, amount: 1 }]);
await rejected(f, paid, await authenticate(f, f.actor), f.paymentAction, before.version);
await restored(f, paid);
});
}
for (const options of [
{ trainerSelected: true, amount: 4, expected: 1 },
{ trainerSelected: true, trainerDies: true, amount: 4, expected: 0 },
{ trainerHidden: true, amount: 4, expected: 0 },
{ amount: 3, expected: 0 },
]) {
void test(`SQLite resolved native support preserves payment and obeys trainer survival, concealment and threshold ${JSON.stringify(options)}`, async t => {
const { expected, ...native } = options;
const f = await fixture(t, { kind: 'battle-support', advanced: true, ...native });
const before = f.beforePayment;
assert.ok(before.battle?.revealed);
assert.equal(before.battle.plans[f.payer].support, options.amount);
assert.deepEqual(viewGame(before, f.owner).spiceBankerIncome!.deferred, []);
const paid = await settlePayment(f);
const trainer = player(paid, f.owner).leaders.find(leader => leader.id === f.leader);
assert.ok(trainer);
assert.equal(trainer.dead, 'trainerDies' in options && options.trainerDies);
assert.equal(paid.lastBattleContext?.event, before.battle.event);
assert.equal(paid.lastBattleContext?.result, 'normal');
const economics = quoteSpiceBankerIncomeBattleEconomics(before, paid);
const support = economics.resolution.payments.find(payment => payment.player === f.payer);
assert.ok(support);
assert.equal(support.ownPayment, options.amount, 'the original native support debit is not netted against income');
const bounty = economics.resolution.bounty;
assert.equal(bounty?.amount ?? 0, trainer.dead ? trainer.strength : 0);
if (bounty) assert.equal(bounty.player, f.payer, 'the winner earns the real killed-leader bounty');
for (const id of [f.payer, f.owner]) {
const debit = economics.resolution.payments.find(payment => payment.player === id)!.ownPayment;
const collection = economics.nativeCollection.find(receipt => receipt.player === id);
const nativeIncome = (bounty?.player === id ? bounty.amount : 0) +
(collection ? collection.strongholds + collection.collected : 0);
assert.equal(player(paid, id).spice, player(before, id).spice - debit + nativeIncome,
'original support, native bounty and actual Collection remain separate from deferred Banker income');
}
const source = paid.spiceBankerIncome!.sources.at(-1);
assert.ok(source);
assert.equal(source.source.kind, 'battle-support');
assert.deepEqual(source.source.bankLegs, [{ payer: f.payer, amount: options.amount }]);
if (trainer.dead) assert.equal(source.source.trainer, null);
else {
assert.equal(source.source.trainer?.resolved, true);
assert.equal(source.source.trainer?.selected, 'trainerSelected' in options && options.trainerSelected);
assert.equal(source.source.trainer?.faceUp, !('trainerSelected' in options || 'trainerHidden' in options));
}
assert.equal(source.grant?.amount ?? 0, expected);
assert.deepEqual(viewGame(paid, f.owner).spiceBankerIncome!.deferred,
expected ? [{ owner: f.owner, amount: 1 }] : []);
await rejected(f, paid, await authenticate(f, f.actor), f.paymentAction, before.version);
await restored(f, paid);
});
}
void test('SQLite Emperor self-purchase actually pays the Bank, retains its original card and auction counter, and collects deferred income at native Mentat once', async t => {
const f = await fixture(t, { emperor: true, payerFaction: 'emperor' });
const before = f.beforePayment;
const emperor = player(before, f.payer);
assert.equal(emperor.faction, 'emperor');
assert.notEqual(emperor.id, f.owner);
assert.ok(before.auction);
const card = before.auction.cards[before.auction.index];
const paid = await settlePayment(f);
assert.equal(player(paid, emperor.id).spice, emperor.spice - 4, 'self purchase is a real bank debit, not self-recipient income');
assert.equal(player(paid, emperor.id).hand.filter(held => held.id === card.id).length, 1);
assert.equal(paid.auction?.index, before.auction.index + 1);
assert.equal(player(paid, f.owner).spice, player(before, f.owner).spice);
const receipt = paid.spiceBankerIncome!.sources.at(-1);
assert.ok(receipt);
assert.deepEqual(receipt.source.bankLegs, [{ payer: emperor.id, amount: 4 }]);
assert.deepEqual(viewGame(paid, f.owner).spiceBankerIncome!.deferred, [{ owner: f.owner, amount: 1 }]);
await restored(f, paid);
const final = await finalCollectionStep(f, paid);
const funds = player(final.game, f.owner).spice;
const collected = await act(f, final.game, final.step.actor, final.step.action);
assert.equal(collected.phase, 8);
assert.equal(player(collected, f.owner).spice, funds + 1);
assert.deepEqual(collected.spiceBankerIncome!.collections.at(-1)!.credits, [{ owner: f.owner, amount: 1 }]);
assert.deepEqual(viewGame(collected, f.owner).spiceBankerIncome!.deferred, []);
await Promise.all([f.restart().continueRoomAutomatic(f.code, clock), f.restart().continueRoomAutomatic(f.code, clock)]);
assert.deepEqual(await f.restart().readRoom(f.code), collected);
await rejected(f, collected, await authenticate(f, final.step.actor), final.step.action, final.game.version);
await restored(f, collected);
});