From b750a3d3eb253dbb402425ee6b33dc5ba891b3a4 Mon Sep 17 00:00:00 2001
From: Quintine <15965533+Quintine@users.noreply.github.com>
Date: Tue, 27 Oct 2026 22:05:43 +1100
Subject: [PATCH] Expose Advanced printed Kull preview in lobbies
---
components/game-table.tsx | 23 ++--
components/ruleset-controls.tsx | 2 +-
docs/ADVANCED_PREVIEW.md | 4 +
docs/CHOAM_KULL_DESIGN.md | 17 +++
docs/CURRENT_STATUS.md | 8 ++
docs/IMPLEMENTATION_STATUS.md | 9 ++
game/engine.ts | 8 +-
game/faction-reference.ts | 2 +-
game/kull-advanced-profile.ts | 34 ++++++
game/reference.ts | 2 +-
tests/advanced-kull-lobby-controls.test.tsx | 87 ++++++++++++++++
tests/advanced-kull-lobby-runtime.test.ts | 110 ++++++++++++++++++++
tests/advanced-preview-controls.test.ts | 2 +-
tests/fixture-advanced-kull-lobby.ts | 57 ++++++++++
tests/kull-advanced-profile.test.ts | 67 ++++++++++++
tests/public-choam-kull-controls.test.tsx | 8 +-
tests/public-choam-kull-runtime.test.ts | 2 +-
17 files changed, 422 insertions(+), 20 deletions(-)
create mode 100644 game/kull-advanced-profile.ts
create mode 100644 tests/advanced-kull-lobby-controls.test.tsx
create mode 100644 tests/advanced-kull-lobby-runtime.test.ts
create mode 100644 tests/fixture-advanced-kull-lobby.ts
create mode 100644 tests/kull-advanced-profile.test.ts
diff --git a/components/game-table.tsx b/components/game-table.tsx
index b4206ab5..52319719 100644
--- a/components/game-table.tsx
+++ b/components/game-table.tsx
@@ -1360,6 +1360,7 @@ export function GameTable({
Kull Wahad development preview · provisional interception timing, not
complete CHOAM or certified expansion rules.{' '}
+ {g.advanced && 'Advanced Kull prevents the attempted specific Karama effect; its phase duration is provisional. '}
Preview rules and limits
)}
@@ -2207,15 +2208,21 @@ export function GameTable({
- Requires Basic CHOAM with the CHOAM and Ix decks plus each faction’s deck, and no other optional modules.
- This preview does not support phase-wide bid or combined turn-action Truthtrance questions, and it defers
- unfunded non-CHOAM Karama-dependent bids. It does not represent complete
- CHOAM rules. Every player must ready again after changing it.
- When Richese is seated, structured bid, alliance, Revival and bribe commitments are unavailable,
- and some Kull reactions may be unavailable in complex response windows.
+ {g.advanced ? <>
+ Requires Advanced CHOAM with only classic factions, the CHOAM and Ix decks, and no other optional modules.
+ This preview prevents the attempted specific Karama effect; phase duration is provisional.
+ Structured bid, alliance, Revival, bribe and combined turn-action questions are unavailable.
+ : <>
+ Requires Basic CHOAM with the CHOAM and Ix decks plus each faction’s deck, and no other optional modules.
+ Phase-wide bid and combined turn-action Truthtrance questions are unavailable.
+ When Richese is seated, structured bid, alliance, Revival and bribe commitments are also unavailable,
+ and some Kull reactions may be unavailable in complex response windows.
+ }{' '}
+ Unfunded non-CHOAM Karama-dependent bids remain deferred. This does not represent complete CHOAM rules.
+ Every player must ready again after changing it.
}
{g.lobbyModules?.kullDefault &&
{g.lobbyModules.kullPreview
@@ -2225,7 +2232,7 @@ export function GameTable({
{!g.lobbyModules?.kullDefault && !g.lobbyModules?.kullPreview &&
g.expansions.includes('choam') && g.expansions.includes('ix') &&
g.players.some(player => player.faction === 'choam') &&
- Printed Kull is inactive in this lobby. Its preview requires the supported Basic configuration and may need different module selections.
+ Printed Kull is inactive in this lobby. Its preview requires a supported {g.advanced ? 'Advanced' : 'Basic'} configuration and may need different module selections.
}
]*>(?:(?!<\/label>)[\s\S])*Kull Wahad(?:(?!<\/label>)[\s\S])*<\/label>/)?.[0];
+ assert.ok(label, 'The Kull preview choice is present in the lobby');
+ return label;
+}
+
+void test('Advanced Kull is off until the host selects the preview and displays its scope and limits', () => {
+ const fresh = lobby(), host = viewGame(fresh, 'choam');
+ assert.equal(host.lobbyModules?.kullPreview, false);
+ assert.equal(host.lobbyModules?.kullDefault, false);
+ const unchecked = table(host);
+ assert.match(kullLabel(unchecked), /type="checkbox"/);
+ assert.match(unchecked, /Kull Wahad ·/);
+ assert.match(unchecked, /Advanced.*development preview/);
+ assert.doesNotMatch(kullLabel(unchecked), /\bchecked=/);
+ assert.doesNotMatch(kullLabel(unchecked), /\bdisabled=/);
+ assert.match(unchecked, /Printed Kull is inactive in this lobby/);
+
+ const selected = applyAction(fresh, 'choam', { type: 'moduleOption', module: 'kullPreview', enabled: true });
+ const selectedView = viewGame(selected, 'choam'), selectedHtml = table(selectedView);
+ assert.equal(selectedView.lobbyModules?.kullPreview, true);
+ assert.match(kullLabel(selectedHtml), /\bchecked=/);
+ assert.match(selectedHtml, /Requires Advanced CHOAM with only classic factions/);
+ assert.match(selectedHtml, /prevents the attempted specific Karama effect/);
+ assert.match(selectedHtml, /phase duration is provisional/);
+ assert.match(selectedHtml, /Structured bid, alliance, Revival, bribe and combined turn-action questions are unavailable/);
+ assert.match(selectedHtml, /Unfunded non-CHOAM Karama-dependent bids remain deferred/);
+ assert.doesNotMatch(selectedHtml, /Printed Kull is inactive in this lobby/);
+});
+
+void test('only the host can change the actual Advanced Kull checkbox', () => {
+ const selected = applyAction(lobby(), 'choam', { type: 'moduleOption', module: 'kullPreview', enabled: true });
+ const host = kullLabel(table(viewGame(selected, 'choam')));
+ const guest = kullLabel(table(viewGame(selected, 'emperor')));
+ assert.doesNotMatch(host, /\bdisabled=/);
+ assert.match(guest, /\bdisabled=/);
+ assert.match(kullLabel(table(viewGame(selected, 'choam'), true)), /\bdisabled=/);
+ assert.throws(() => applyAction(selected, 'emperor', { type: 'moduleOption', module: 'kullPreview', enabled: false }));
+});
+
+void test('a real Advanced Kull start retains both the Advanced and Kull preview notices', () => {
+ let game = applyAction(lobby(), 'choam', { type: 'moduleOption', module: 'kullPreview', enabled: true });
+ for (const seat of game.players) game = applyAction(game, seat.id, { type: 'ready' });
+ game = applyAction(game, 'choam', { type: 'start', advancedPreview: true });
+ assert.equal(game.status, 'setup');
+ assert.equal(game.kullPreview, true);
+ for (const actor of ['choam', 'emperor']) {
+ const html = table(viewGame(game, actor));
+ assert.match(html, /Advanced preview/);
+ assert.match(html, /Rules and card interactions are still/);
+ assert.match(html, /Kull Wahad development preview/);
+ assert.match(html, /provisional interception timing/);
+ assert.match(html, /not\s+complete CHOAM or certified expansion rules/);
+ }
+});
diff --git a/tests/advanced-kull-lobby-runtime.test.ts b/tests/advanced-kull-lobby-runtime.test.ts
new file mode 100644
index 00000000..8b75e397
--- /dev/null
+++ b/tests/advanced-kull-lobby-runtime.test.ts
@@ -0,0 +1,110 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createGame, joinGame, newPlayer, viewGame, type Action, type Game } from '../game/engine';
+import { botActions } from '../game/bots';
+import { act, advance, clean, player, inventory, createAdvancedKullLobbyFixture as fixture,
+ advancedKullAttempt as attempt } from './fixture-advanced-kull-lobby';
+
+function rejected(game: Game, actor: string, action: Action) {
+ const before = structuredClone(game);
+ assert.throws(() => act(game, actor, action));
+ assert.deepEqual(game, before);
+}
+function ready(game: Game): Game {
+ for (const seat of game.players) game = act(game, seat.id, { type: 'ready' });
+ return game;
+}
+function lobby(roster: readonly ('atreides' | 'beneGesserit' | 'emperor' | 'fremen' | 'guild' | 'harkonnen')[],
+ advanced = true, expansions = ['choam', 'ix']): Game {
+ const game = createGame('ADVKULL', newPlayer('choam', 'CHOAM', 'choam'), advanced, expansions);
+ for (const faction of roster) joinGame(game, newPlayer(faction, faction, faction));
+ return game;
+}
+
+void test('a normal Advanced lobby requires the explicit host selection and preview-start acknowledgement', () => {
+ let game = lobby(['emperor', 'guild']);
+ assert.equal(viewGame(game, 'choam').lobbyModules?.kullPreview, false);
+ rejected(game, 'emperor', { type: 'moduleOption', module: 'kullPreview', enabled: true });
+ game = act(game, 'choam', { type: 'moduleOption', module: 'kullPreview', enabled: true });
+ assert.equal(viewGame(game, 'choam').lobbyModules?.kullPreview, true);
+ game = ready(game);
+ rejected(game, 'choam', { type: 'start' });
+ const started = act(game, 'choam', { type: 'start', advancedPreview: true });
+ assert.equal(started.status, 'setup');
+ assert.equal(started.advanced, true);
+ assert.equal(started.kullPreview, true);
+ assert.equal(viewGame(started, 'choam').kullPreview, true);
+ assert.equal(started.deck.filter(card => card.id === 'ix-kull-wahad').length, 1);
+});
+
+for (const seats of [2, 3, 4, 5, 6] as const) {
+ void test(`Advanced Kull public preview starts its native CHOAM and ${seats - 1} classic-seat roster`, () => {
+ const others = ['atreides', 'beneGesserit', 'emperor', 'fremen', 'guild'] as const;
+ let game = lobby(others.slice(0, seats - 1));
+ game = act(game, 'choam', { type: 'moduleOption', module: 'kullPreview', enabled: true });
+ game = act(ready(game), 'choam', { type: 'start', advancedPreview: true });
+ assert.equal(game.status, 'setup');
+ assert.equal(game.players.length, seats);
+ assert.equal(game.kullPreview, true);
+ assert.equal(game.deck.filter(card => card.id === 'ix-kull-wahad').length, 1);
+ });
+}
+
+void test('unselected and saved pre-selection Advanced lobbies do not acquire Kull automatically', () => {
+ for (const old of [false, true]) {
+ const game = lobby(['emperor']);
+ if (old) delete game.kullDefaultPolicy;
+ const started = act(ready(game), 'choam', { type: 'start', advancedPreview: true });
+ assert.equal(started.kullPreview ?? false, false);
+ assert.equal(viewGame(started, 'choam').kullPreview, false);
+ }
+});
+
+void test('Advanced Kull selection rejects unsupported decks, native factions and modules atomically', () => {
+ for (const kind of ['missingIx', 'richese', 'nexus', 'skills'] as const) {
+ let game = lobby(['emperor'], true, kind === 'missingIx' ? ['choam'] : ['choam', 'ix']);
+ if (kind === 'richese') joinGame(game, newPlayer('richese', 'Richese', 'richese'));
+ if (kind === 'nexus') game = act(game, 'choam', { type: 'moduleOption', module: 'nexusCards', enabled: true });
+ if (kind === 'skills') game = act(game, 'choam', { type: 'moduleOption', module: 'leaderSkills', enabled: true });
+ game = act(game, 'choam', { type: 'moduleOption', module: 'kullPreview', enabled: true });
+ game = ready(game);
+ rejected(game, 'choam', { type: 'start', advancedPreview: true });
+ }
+});
+
+void test('normal Advanced Kull preview uses the real held card and distinct counter at the original attempt', () => {
+ const f = fixture();
+ assert.ok(f.actions.some(row => row.actor === f.reactor && row.action.type === 'start' && row.action.advancedPreview === true));
+ const pending = act(f.game, f.actor, attempt(f));
+ assert.equal(pending.pendingKull?.stage, 'offer');
+ assert.ok(player(pending, f.actor).hand.some(card => card.id === f.karama));
+ const reaction = viewGame(pending, f.reactor).kullReaction; assert.ok(reaction);
+ assert.equal(reaction.scope, 'effect');
+ assert.ok(reaction.plays.some(play => play.source === 'printed' && play.card.id === f.kull && !play.blocked));
+ assert.deepEqual(viewGame(pending, f.actor).kullReaction?.plays, []);
+ assert.deepEqual(inventory(pending), f.originalCards);
+
+ const bot = viewGame(pending, f.reactor); bot.players.find(seat => seat.id === f.reactor)!.bot = 'Easy';
+ const botAction = botActions(bot).find(action => action.type === 'kullDecision'); assert.ok(botAction);
+ assert.doesNotThrow(() => act(structuredClone(pending), f.reactor, botAction));
+
+ const declared = act(pending, f.reactor, { type: 'kullDecision', event: reaction.event, source: 'printed', card: f.kull });
+ assert.equal(declared.pendingKull?.stage, 'counter');
+ assert.ok(viewGame(declared, f.counterOwner).responseControls?.cancelCards.includes(f.counter));
+ const countered = act(declared, f.counterOwner, { type: 'card', mode: 'cancel', card: f.counter });
+ const resumed = advance(countered, clean);
+ assert.equal(resumed.karamaShipping?.owner, f.actor);
+ assert.equal(resumed.discard.filter(card => card.id === f.karama).length, 1);
+ assert.equal(resumed.discard.filter(card => card.id === f.counter).length, 1);
+ assert.ok(player(resumed, f.reactor).hand.some(card => card.id === f.kull));
+ assert.deepEqual(inventory(resumed), f.originalCards);
+
+ const successful = advance(declared, clean);
+ assert.equal(successful.karamaShipping, null);
+ assert.ok(player(successful, f.actor).hand.some(card => card.id === f.karama));
+ assert.equal(successful.discard.filter(card => card.id === f.kull).length, 1);
+ assert.equal(viewGame(successful, f.actor).karamaBlocked, null);
+ assert.equal(viewGame(successful, f.actor).karamaPurposeBlocks[0]?.purpose, 'shipment-price');
+ rejected(successful, f.actor, attempt(f));
+ assert.deepEqual(inventory(successful), f.originalCards);
+});
diff --git a/tests/advanced-preview-controls.test.ts b/tests/advanced-preview-controls.test.ts
index 073a1cba..b9083f6d 100644
--- a/tests/advanced-preview-controls.test.ts
+++ b/tests/advanced-preview-controls.test.ts
@@ -22,7 +22,7 @@ void test('rules controls identify the unfinished selection before readiness and
const preview = render(true, true);
assert.match(preview, /value="advanced" selected=""/);
assert.match(preview, /Rules and card interactions are still/);
- assert.match(preview, /six classic factions/);
+ assert.match(preview, /Classic and supported expansion selections are unfinished previews/);
assert.match(preview, /Changing rules clears player readiness/);
assert.match(preview, /Switching to Basic removes Stronghold Cards/);
assert.match(render(true, false), / { game = act(game, actor, action, actions); };
+ const reach = (until: (g: Game) => boolean) => { game = advance(game, until, actions); };
+ send('choam', { type: 'moduleOption', module: 'kullPreview', enabled: true });
+ for (const seat of game.players) send(seat.id, { type: 'ready' });
+ const lobby = structuredClone(game);
+ send('choam', { type: 'start', advancedPreview: true });
+ const setup = structuredClone(game);
+ assert.equal(game.status, 'setup');
+ assert.equal(game.advanced, true);
+ assert.equal(game.kullPreview, true);
+ assert.ok(game.players.every(seat => seat.hand.length === 0));
+ const originalCards = game.deck.map(card => card.id).sort();
+ const selected: Game['deck'] = [];
+ for (const kind of ['kull', 'karama', 'karama'] as const) {
+ const index = game.deck.findIndex(card => kind === 'kull' ? card.id === 'ix-kull-wahad' : card.effect === 'karama');
+ assert.ok(index >= 0); selected.push(game.deck.splice(index, 1)[0]);
+ }
+ game.deck.unshift(...selected);
+ const beforeDeal = structuredClone(game);
+ reach(state => state.status === 'playing');
+ const afterSetup = structuredClone(game);
+ const [kull, karama, counter] = selected.map(card => card.id);
+ for (const [seat, card] of [['choam', kull], ['emperor', karama], ['guild', counter]] as const)
+ assert.ok(player(game, seat).hand.some(held => held.id === card));
+ assert.deepEqual(inventory(game), originalCards);
+ const safe: Game['spiceDeck'] = [];
+ for (let i = 0; i < 2; i++) {
+ const index = game.spiceDeck.findIndex(card => 'territory' in card && !card.discovery);
+ assert.ok(index >= 0); safe.push(game.spiceDeck.splice(index, 1)[0]);
+ }
+ game.spiceDeck.unshift(...safe);
+ reach(state => state.phase === 5 && state.active === 'choam' && clean(state));
+ send('choam', { type: 'endMovement' });
+ reach(state => state.phase === 5 && state.active === 'emperor' && clean(state));
+ assert.deepEqual(inventory(game), originalCards);
+ return { game, lobby, setup, beforeDeal, afterSetup, actions, originalCards,
+ kull, karama, counter, actor: 'emperor', reactor: 'choam', counterOwner: 'guild' };
+}
+
+export type AdvancedKullLobbyFixture = ReturnType;
+export const advancedKullAttempt = (f: AdvancedKullLobbyFixture): Action =>
+ ({ type: 'card', mode: 'shipment', card: f.karama, target: f.actor });
diff --git a/tests/kull-advanced-profile.test.ts b/tests/kull-advanced-profile.test.ts
new file mode 100644
index 00000000..5c7e8986
--- /dev/null
+++ b/tests/kull-advanced-profile.test.ts
@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { advancedKullLobbyEligible, advancedKullLobbyProfile } from '../game/kull-advanced-profile';
+import { kullDefaultEligible, type KullDefaultProfile } from '../game/kull-default-profile';
+
+const lobby: KullDefaultProfile = {
+ status: 'lobby', advanced: true, expansions: ['choam', 'ix'],
+ players: [{ faction: 'choam' }, { faction: 'atreides' }],
+};
+
+void test('Advanced printed Kull supports native CHOAM plus classic factions with the selected decks', () => {
+ assert.deepEqual(advancedKullLobbyProfile(lobby), { eligible: true, reason: null });
+ assert.equal(advancedKullLobbyEligible({ ...lobby, players: [{ faction: 'choam' }] }), true,
+ 'The host can see the preview before another seat joins; the start checks its minimum.');
+ for (const faction of ['atreides', 'beneGesserit', 'emperor', 'fremen', 'guild', 'harkonnen'])
+ assert.equal(advancedKullLobbyEligible({ ...lobby, players: [{ faction: 'choam' }, { faction }] }), true, faction);
+ assert.equal(advancedKullLobbyEligible({ ...lobby, expansions: ['ix', 'choam'] }), true);
+});
+
+void test('Advanced profile excludes ongoing games, wrong rules, unsupported decks and native expansion seats', () => {
+ for (const profile of [
+ { ...lobby, status: 'playing' }, { ...lobby, status: 'setup' }, { ...lobby, advanced: false },
+ { ...lobby, players: [{ faction: 'emperor' }, { faction: 'guild' }] },
+ { ...lobby, expansions: ['choam'] }, { ...lobby, expansions: ['ix'] },
+ { ...lobby, expansions: ['choam', 'ix', 'ecaz'] }, { ...lobby, expansions: ['choam', 'choam'] },
+ { ...lobby, players: [] }, { ...lobby, players: [{ faction: 'choam' }, { faction: 'choam' }] },
+ ...['richese', 'ixians', 'tleilaxu', 'ecaz', 'moritani', 'unknown'].map(faction =>
+ ({ ...lobby, players: [{ faction: 'choam' }, { faction }] })),
+ { ...lobby, players: ['choam', 'atreides', 'beneGesserit', 'emperor', 'fremen', 'guild', 'harkonnen']
+ .map(faction => ({ faction })) },
+ ]) {
+ const result = advancedKullLobbyProfile(profile);
+ assert.equal(result.eligible, false); assert.ok(result.reason);
+ }
+});
+
+void test('Advanced lobby profile excludes all optional modules on source and public projection', () => {
+ for (const option of [
+ { lobbyOptions: { leaderSkills: true } }, { lobbyOptions: { ecazTreachery: true } },
+ { lobbyModules: { leaderSkills: true } }, { lobbyModules: { ecazTreachery: true } },
+ { lobbyModules: { nexusCards: true } }, { lobbyModules: { discoveries: true } },
+ { leaderSkills: {} }, { ecazTreachery: true }, { nexusCards: {} }, { discoveryEnabled: true },
+ { discoveries: {} }, { discoveryStash: {} }, { greatMaker: {} },
+ { homeworlds: {} }, { techTokens: {} }, { strongholdCards: {} },
+ ]) assert.equal(advancedKullLobbyEligible({ ...lobby, ...option }), false);
+ assert.equal(advancedKullLobbyEligible({ ...lobby,
+ lobbyModules: { leaderSkills: false, ecazTreachery: false, nexusCards: false, discoveries: false },
+ lobbyOptions: { leaderSkills: false, ecazTreachery: false } }), true);
+});
+
+void test('Advanced eligibility does not alter Basic eligibility or depend on a host opt-out', () => {
+ const basic = { ...lobby, advanced: false };
+ const selection = { leaderSkills: false, kullOptOut: true };
+ assert.equal(kullDefaultEligible(basic), true);
+ assert.equal(advancedKullLobbyEligible(basic), false);
+ assert.equal(advancedKullLobbyEligible({ ...lobby, lobbyOptions: selection }), true);
+});
+
+void test('Advanced eligibility reads only public faction/configuration and never private hands or spice', () => {
+ const choam = { faction: 'choam', get hand() { throw Error('private hand read'); },
+ get spice() { throw Error('private spice read'); } };
+ const rival = { faction: 'beneGesserit', get hand() { throw Error('private rival hand read'); } };
+ const game = { ...lobby, players: [choam, rival] };
+ assert.equal(advancedKullLobbyEligible(game), true);
+ assert.deepEqual(game.expansions, ['choam', 'ix']);
+ assert.equal(game.status, 'lobby');
+});
diff --git a/tests/public-choam-kull-controls.test.tsx b/tests/public-choam-kull-controls.test.tsx
index 6933557f..56dd33c3 100644
--- a/tests/public-choam-kull-controls.test.tsx
+++ b/tests/public-choam-kull-controls.test.tsx
@@ -31,15 +31,15 @@ void test('public host lobby shows the explicitly selected Kull preview and its
assert.equal(host.lobbyModules?.kullPreview,true);
assert.match(html,/Kull Wahad · Basic development preview/);
assert.match(html,/Printed Kull is enabled by default/);
- assert.match(html,/does not support phase-wide bid or combined turn-action Truthtrance questions/);
- assert.match(html,/defers unfunded non-CHOAM Karama-dependent bids/);
- assert.match(html,/When Richese is seated, structured bid, alliance, Revival and bribe commitments are unavailable/);
+ assert.match(html,/Phase-wide bid and combined turn-action Truthtrance questions are unavailable/);
+ assert.match(html,/Unfunded non-CHOAM Karama-dependent bids remain deferred/);
+ assert.match(html,/When Richese is seated, structured bid, alliance, Revival and bribe commitments are also unavailable/);
const off = act(f.lobby,f.lobby.host,{type:'moduleOption',module:'kullPreview',enabled:false});
const unselected = viewGame(off,off.host);
assert.equal(unselected.lobbyModules?.kullPreview,false);
assert.match(table(unselected),/Kull Wahad · Basic development preview/);
assert.match(table(unselected),/The host has turned off the printed Kull preview/);
- assert.doesNotMatch(table(unselected),/does not support phase-wide bid or combined turn-action Truthtrance questions/);
+ assert.doesNotMatch(table(unselected),/Phase-wide bid and combined turn-action Truthtrance questions are unavailable/);
const nonhost = table(viewGame(f.lobby,f.actor));
assert.match(nonhost,/disabled=""[^>]*type="checkbox"|type="checkbox"[^>]*disabled=""/);
});
diff --git a/tests/public-choam-kull-runtime.test.ts b/tests/public-choam-kull-runtime.test.ts
index b60128c3..0d5f5d77 100644
--- a/tests/public-choam-kull-runtime.test.ts
+++ b/tests/public-choam-kull-runtime.test.ts
@@ -51,7 +51,7 @@ void test('Kull is a host-configurable Basic lobby preview with supported Truth
void test('incompatible opt-in starts reject without modifying their original lobby', () => {
for (const config of [
- {advanced:true,expansions:['choam','ix'],last:'guild' as const,module:false},
+ {advanced:true,expansions:['choam','ix'],last:'guild' as const,module:true},
{advanced:false,expansions:['choam'],last:'guild' as const,module:false},
{advanced:false,expansions:['choam','ix'],last:'guild' as const,module:true},
]) {