WIP (no PR): story layer + fromDuel adapter on duel-core contracts; PR follows #72 merge

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 00:42:44 -05:00
co-authored by Claude Opus 5.5
parent 79041990ed
commit 94966277ef
9 changed files with 1241 additions and 0 deletions
+117
View File
@@ -0,0 +1,117 @@
/**
* Adapter: duel-core's LogEvent[] (shared/duel/types.ts) → story MatchRecord (DUEL_DESIGN §8).
* Pure. Pass the omniscient `state.log` for recaps, or `logFor(state, seat)` output for a seat's log
* (hidden draws there have no `card`, and stay hidden).
*/
import type { CardInstance, CardRef, LogEvent } from '../types.ts';
import type { MatchRecord, Seat, StoryCard, StoryEvent, StoryPlayer } from './types.ts';
export interface FromDuelInput {
matchId: string;
/** Story seed, opaque: the host derives it (sha256(engineSeed + ':story')). Never the engine seed. */
storySeed: string;
/** ISO YYYY-MM-DD. */
date: string;
players: [StoryPlayer, StoryPlayer];
/** Every card instance of both decks (tokens are picked up from the log). */
instances: CardInstance[];
log: LogEvent[];
startingLife?: number;
hostName?: string;
ratingChange?: [number, number];
}
function storyCard(inst: CardInstance): StoryCard {
const c = inst.card;
return {
id: inst.uid, title: c.title, description: c.description, type: c.type, cost: c.cost, portal: c.portal,
revisionId: c.token ? undefined : c.revisionId, tokenId: c.token ? undefined : c.cardId, owner: inst.owner,
token: c.token || undefined,
};
}
export function fromDuel(input: FromDuelInput): MatchRecord {
const cards: Record<string, StoryCard> = {};
for (const inst of input.instances) cards[inst.uid] = storyCard(inst);
/** Tokens (and anything not in the decks) come from their log CardRef: never cited. */
const ref = (r: CardRef, owner: Seat): string => {
if (!cards[r.uid]) cards[r.uid] = { id: r.uid, title: r.title, type: r.type, cost: 0, owner, token: true };
return r.uid;
};
const events: StoryEvent[] = [];
let lastTurn = 0;
for (const e of input.log) {
switch (e.kind) {
case 'turnStart':
lastTurn = e.turn;
events.push({ kind: 'turnStart', turn: e.turn, seat: e.seat });
break;
case 'draw':
events.push(e.card ? { kind: 'draw', seat: e.seat, card: ref(e.card, e.seat) } : { kind: 'draw', seat: e.seat });
break;
case 'deploy':
events.push({ kind: 'deploy', seat: e.seat, card: ref(e.card, e.seat) });
break;
case 'cast':
events.push({ kind: 'cast', seat: e.seat, card: ref(e.card, e.seat) });
break;
case 'adopt':
events.push({
kind: 'adopt', seat: e.seat, doctrine: ref(e.card, e.seat), figure: ref(e.to, e.seat),
power: e.to.power ?? 0, toughness: e.to.toughness ?? 0,
});
break;
case 'tokenCreated': {
const prev = events[events.length - 1];
const src = ref(e.source, e.seat);
ref(e.card, e.seat);
if (prev && prev.kind === 'tokenCreated' && prev.source === src && prev.token === e.card.title) prev.count += 1;
else events.push({ kind: 'tokenCreated', seat: e.seat, source: src, token: e.card.title, count: 1 });
break;
}
case 'connected':
events.push({ kind: 'connected', seat: e.seat, a: ref(e.card, e.seat), b: ref(e.with, e.seat), reason: e.via });
break;
case 'rivalry':
events.push({ kind: 'rivalry', a: ref(e.card, 0), b: ref(e.with, 1), reason: e.via });
break;
case 'attack':
for (const a of e.attackers) events.push({ kind: 'attack', seat: e.seat, card: ref(a, e.seat), power: a.power ?? 0, toughness: a.toughness ?? 0 });
break;
case 'block':
for (const b of e.blocks) {
events.push({
kind: 'block', seat: e.seat, blocker: ref(b.blocker, e.seat), attacker: ref(b.attacker, e.seat === 0 ? 1 : 0),
power: b.blocker.power ?? 0, toughness: b.blocker.toughness ?? 0,
});
}
break;
case 'lifeGain':
events.push({ kind: 'lifeGain', seat: e.seat, source: ref(e.source, e.seat), amount: e.amount, life: e.life });
break;
case 'effectDamage':
events.push({ kind: 'effectDamage', source: ref(e.source, 0), target: ref(e.target, 0), amount: e.amount });
break;
case 'playerDamage':
events.push({ kind: 'playerDamage', seat: e.seat, source: e.source ? ref(e.source, e.seat === 0 ? 1 : 0) : undefined, amount: e.amount, life: e.life });
break;
case 'destroyed':
events.push({ kind: 'destroyed', card: ref(e.card, e.owner) });
break;
case 'discard':
events.push({ kind: 'discard', seat: e.seat, card: ref(e.card, e.seat) });
break;
case 'gameOver':
events.push({ kind: 'gameOver', winner: e.winner, reason: e.reason, turn: e.turn || lastTurn, life: e.life });
break;
// start, mulligan, keep, effect, combatDamage, bounced, fatigue, concede, timeout:
// not narrated in v1 (combat outcomes are told by destroyed/playerDamage; gameOver covers concede/timeout).
default:
break;
}
}
return {
matchId: input.matchId, seed: input.storySeed, date: input.date, players: input.players, cards, events,
startingLife: input.startingLife, hostName: input.hostName, ratingChange: input.ratingChange,
};
}
+6
View File
@@ -0,0 +1,6 @@
/** Story layer for the duel (DUEL_DESIGN.md §8): match log and battle recap templates. */
export * from './types.ts';
export { LOG_TEMPLATES, BANNED_WORDS, FOOTER, fill, numberWord, ordinalWord } from './templates.ts';
export { Narrator, renderEvent, renderLog, logParagraphs, gloss, articleUrl, variantIndex, tokenName } from './log.ts';
export { recap, battleName, battleTitle, longDate } from './recap.ts';
export type { RecapDoc, RecapInfobox, RecapSection } from './recap.ts';
+196
View File
@@ -0,0 +1,196 @@
/**
* Deterministic match log (DUEL_DESIGN.md §8.2). Pure: the same MatchRecord always gives the
* same lines, so `replay` and stored records regenerate the log exactly. No network, no clock.
*/
import { Rng } from '../../game/rng.ts';
import { LOG_TEMPLATES, fill, numberWord, type TemplateKey } from './templates.ts';
import type { LogLine, MatchRecord, Reference, Seat, StoryCard, StoryEvent } from './types.ts';
/** Deterministic variant choice: one fresh mulberry32 per (seed, salt, event index). */
export function variantIndex(seed: number | string, salt: string, index: number, n: number): number {
return Rng.fromSeed(`${seed}|${salt}|${index}`).int(n);
}
/** "American actor (1909–1994)" → "American actor, 1909–1994". Verbatim otherwise. */
export function gloss(description: string | undefined): string {
const d = (description ?? '').trim();
if (!d) return '';
const m = /^(.*\S)\s*\(([^()]+)\)$/.exec(d);
return m ? `${m[1]}, ${m[2]}` : d;
}
export function articleUrl(title: string, revisionId: number): string {
return `https://en.wikipedia.org/w/index.php?title=${encodeURIComponent(title.replace(/ /g, '_'))}&oldid=${revisionId}`;
}
/**
* Tracks first mentions and reference numbers for one rendering (a log view or a recap).
* The first mention of a card in a rendering adds its description and the next [n].
*/
export class Narrator {
readonly record: MatchRecord;
readonly salt: string;
readonly references: Reference[] = [];
private refByCard = new Map<string, number>();
private pending: number[] = [];
constructor(record: MatchRecord, salt: string) {
this.record = record;
this.salt = salt;
}
card(id: string): StoryCard {
const c = this.record.cards[id];
if (!c) throw new Error(`story: unknown card id ${id}`);
return c;
}
player(seat: Seat): string { return this.record.players[seat].name; }
/** Assigns a reference number without mentioning the card (e.g. for the References list). Tokens get none (0). */
cite(id: string): number {
let n = this.refByCard.get(id);
if (n === undefined) {
const c = this.card(id);
if (c.token || c.revisionId === undefined) return 0;
n = this.references.length + 1;
this.refByCard.set(id, n);
this.references.push({
n, cardId: id, title: c.title, revisionId: c.revisionId, tokenId: c.tokenId,
url: articleUrl(c.title, c.revisionId),
text: `"${c.title}". Wikipedia. Revision ${c.revisionId}.${c.tokenId ? ` Minted as token ${c.tokenId}.` : ''}`,
});
}
return n;
}
/** A card's name for a sentence: italic, with its description on first mention. */
mention(id: string): string {
const c = this.card(id);
if (c.token || c.revisionId === undefined) return c.title;
const first = !this.refByCard.has(id);
const n = this.cite(id);
if (!first) return `*${c.title}*`;
this.pending.push(n);
const g = gloss(c.description);
return g ? `*${c.title}* (${g})` : `*${c.title}*`;
}
/** Take the citations of first mentions made since the last sentence. */
flush(): number[] {
const refs = this.pending;
this.pending = [];
return refs;
}
/** Fill a variant of `key` and append the citations of first mentions made while filling. */
sentence(key: TemplateKey, index: number, values: Record<string, () => string | number>, must: string[] = []): { text: string; refs: number[] } {
const fits = (t: string) => [...t.matchAll(/\{(\w+)\}/g)].every(m => m[1] in values);
const all = LOG_TEMPLATES[key].filter(fits);
const preferred = all.filter(t => must.every(k => t.includes(`{${k}}`)));
const usable = preferred.length ? preferred : all;
if (!usable.length) throw new Error(`story: no usable template for ${key}`);
const template = usable[variantIndex(this.record.seed, `${this.salt}:${key}`, index, usable.length)];
// Evaluate placeholders in template order so first mentions are numbered left to right.
const filled: Record<string, string | number> = {};
for (const m of template.matchAll(/\{(\w+)\}/g)) if (!(m[1] in filled)) filled[m[1]] = values[m[1]]();
const refs = this.flush();
const body = fill(template, filled);
return { text: body + refs.map(r => `[${r}]`).join(''), refs };
}
}
/** Pluralise a fixed token name ("Staff Member" → "Staff Members"). */
export function tokenName(token: string, count: number): string {
return count === 1 ? token : `${token}s`;
}
/**
* Render one event as a sentence, or null if it is not shown to this viewer.
* `viewer` null = omniscient (post-match, spectators after the end).
*/
export interface RenderOptions {
/** Prefer variants that name the source card (the recap uses this for damage lines). */
preferSource?: boolean;
}
export function renderEvent(nar: Narrator, ev: StoryEvent, index: number, viewer: Seat | null, opts: RenderOptions = {}): { text: string; refs: number[] } | null {
const P = (s: Seat) => () => nar.player(s);
const M = (id: string) => () => nar.mention(id);
const N = (n: number) => () => n;
const other = (s: Seat): Seat => (s === 0 ? 1 : 0);
switch (ev.kind) {
case 'turnStart':
return { text: `Turn ${ev.turn}.`, refs: [] };
case 'deploy':
return nar.sentence('deploy', index, { player: P(ev.seat), card: M(ev.card) });
case 'cast':
return nar.sentence('cast', index, { player: P(ev.seat), card: M(ev.card) });
case 'adopt':
return nar.sentence('adopt', index, { player: P(ev.seat), doctrine: M(ev.doctrine), figure: M(ev.figure), p: N(ev.power), t: N(ev.toughness) });
case 'attack':
return nar.sentence('attack', index, { player: P(ev.seat), opponent: P(other(ev.seat)), card: M(ev.card), p: N(ev.power), t: N(ev.toughness) });
case 'block':
return nar.sentence('block', index, { player: P(ev.seat), blocker: M(ev.blocker), attacker: M(ev.attacker), p: N(ev.power), t: N(ev.toughness) });
case 'playerDamage': {
const v: Record<string, () => string | number> = { player: P(ev.seat), n: N(ev.amount), life: N(Math.max(0, ev.life)) };
if (ev.source) v.source = M(ev.source);
return nar.sentence('playerDamage', index, v, opts.preferSource && ev.source ? ['source'] : []);
}
case 'lifeGain':
return nar.sentence('lifeGain', index, { player: P(ev.seat), source: M(ev.source), n: N(ev.amount), life: N(ev.life) });
case 'effectDamage':
return nar.sentence('effectDamage', index, { source: M(ev.source), target: M(ev.target), n: N(ev.amount) });
case 'destroyed':
return nar.sentence('destroyed', index, { card: M(ev.card) });
case 'tokenCreated':
return nar.sentence('tokenCreated', index, {
source: M(ev.source), count: () => numberWord(ev.count), token: () => tokenName(ev.token, ev.count),
});
case 'draw': {
const count = ev.count ?? 1;
const visible = ev.card !== undefined && (viewer === null || viewer === ev.seat);
if (visible) return nar.sentence('drawKnown', index, { player: P(ev.seat), card: M(ev.card as string) });
if (count > 1) return nar.sentence('drawHiddenMany', index, { player: P(ev.seat), count: () => numberWord(count) });
return nar.sentence('drawHidden', index, { player: P(ev.seat) });
}
case 'discard':
return nar.sentence('discard', index, { player: P(ev.seat), card: M(ev.card) });
case 'connected':
return nar.sentence('connected', index, { a: M(ev.a), b: M(ev.b), reason: () => ev.reason });
case 'rivalry':
return nar.sentence('rivalry', index, { a: M(ev.a), b: M(ev.b), reason: () => ev.reason });
case 'gameOver': {
if (ev.winner === null) return nar.sentence('gameOverDraw', index, { turn: N(ev.turn) });
const key = ({ life: 'gameOverLife', library: 'gameOverLibrary', concede: 'gameOverConcede', timeout: 'gameOverTimeout', turnCap: 'gameOverTurnCap' } as const)[ev.reason];
return nar.sentence(key, index, { winner: P(ev.winner), loser: P(other(ev.winner)), turn: N(ev.turn) });
}
}
}
/** The match log for one viewer (DUEL_DESIGN §8.2). Hidden draws by the opponent stay hidden. */
export function renderLog(record: MatchRecord, viewer: Seat | null = null): { lines: LogLine[]; references: Reference[] } {
const nar = new Narrator(record, 'log');
const lines: LogLine[] = [];
let turn = 0;
record.events.forEach((ev, i) => {
if (ev.kind === 'turnStart') turn = ev.turn;
const out = renderEvent(nar, ev, i, viewer);
if (out) lines.push({ turn, ...out });
});
return { lines, references: nar.references };
}
/** Join lines into one paragraph per turn: "Turn 5. alice deployed …". */
export function logParagraphs(lines: LogLine[]): string[] {
const out: string[] = [];
let cur: string[] = [];
let curTurn = -1;
for (const l of lines) {
if (l.turn !== curTurn && cur.length) { out.push(cur.join(' ')); cur = []; }
curTurn = l.turn;
cur.push(l.text);
}
if (cur.length) out.push(cur.join(' '));
return out;
}
+290
View File
@@ -0,0 +1,290 @@
/**
* "Battle of X (2026)" recap (DUEL_DESIGN.md §8.3). Pure and deterministic: input is the
* match record only. Output is structured data; ui-pvp renders it. All prose is templates
* filled with real card and match data. No LLM, no invented facts.
*/
import { Narrator, renderEvent, variantIndex } from './log.ts';
import { FOOTER, numberWord, ordinalWord } from './templates.ts';
import type { GameOverReason, MatchRecord, Reference, Seat, StoryCard, StoryEvent } from './types.ts';
export interface RecapInfobox {
date: string;
location: string;
result: string;
belligerents: [string, string];
commanders: [string, string];
strength: [string, string];
casualties: [string, string];
}
export interface RecapSection {
heading: string;
paragraphs: string[];
}
export interface RecapDoc {
matchId: string;
/** Path of the shareable page. */
url: string;
masthead: 'WikiDeck';
title: string;
/** Card the battle is named after, if any. */
nameCardId?: string;
infobox: RecapInfobox;
/** Lead paragraph, then Background, Course of the battle, Aftermath, See also. */
lead: string;
sections: RecapSection[];
references: Reference[];
footer: string;
}
const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
/** "2026-11-17" → "17 November 2026". */
export function longDate(iso: string): string {
const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(iso);
if (!m) throw new Error(`recap: date must be ISO YYYY-MM-DD, got ${iso}`);
return `${Number(m[3])} ${MONTHS[Number(m[2]) - 1]} ${m[1]}`;
}
interface Played { id: string; seat: Seat; order: number }
interface Facts {
/** For a draw: seat 0, with `draw` set. */
winner: Seat;
draw: boolean;
loser: Seat;
reason: GameOverReason;
turns: number;
life: [number, number];
played: Played[];
destroyed: string[];
}
function facts(record: MatchRecord): Facts {
const over = [...record.events].reverse().find((e): e is Extract<StoryEvent, { kind: 'gameOver' }> => e.kind === 'gameOver');
if (!over) throw new Error('recap: match has no gameOver event');
const start = record.startingLife ?? 20;
const life: [number, number] = [start, start];
const played: Played[] = [];
const destroyed: string[] = [];
record.events.forEach((e, i) => {
if (e.kind === 'playerDamage' || e.kind === 'lifeGain') life[e.seat] = Math.max(0, e.life);
if (e.kind === 'deploy' || e.kind === 'cast') played.push({ id: e.card, seat: e.seat, order: i });
if (e.kind === 'adopt') played.push({ id: e.doctrine, seat: e.seat, order: i });
if (e.kind === 'destroyed') destroyed.push(e.card);
});
if (over.life) { life[0] = Math.max(0, over.life[0]); life[1] = Math.max(0, over.life[1]); }
const winner: Seat = over.winner ?? 0;
return { winner, draw: over.winner === null, loser: winner === 0 ? 1 : 0, reason: over.reason, turns: over.turn, life, played, destroyed };
}
/** Highest cost wins; ties go to the card played first. */
function best(cands: Played[], cards: Record<string, StoryCard>): Played | undefined {
let top: Played | undefined;
for (const c of cands) if (!top || cards[c.id].cost > cards[top.id].cost) top = c;
return top;
}
/** DUEL_DESIGN §8.3 naming order. */
export function battleName(record: MatchRecord, f: Facts = facts(record)): StoryCard | undefined {
const C = record.cards;
const of = (seat: Seat | null, type?: StoryCard['type']) =>
f.played.filter(p => (seat === null || p.seat === seat) && (!type || C[p.id].type === type));
const pick = best(of(f.winner, 'Location'), C) ?? best(of(f.loser, 'Location'), C)
?? best(of(null, 'Event'), C) ?? best(of(f.winner), C) ?? best(of(f.loser), C);
return pick ? C[pick.id] : undefined;
}
export function battleTitle(record: MatchRecord, f: Facts = facts(record)): string {
const card = battleName(record, f);
const year = record.date.slice(0, 4);
if (!card) return `WikiDeck match of ${longDate(record.date)}`;
if (card.type === 'Figure') return `${card.title} campaign (${year})`;
const each = Math.ceil(f.turns / 2);
const prefix = each <= 6 ? 'Skirmish at' : each >= 13 ? 'Siege of' : 'Battle of';
return `${prefix} ${card.title} (${year})`;
}
function resultText(record: MatchRecord, f: Facts): string {
const w = record.players[f.winner].name;
if (f.draw) return 'Inconclusive';
switch (f.reason) {
case 'concede': case 'timeout': return `${w} victory by withdrawal`;
case 'library': return `${w} victory by attrition`;
case 'turnCap': return `${w} victory by decision`;
case 'life': {
if (f.life[f.winner] <= 3) return `Pyrrhic ${w} victory`;
if (f.life[f.winner] - f.life[f.loser] >= 10) return `Decisive ${w} victory`;
return `${w} victory`;
}
}
}
const LEAD_VARIANTS = [
'The {title} was a WikiDeck engagement fought on {date} between the forces of {a} and {b}. It lasted {turns} turns and ended in {result}.',
'The {title} was fought on {date} between {a} and {b}, and lasted {turns} turns. It ended in {result}.',
'The {title} took place on {date}. The forces of {a} and {b} engaged for {turns} turns; the engagement ended in {result}.',
];
const FIRST_DEPLOY_VARIANTS = [
'Contemporary accounts note the deployment of {card} in the {ordinal} turn.',
'Records list {card} as the first Figure deployed, in the {ordinal} turn.',
'The first Figure to enter play was {card}, in the {ordinal} turn.',
];
function pickVariant(record: MatchRecord, salt: string, list: readonly string[]): string {
return list[variantIndex(record.seed, `recap:${salt}`, 0, list.length)];
}
function sub(t: string, v: Record<string, string | number>): string {
return t.replace(/\{(\w+)\}/g, (_, k: string) => String(v[k]));
}
/** The result as a phrase for the lead: "a Pyrrhic victory for bob". */
function resultPhrase(record: MatchRecord, f: Facts): string {
const w = record.players[f.winner].name;
if (f.draw) return 'a draw';
switch (f.reason) {
case 'concede': case 'timeout': return `a victory for ${w} by withdrawal`;
case 'library': return `a victory for ${w} by attrition`;
case 'turnCap': return `a victory for ${w} by decision`;
case 'life': {
if (f.life[f.winner] <= 3) return `a Pyrrhic victory for ${w}`;
if (f.life[f.winner] - f.life[f.loser] >= 10) return `a decisive victory for ${w}`;
return `a victory for ${w}`;
}
}
}
export function recap(record: MatchRecord): RecapDoc {
const f = facts(record);
const C = record.cards;
const nar = new Narrator(record, 'recap');
const [a, b] = [record.players[0].name, record.players[1].name];
const nameCard = battleName(record, f);
const title = battleTitle(record, f);
const result = resultText(record, f);
// Lead: cite the name card first so it is reference [1].
const nameRef = nameCard ? `[${nar.cite(nameCard.id)}]` : '';
let lead = sub(pickVariant(record, 'lead', LEAD_VARIANTS), {
title: `**${title}**`, date: longDate(record.date), a, b, turns: numberWord(f.turns), result: resultPhrase(record, f),
}) + nameRef;
const firstFig = record.events.findIndex(e => e.kind === 'deploy' && C[e.card].type === 'Figure');
if (firstFig >= 0) {
const ev = record.events[firstFig] as Extract<StoryEvent, { kind: 'deploy' }>;
const turn = turnAt(record.events, firstFig);
const t = pickVariant(record, 'firstDeploy', FIRST_DEPLOY_VARIANTS);
const card = nar.mention(ev.card);
const refs = nar.flush();
lead += ' ' + sub(t, { card, ordinal: ordinalWord(turn) }) + refs.map(r => `[${r}]`).join('');
}
// Background: Portal mix of the cards each side played.
const background: string[] = [];
for (const seat of [0, 1] as Seat[]) {
const mine = f.played.filter(p => p.seat === seat);
if (!mine.length) { background.push(`${record.players[seat].name} played no cards.`); continue; }
const counts = new Map<string, number>();
for (const p of mine) { const k = C[p.id].portal ?? 'Neutral'; counts.set(k, (counts.get(k) ?? 0) + 1); }
const sorted = [...counts.entries()].sort((x, y) => y[1] - x[1] || x[0].localeCompare(y[0]));
const max = sorted[0][1];
const tops = sorted.filter(([, n]) => n === max).map(([k]) => k);
const name = record.players[seat].name;
const played = `${numberWord(mine.length)} ${mine.length === 1 ? 'card' : 'cards'} played`;
if (tops.length === 1) background.push(`${tops[0]} was the largest Portal in the force of ${name} (${numberWord(max)} of ${played}).`);
else background.push(`${listJoin(tops)} were equally represented in the force of ${name} (${numberWord(max)} ${max === 1 ? 'card' : 'cards'} each, of ${played}).`);
}
// Course of the battle: the largest Notability swings and destroyed cards of cost ≥ 4.
const swings = record.events
.map((e, i) => ({ e, i }))
.filter(x => x.e.kind === 'playerDamage')
.sort((x, y) => (y.e as { amount: number }).amount - (x.e as { amount: number }).amount || x.i - y.i)
.slice(0, 5).map(x => x.i);
const big = record.events.map((e, i) => ({ e, i }))
.filter(x => x.e.kind === 'destroyed' && C[(x.e as { card: string }).card].cost >= 4).map(x => x.i);
const chosen = [...new Set([...swings, ...big])].sort((x, y) => x - y);
const course: string[] = [];
let curTurn = -1;
let para: string[] = [];
for (const i of chosen) {
const t = turnAt(record.events, i);
if (t !== curTurn && para.length) { course.push(para.join(' ')); para = []; }
if (t !== curTurn) para.push(`In the ${ordinalWord(t)} turn,`);
curTurn = t;
const out = renderEvent(nar, record.events[i], i, null, { preferSource: true });
if (out) para.push(out.text);
}
if (para.length) course.push(para.join(' '));
const over = record.events.findIndex(e => e.kind === 'gameOver');
const end = renderEvent(nar, record.events[over], over, null);
if (end) course.push(end.text);
// Aftermath.
const aftermath = [f.draw
? `Both ${a} and ${b} ended the engagement with ${f.life[0]} Notability.`
: `${record.players[f.winner].name} ended the engagement with ${f.life[f.winner]} Notability; ${record.players[f.loser].name} ended with ${f.life[f.loser]}.`,
];
if (record.ratingChange) {
const fmt = (n: number) => (n >= 0 ? `+${n}` : `${n}`);
aftermath.push(`Ratings changed by ${fmt(record.ratingChange[0])} for ${a} and ${fmt(record.ratingChange[1])} for ${b}.`);
}
// See also: Connected pairs and rivalries.
const seeAlso: string[] = [];
for (const e of record.events) {
if (e.kind === 'connected' || e.kind === 'rivalry') seeAlso.push(`*${C[e.a].title}* – *${C[e.b].title}* (${e.reason})`);
}
// References: every card played, in first-mention order.
for (const p of f.played) nar.cite(p.id);
const perSeat = (fn: (s: Seat) => string): [string, string] => [fn(0), fn(1)];
const infobox: RecapInfobox = {
date: longDate(record.date),
location: nameCard?.type === 'Location' ? nameCard.title : `WikiDeck host ${record.hostName ?? 'unknown'}`,
result,
belligerents: [a, b],
commanders: perSeat(s => {
const c = best(f.played.filter(p => p.seat === s && C[p.id].type === 'Figure'), C);
return c ? C[c.id].title : 'None recorded';
}),
strength: perSeat(s => cards(f.played.filter(p => p.seat === s).length)),
casualties: perSeat(s => {
const lost = f.destroyed.filter(id => C[id].owner === s).map(id => C[id].title);
return lost.length ? `${cards(lost.length)} destroyed: ${lost.join(', ')}` : 'None';
}),
};
const sections: RecapSection[] = [
{ heading: 'Background', paragraphs: background },
{ heading: 'Course of the battle', paragraphs: course },
{ heading: 'Aftermath', paragraphs: aftermath },
];
if (seeAlso.length) sections.push({ heading: 'See also', paragraphs: seeAlso });
return {
matchId: record.matchId,
url: `/recap/${encodeURIComponent(record.matchId)}`,
masthead: 'WikiDeck',
title,
nameCardId: nameCard?.id,
infobox,
lead,
sections,
references: nar.references,
footer: FOOTER,
};
}
function listJoin(xs: string[]): string {
return xs.length <= 1 ? xs.join('') : `${xs.slice(0, -1).join(', ')} and ${xs[xs.length - 1]}`;
}
function cards(n: number): string { return `${n} ${n === 1 ? 'card' : 'cards'}`; }
function turnAt(events: StoryEvent[], index: number): number {
for (let i = index; i >= 0; i--) { const e = events[i]; if (e.kind === 'turnStart') return e.turn; }
return 0;
}
+156
View File
@@ -0,0 +1,156 @@
/**
* Match-log sentence templates (DUEL_DESIGN.md §8.2). Data only.
*
* Tone (BRIEF decision 5, DUEL_DESIGN §8.1): past tense, encyclopedic, deadpan. No adjectives
* about cards or players, no exclamation marks, never comment on the matchup. Placeholders
* are filled only with real card and match data. `tests/duel-design-story.test.ts` lints this file.
*
* Placeholders: {player} {opponent} {card} {doctrine} {figure} {attacker} {blocker} {source}
* {target} {token} {a} {b} {reason} {winner} {loser} {n} {count} {p} {t} {life} {turn}.
*/
export const LOG_TEMPLATES = {
deploy: [
'{player} deployed {card}.',
'{card} was deployed by {player}.',
'{player} brought {card} into play.',
'{card} entered play under {player}.',
],
cast: [
'{player} cited {card}.',
'{card} was cited by {player}.',
'{player} invoked {card}.',
],
adopt: [
'{doctrine} was adopted by {figure}, which became a {p}/{t}.',
'{figure} adopted {doctrine} and became a {p}/{t}.',
'{player} attached {doctrine} to {figure} ({p}/{t}).',
],
attack: [
'{card} ({p}/{t}) attacked.',
'{player} sent {card} ({p}/{t}) into combat.',
'{card} ({p}/{t}) advanced on {opponent}.',
],
block: [
'{blocker} ({p}/{t}) blocked {attacker}.',
'{attacker} was blocked by {blocker} ({p}/{t}).',
'{blocker} ({p}/{t}) intercepted {attacker}.',
],
playerDamage: [
'{player} lost {n} Notability ({life} remaining).',
'{source} dealt {n} damage to {player}, leaving {life} Notability.',
"{player}'s Notability fell to {life}.",
],
lifeGain: [
'{player} gained {n} Notability from {source} ({life} total).',
'{source} restored {n} Notability to {player}.',
"{player}'s Notability rose to {life} ({source}).",
],
effectDamage: [
'{source} dealt {n} damage to {target}.',
'{target} took {n} damage from {source}.',
'{source} inflicted {n} damage on {target}.',
],
destroyed: [
'{card} was destroyed.',
'{card} was moved to Deleted.',
'{card} was removed from play.',
'{card} did not survive the turn.',
],
tokenCreated: [
'{source} produced {count} {token}.',
'{source} brought {count} {token} into play.',
'{source} created {count} {token}.',
],
drawKnown: [
'{player} drew {card}.',
'{card} was drawn by {player}.',
'{player} added {card} to their hand.',
],
drawHidden: [
'{player} drew a card.',
'{player} drew one card.',
'{player} added a card to their hand.',
],
drawHiddenMany: [
'{player} drew {count} cards.',
'{player} added {count} cards to their hand.',
'{player} took {count} cards into hand.',
],
discard: [
'{player} discarded {card}.',
'{card} was discarded by {player}.',
'{player} moved {card} from hand to Deleted.',
],
connected: [
'{a} and {b} were Connected ({reason}).',
'{a} was Connected to {b} through {reason}.',
'Records link {a} and {b} ({reason}).',
],
rivalry: [
'{a} and {b} are both listed under {reason}.',
'{a} and {b} share {reason}.',
'The two sides were linked through {reason}.',
],
gameOverLife: [
'{loser} was nominated for deletion. The result was **delete**.',
'{loser} was reduced to 0 Notability. {winner} won.',
'{winner} won on turn {turn}.',
],
gameOverDraw: [
'Both sides were reduced to 0 Notability. The engagement ended in a draw.',
'The engagement ended in a draw on turn {turn}.',
'Neither side retained any Notability. No winner was recorded.',
],
gameOverLibrary: [
'{loser} could not draw a card and lost.',
'{loser} ran out of cards. {winner} won.',
"{loser}'s library was exhausted. {winner} won.",
],
gameOverConcede: [
'{loser} withdrew.',
'{loser} withdrew. {winner} won.',
'{loser} conceded on turn {turn}.',
],
gameOverTimeout: [
'{loser} did not respond in time and withdrew.',
'{loser} ran out of time. {winner} won.',
"{loser}'s clock expired on turn {turn}.",
],
gameOverTurnCap: [
'{winner} won on Notability at the turn limit.',
'The turn limit was reached. {winner} won on Notability.',
'The engagement reached the turn limit; {winner} held more Notability.',
],
} as const satisfies Record<string, readonly string[]>;
export type TemplateKey = keyof typeof LOG_TEMPLATES;
/** Words the generator must never emit (critic S7 failure modes). Lowercase; whole words. */
export const BANNED_WORDS = [
'brutal', 'brutally', 'heroic', 'heroically', 'humiliating', 'humiliated', 'bloodiest', 'bloody',
'surprising', 'surprisingly', 'ironically', 'unlikely', 'hilarious', 'tragic', 'tragically', 'sadly',
'unfortunately', 'poor', 'epic', 'crushed', 'squashed', 'killed', 'murdered', 'destroyed utterly', 'lol',
];
export const FOOTER =
'This page records a WikiDeck match. Card names refer to Wikipedia articles; the events described are game events.';
const NUMBER_WORDS = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven',
'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen', 'twenty'];
export function numberWord(n: number): string {
return Number.isInteger(n) && n >= 0 && n < NUMBER_WORDS.length ? NUMBER_WORDS[n] : String(n);
}
const ORDINALS = ['zeroth', 'first', 'second', 'third', 'fourth', 'fifth', 'sixth', 'seventh', 'eighth', 'ninth', 'tenth',
'eleventh', 'twelfth', 'thirteenth', 'fourteenth', 'fifteenth', 'sixteenth', 'seventeenth', 'eighteenth', 'nineteenth', 'twentieth'];
export function ordinalWord(n: number): string {
if (Number.isInteger(n) && n >= 0 && n < ORDINALS.length) return ORDINALS[n];
const s = n % 100 >= 11 && n % 100 <= 13 ? 'th' : ({ 1: 'st', 2: 'nd', 3: 'rd' } as Record<number, string>)[n % 10] ?? 'th';
return `${n}${s}`;
}
export function fill(template: string, values: Record<string, string | number>): string {
return template.replace(/\{(\w+)\}/g, (whole, key: string) => {
if (!(key in values)) throw new Error(`story template is missing a value for {${key}}: ${template}`);
return String(values[key]);
});
}
+98
View File
@@ -0,0 +1,98 @@
/**
* Story input contract (DUEL_DESIGN.md §8). This is the minimal, engine-agnostic shape the
* match-log and recap templates read. `fromDuel.ts` (added after duel-core's
* shared/duel/types.ts merges) maps engine LogEvents onto it. Everything is plain JSON,
* so a stored match record can regenerate its log and recap exactly.
*/
export type Seat = 0 | 1;
export type CardType = 'Figure' | 'Location' | 'Event' | 'Institution' | 'Doctrine';
/** One card instance in the match, frozen from its derived profile. Only real data. */
export interface StoryCard {
/** Engine instance id, unique within the match. */
id: string;
/** Article title, verbatim. */
title: string;
/** Wikidata short description, verbatim ('' or undefined if none). */
description?: string;
type: CardType;
cost: number;
/** Portal (faction): Arts, Earth, History, Science, Society or Neutral. */
portal?: string;
/** The article revision the card was minted from (on-chain). Absent for tokens: they are never cited. */
revisionId?: number;
/** Tokens (Elected Member, Staff Member): generic, not articles, never cited or glossed. */
token?: boolean;
/** On-chain token id of the mint, if known. */
tokenId?: string;
/** Seat that owns the card in this match. */
owner: Seat;
}
export type GameOverReason = 'life' | 'library' | 'concede' | 'timeout' | 'turnCap';
export type StoryEvent =
| { kind: 'turnStart'; turn: number; seat: Seat }
| { kind: 'deploy'; seat: Seat; card: string }
| { kind: 'cast'; seat: Seat; card: string }
| { kind: 'adopt'; seat: Seat; doctrine: string; figure: string; power: number; toughness: number }
| { kind: 'attack'; seat: Seat; card: string; power: number; toughness: number }
| { kind: 'block'; seat: Seat; blocker: string; attacker: string; power: number; toughness: number }
/** `seat` is the player who lost Notability; `life` is what remains. */
| { kind: 'playerDamage'; seat: Seat; source?: string; amount: number; life: number }
/** `life` is the new total. */
| { kind: 'lifeGain'; seat: Seat; source: string; amount: number; life: number }
| { kind: 'effectDamage'; source: string; target: string; amount: number }
| { kind: 'destroyed'; card: string }
| { kind: 'tokenCreated'; seat: Seat; source: string; token: string; count: number }
/** `card` set when the drawn card is known to the viewer's record; hidden draws omit it. */
| { kind: 'draw'; seat: Seat; card?: string; count?: number }
/** Deleted is public (DUEL_DESIGN §2.3): discards are always named. */
| { kind: 'discard'; seat: Seat; card: string }
| { kind: 'connected'; seat: Seat; a: string; b: string; reason: string }
| { kind: 'rivalry'; a: string; b: string; reason: string }
/** winner null = draw (both players reached 0 at once). */
/** `life`: final Notability per seat, authoritative when present (duel-core carries it). */
| { kind: 'gameOver'; winner: Seat | null; reason: GameOverReason; turn: number; life?: [number, number] };
export interface StoryPlayer {
/** Display name of the seat (account display name or "Bot (Normal)"). */
name: string;
}
export interface MatchRecord {
matchId: string;
/**
* Story seed: drives template variants only. NOT the engine seed: a client rendering
* logFor text must never learn the engine seed (it would reveal library order). The host
* derives it, e.g. sha256(engineSeed + ':story'). Recaps after the match may use either.
*/
seed: number | string;
/** Match date, ISO `YYYY-MM-DD`. No clock is read by the story code. */
date: string;
players: [StoryPlayer, StoryPlayer];
cards: Record<string, StoryCard>;
events: StoryEvent[];
startingLife?: number;
hostName?: string;
/** Ranked matches: rating change per seat. */
ratingChange?: [number, number];
}
export interface LogLine {
turn: number;
text: string;
/** Reference numbers cited by this line, in order. */
refs: number[];
}
export interface Reference {
n: number;
cardId: string;
title: string;
revisionId: number;
tokenId?: string;
url: string;
/** Rendered citation line, without the leading number. */
text: string;
}
+72
View File
@@ -0,0 +1,72 @@
import { test } from 'node:test';
import assert from 'node:assert/strict';
import type { CardInstance, CardRef, DuelCard, LogEvent } from '../shared/duel/types.ts';
import { fromDuel } from '../shared/duel/story/fromDuel.ts';
import { recap, renderLog } from '../shared/duel/story/index.ts';
function duelCard(cardId: string, title: string, type: DuelCard['type'], cost: number, extra: Partial<DuelCard> = {}): DuelCard {
return {
cardId, pageId: 1, revisionId: 1000 + cost, title, description: `${title} description`, type, subtype: null,
portal: 'Society', cost, power: type === 'Figure' ? 2 : null, toughness: type === 'Figure' ? 2 : null,
keywords: [], effects: [], rulesText: '', flavor: '', ...extra,
};
}
const inst: CardInstance[] = [
{ uid: '0:0', owner: 0, card: duelCard('tokA', 'Pathrail Mosque', 'Location', 2) },
{ uid: '0:1', owner: 0, card: duelCard('tokB', 'Tom Ewell', 'Figure', 6) },
{ uid: '1:0', owner: 1, card: duelCard('tokC', '1954 Gold Coast general election', 'Event', 3) },
{ uid: '1:1', owner: 1, card: duelCard('tokD', "Pallas's cat", 'Figure', 6) },
];
const R = (i: CardInstance, p?: number, t?: number): CardRef =>
({ uid: i.uid, cardId: i.card.cardId, title: i.card.title, pageId: i.card.pageId, type: i.card.type, power: p, toughness: t });
const tok1: CardRef = { uid: 't:1', cardId: 'token:elected', title: 'Elected Member', pageId: null, type: 'Figure', power: 1, toughness: 1 };
const tok2: CardRef = { ...tok1, uid: 't:2' };
let seq = 0;
const E = (turn: number, e: Record<string, unknown>) => ({ seq: seq++, turn, ...e }) as LogEvent;
const log: LogEvent[] = [
E(0, { kind: 'start', firstSeat: 0 }),
E(1, { kind: 'turnStart', seat: 0, citations: 1, life: [20, 20] }),
E(1, { kind: 'deploy', seat: 0, card: R(inst[0], 0, 3) }),
E(2, { kind: 'turnStart', seat: 1, citations: 1, life: [20, 20] }),
E(2, { kind: 'draw', seat: 1 }),
E(2, { kind: 'cast', seat: 1, card: R(inst[2]), targets: [] }),
E(2, { kind: 'tokenCreated', seat: 1, card: tok1, source: R(inst[2]) }),
E(2, { kind: 'tokenCreated', seat: 1, card: tok2, source: R(inst[2]) }),
E(3, { kind: 'turnStart', seat: 0, citations: 2, life: [20, 20] }),
E(3, { kind: 'draw', seat: 0, card: R(inst[1]) }),
E(3, { kind: 'deploy', seat: 0, card: R(inst[1], 5, 5) }),
E(4, { kind: 'turnStart', seat: 1, citations: 2, life: [20, 20] }),
E(4, { kind: 'attack', seat: 1, attackers: [R(inst[3], 5, 5), tok1] }),
E(4, { kind: 'block', seat: 0, blocks: [{ blocker: R(inst[1], 5, 5), attacker: tok1 }] }),
E(4, { kind: 'combatDamage', source: tok1, target: R(inst[1]), amount: 1 }),
E(4, { kind: 'destroyed', card: tok1, owner: 1 }),
E(4, { kind: 'playerDamage', source: R(inst[3]), seat: 0, amount: 5, life: 15, combat: true }),
E(4, { kind: 'lifeGain', source: R(inst[3]), seat: 1, amount: 2, life: 22 }),
E(4, { kind: 'concede', seat: 0 }),
E(4, { kind: 'gameOver', winner: 1, reason: 'concede', life: [15, 22] }),
];
test('fromDuel maps duel-core LogEvents onto the story record', () => {
const rec = fromDuel({
matchId: 'm1', storySeed: 'story-seed', date: '2026-11-17',
players: [{ name: 'alice' }, { name: 'bob' }], instances: inst, log,
});
assert.deepEqual(rec.events.map(e => e.kind), [
'turnStart', 'deploy', 'turnStart', 'draw', 'cast', 'tokenCreated', 'turnStart', 'draw', 'deploy',
'turnStart', 'attack', 'attack', 'block', 'destroyed', 'playerDamage', 'lifeGain', 'gameOver',
]);
const tc = rec.events.find(e => e.kind === 'tokenCreated');
assert.deepEqual(tc, { kind: 'tokenCreated', seat: 1, source: '1:0', token: 'Elected Member', count: 2 });
assert.equal(rec.cards['t:1'].token, true);
assert.equal(rec.cards['0:1'].tokenId, 'tokB');
assert.equal(rec.seed, 'story-seed');
const over = rec.events[rec.events.length - 1];
assert.deepEqual(over, { kind: 'gameOver', winner: 1, reason: 'concede', turn: 4, life: [15, 22] });
const r = recap(rec);
assert.equal(r.title, 'Skirmish at Pathrail Mosque (2026)');
assert.equal(r.infobox.result, 'bob victory by withdrawal');
assert.ok(r.references.every(x => !x.title.includes('Elected Member')));
const forBob = renderLog(rec, 1).lines.map(l => l.text).join(' ');
assert.doesNotMatch(forBob, /Tom Ewell.*drawn|drew \*Tom Ewell/); // alice's draw is hidden from bob
});
+50
View File
@@ -0,0 +1,50 @@
{
"log": [
"Turn 1. alice brought *Pathrail Mosque* (Mosque in Faridpur, Bangladesh) into play.[1]",
"Turn 2. bob added *1954 Gold Coast general election* to their hand.[2]",
"Turn 3. alice added *Dichromorpha viridis* (Species of grasshopper) to their hand.[3] *Dichromorpha viridis* entered play under alice.",
"Turn 4. bob added a card to their hand. *1954 Gold Coast general election* was cited by bob. *1954 Gold Coast general election* brought two Elected Members into play.",
"Turn 5. alice drew one card. alice sent *Dichromorpha viridis* (4/2) into combat. bob lost 4 Notability (16 remaining).",
"Turn 6. bob drew one card. bob cited *April 2021 nor'easter* (Slow-moving nor'easter in April 2021).[4] *Dichromorpha viridis* took 1 damage from *April 2021 nor'easter*. *April 2021 nor'easter* dealt 1 damage to *Pathrail Mosque*. *Dichromorpha viridis* was removed from play.",
"Turn 7. alice added a card to their hand. *Zbyszek Godlewski* (Polish protester, 1952–1970) entered play under alice.[5]",
"Turn 8. bob added a card to their hand. *Marc Fesneau* (French politician, born 1971) entered play under bob.[6]",
"Turn 9. alice drew one card. *Zbyszek Godlewski* (6/3) attacked. *Zbyszek Godlewski* was blocked by *Marc Fesneau* (5/4). *Zbyszek Godlewski* was removed from play. *Marc Fesneau* was removed from play. alice drew one card.",
"Turn 10. bob added a card to their hand. bob discarded *Agda (programming language)* (Functional programming language).[7] bob deployed *Pallas's cat* (Species of small wild cat).[8]",
"Turn 11. alice drew one card. alice deployed *Tom Ewell* (American actor, 1909–1994).[9]",
"Turn 12. bob added a card to their hand. bob attached *Heart rot* (Fungal disease of trees) to *Tom Ewell* (2/2).[10] *Pallas's cat* (5/5) advanced on alice. *Pallas's cat* dealt 5 damage to alice, leaving 15 Notability.",
"Turn 13. alice added a card to their hand. *Monoid* (Algebraic structure with an associative operation and an identity element) was adopted by *Tom Ewell*, which became a 5/5.[11] alice sent *Tom Ewell* (5/5) into combat. bob lost 5 Notability (11 remaining).",
"Turn 14. bob drew one card. bob invoked *2025 Tehreek-e-Labbaik Pakistan protests* (Gaza war protests in Pakistan).[12] *2025 Tehreek-e-Labbaik Pakistan protests* inflicted 3 damage on *Tom Ewell*. bob brought *Tatsunoko Production* (Japanese animation studio) into play.[13] bob sent *Pallas's cat* (5/5) into combat. alice's Notability fell to 10.",
"Turn 15. alice drew a card. *Tom Ewell* (5/5) advanced on bob. bob lost 5 Notability (6 remaining).",
"Turn 16. bob drew a card. bob sent *Pallas's cat* (5/5) into combat. alice lost 5 Notability (5 remaining).",
"Turn 17. alice drew one card. *Tom Ewell* (5/5) advanced on bob. bob's Notability fell to 1.",
"Turn 18. bob drew one card. bob sent *Pallas's cat* (5/5) into combat. alice lost 5 Notability (0 remaining). alice was reduced to 0 Notability. bob won."
],
"lead": "The **Battle of Pathrail Mosque (2026)** was a WikiDeck engagement fought on 17 November 2026 between the forces of alice and bob. It lasted eighteen turns and ended in a Pyrrhic victory for bob.[1] Contemporary accounts note the deployment of *Dichromorpha viridis* (Species of grasshopper) in the third turn.[2]",
"sections": [
{
"heading": "Background",
"paragraphs": [
"Arts, Earth, History, Science and Society were equally represented in the force of alice (one card each, of five cards played).",
"Society was the largest Portal in the force of bob (three of seven cards played)."
]
},
{
"heading": "Course of the battle",
"paragraphs": [
"In the ninth turn, *Zbyszek Godlewski* (Polish protester, 1952–1970) was destroyed.[3] *Marc Fesneau* (French politician, born 1971) was removed from play.[4]",
"In the twelfth turn, *Pallas's cat* (Species of small wild cat) dealt 5 damage to alice, leaving 15 Notability.[5]",
"In the thirteenth turn, *Tom Ewell* (American actor, 1909–1994) dealt 5 damage to bob, leaving 11 Notability.[6]",
"In the fourteenth turn, *Pallas's cat* dealt 5 damage to alice, leaving 10 Notability.",
"In the fifteenth turn, *Tom Ewell* dealt 5 damage to bob, leaving 6 Notability.",
"In the sixteenth turn, *Pallas's cat* dealt 5 damage to alice, leaving 5 Notability.",
"alice was nominated for deletion. The result was **delete**."
]
},
{
"heading": "Aftermath",
"paragraphs": [
"bob ended the engagement with 1 Notability; alice ended with 0."
]
}
]
}
+256
View File
@@ -0,0 +1,256 @@
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync, readdirSync } from 'node:fs';
import {
BANNED_WORDS, FOOTER, LOG_TEMPLATES, gloss, logParagraphs, longDate, recap, renderLog,
type CardType, type MatchRecord, type StoryCard, type StoryEvent,
} from '../shared/duel/story/index.ts';
// Real cards from docs/game/card-sample.json (no network). Types, costs and Portals are the
// DUEL_DESIGN.md §9 worked examples.
const sample = JSON.parse(readFileSync(new URL('../docs/game/card-sample.json', import.meta.url), 'utf8')) as {
cards: { title: string; description: string | null; revisionId: number; pageId: number }[];
};
const byTitle = new Map(sample.cards.map(c => [c.title, c]));
function card(id: string, title: string, type: CardType, cost: number, portal: string, owner: 0 | 1): StoryCard {
const c = byTitle.get(title);
if (!c) throw new Error(`not in sample: ${title}`);
return { id, title, description: c.description ?? '', type, cost, portal, revisionId: c.revisionId, tokenId: `tok-${c.pageId}`, owner };
}
const cards: Record<string, StoryCard> = Object.fromEntries([
card('a1', 'Dichromorpha viridis', 'Figure', 2, 'Earth', 0),
card('a2', 'Pathrail Mosque', 'Location', 2, 'Society', 0),
card('a3', 'Zbyszek Godlewski', 'Figure', 5, 'History', 0),
card('a4', 'Monoid', 'Doctrine', 6, 'Science', 0),
card('a5', 'Tom Ewell', 'Figure', 6, 'Arts', 0),
card('b1', '1954 Gold Coast general election', 'Event', 3, 'Society', 1),
card('b2', "April 2021 nor'easter", 'Event', 3, 'Earth', 1),
card('b3', 'Marc Fesneau', 'Figure', 5, 'Society', 1),
card('b4', "Pallas's cat", 'Figure', 6, 'Earth', 1),
card('b5', 'Heart rot', 'Doctrine', 5, 'Science', 1),
card('b6', '2025 Tehreek-e-Labbaik Pakistan protests', 'Event', 5, 'Society', 1),
card('b7', 'Tatsunoko Production', 'Institution', 6, 'Arts', 1),
card('b8', 'Agda (programming language)', 'Doctrine', 6, 'Science', 1),
].map(c => [c.id, c]));
const T = (turn: number): StoryEvent => ({ kind: 'turnStart', turn, seat: turn % 2 === 1 ? 0 : 1 });
const events: StoryEvent[] = [
T(1), { kind: 'deploy', seat: 0, card: 'a2' },
T(2), { kind: 'draw', seat: 1, card: 'b1' },
T(3), { kind: 'draw', seat: 0, card: 'a1' }, { kind: 'deploy', seat: 0, card: 'a1' },
T(4), { kind: 'draw', seat: 1 }, { kind: 'cast', seat: 1, card: 'b1' },
{ kind: 'tokenCreated', seat: 1, source: 'b1', token: 'Elected Member', count: 2 },
T(5), { kind: 'draw', seat: 0 }, { kind: 'attack', seat: 0, card: 'a1', power: 4, toughness: 2 },
{ kind: 'playerDamage', seat: 1, source: 'a1', amount: 4, life: 16 },
T(6), { kind: 'draw', seat: 1 }, { kind: 'cast', seat: 1, card: 'b2' },
{ kind: 'effectDamage', source: 'b2', target: 'a1', amount: 1 },
{ kind: 'effectDamage', source: 'b2', target: 'a2', amount: 1 }, { kind: 'destroyed', card: 'a1' },
T(7), { kind: 'draw', seat: 0 }, { kind: 'deploy', seat: 0, card: 'a3' },
T(8), { kind: 'draw', seat: 1 }, { kind: 'deploy', seat: 1, card: 'b3' },
T(9), { kind: 'draw', seat: 0 }, { kind: 'attack', seat: 0, card: 'a3', power: 6, toughness: 3 },
{ kind: 'block', seat: 1, blocker: 'b3', attacker: 'a3', power: 5, toughness: 4 },
{ kind: 'destroyed', card: 'a3' }, { kind: 'destroyed', card: 'b3' }, { kind: 'draw', seat: 0 },
T(10), { kind: 'draw', seat: 1 }, { kind: 'discard', seat: 1, card: 'b8' }, { kind: 'deploy', seat: 1, card: 'b4' },
T(11), { kind: 'draw', seat: 0 }, { kind: 'deploy', seat: 0, card: 'a5' },
T(12), { kind: 'draw', seat: 1 }, { kind: 'adopt', seat: 1, doctrine: 'b5', figure: 'a5', power: 2, toughness: 2 },
{ kind: 'attack', seat: 1, card: 'b4', power: 5, toughness: 5 }, { kind: 'playerDamage', seat: 0, source: 'b4', amount: 5, life: 15 },
T(13), { kind: 'draw', seat: 0 }, { kind: 'adopt', seat: 0, doctrine: 'a4', figure: 'a5', power: 5, toughness: 5 },
{ kind: 'attack', seat: 0, card: 'a5', power: 5, toughness: 5 }, { kind: 'playerDamage', seat: 1, source: 'a5', amount: 5, life: 11 },
T(14), { kind: 'draw', seat: 1 }, { kind: 'cast', seat: 1, card: 'b6' },
{ kind: 'effectDamage', source: 'b6', target: 'a5', amount: 3 }, { kind: 'deploy', seat: 1, card: 'b7' },
{ kind: 'attack', seat: 1, card: 'b4', power: 5, toughness: 5 }, { kind: 'playerDamage', seat: 0, source: 'b4', amount: 5, life: 10 },
T(15), { kind: 'draw', seat: 0 }, { kind: 'attack', seat: 0, card: 'a5', power: 5, toughness: 5 },
{ kind: 'playerDamage', seat: 1, source: 'a5', amount: 5, life: 6 },
T(16), { kind: 'draw', seat: 1 }, { kind: 'attack', seat: 1, card: 'b4', power: 5, toughness: 5 },
{ kind: 'playerDamage', seat: 0, source: 'b4', amount: 5, life: 5 },
T(17), { kind: 'draw', seat: 0 }, { kind: 'attack', seat: 0, card: 'a5', power: 5, toughness: 5 },
{ kind: 'playerDamage', seat: 1, source: 'a5', amount: 5, life: 1 },
T(18), { kind: 'draw', seat: 1 }, { kind: 'attack', seat: 1, card: 'b4', power: 5, toughness: 5 },
{ kind: 'playerDamage', seat: 0, source: 'b4', amount: 5, life: 0 },
{ kind: 'gameOver', winner: 1, reason: 'life', turn: 18 },
];
const record: MatchRecord = {
matchId: 'golden-1', seed: 'golden-seed', date: '2026-11-17',
players: [{ name: 'alice' }, { name: 'bob' }], cards, events, hostName: 'testnet-r350',
};
test('recap: title, infobox and footer follow DUEL_DESIGN §8.3', () => {
const r = recap(record);
assert.equal(r.title, 'Battle of Pathrail Mosque (2026)'); // loser's Location; 9 turns each → "Battle of"
assert.equal(r.url, '/recap/golden-1');
assert.equal(r.masthead, 'WikiDeck');
assert.deepEqual(r.infobox, {
date: '17 November 2026',
location: 'Pathrail Mosque',
result: 'Pyrrhic bob victory',
belligerents: ['alice', 'bob'],
commanders: ['Tom Ewell', "Pallas's cat"],
strength: ['5 cards', '7 cards'],
casualties: ['2 cards destroyed: Dichromorpha viridis, Zbyszek Godlewski', '1 card destroyed: Marc Fesneau'],
});
assert.equal(r.footer, FOOTER);
assert.match(r.lead, /^The \*\*Battle of Pathrail Mosque \(2026\)\*\* .*17 November 2026.*alice.*bob.*eighteen turns.*a Pyrrhic victory for bob\.\[1\]/);
assert.match(r.lead, /\*Dichromorpha viridis\* \(Species of grasshopper\).* third turn\.\[2\]$/);
assert.deepEqual(r.sections.map(s => s.heading), ['Background', 'Course of the battle', 'Aftermath']);
assert.match(r.sections[2].paragraphs[0], /^bob ended the engagement with 1 Notability; alice ended with 0\.$/);
});
test('recap: references cite every card played with its revision id, in first-mention order', () => {
const r = recap(record);
assert.equal(r.references.length, 12);
assert.deepEqual(r.references.map(x => x.n), r.references.map((_, i) => i + 1));
assert.equal(r.references[0].title, 'Pathrail Mosque');
for (const ref of r.references) {
const c = cards[ref.cardId];
assert.equal(ref.revisionId, c.revisionId);
assert.ok(ref.url.endsWith(`&oldid=${c.revisionId}`), ref.url);
assert.ok(ref.url.startsWith('https://en.wikipedia.org/w/index.php?title='));
assert.match(ref.text, new RegExp(`Revision ${c.revisionId}\\. Minted as token tok-`));
}
// every [n] used in the text exists
const text = [r.lead, ...r.sections.flatMap(s => s.paragraphs)].join(' ');
for (const m of text.matchAll(/\[(\d+)\]/g)) assert.ok(Number(m[1]) <= r.references.length);
});
test('log: golden lines for the omniscient view', () => {
const { lines, references } = renderLog(record, null);
const paras = logParagraphs(lines);
assert.equal(paras.length, 18);
assert.equal(lines[0].text, 'Turn 1.');
assert.match(lines[1].text, /\*Pathrail Mosque\* \(Mosque in Faridpur, Bangladesh\).*\[1\]$/);
assert.ok(lines.some(l => /\*Zbyszek Godlewski\* \(Polish protester, 1952–1970\)/.test(l.text)));
assert.ok(lines.some(l => /two Elected Members/.test(l.text)));
assert.match(lines[lines.length - 1].text, /alice/);
// later mentions carry no gloss and no new citation
const later = lines.filter(l => l.text.includes('*Tom Ewell*'));
assert.ok(later.length >= 3);
assert.equal(later.filter(l => l.text.includes('American actor')).length, 1);
assert.equal(references.length, 13); // 12 played + the discarded Agda
// snapshot of the whole log text (golden): regenerate deliberately if templates change
assert.equal(paras.join('\n').length > 1500, true);
assert.deepEqual(renderLog(record, null), { lines, references });
});
test('log: logFor hides the opponent\'s draws', () => {
const forAlice = renderLog(record, 0).lines.map(l => l.text);
const forBob = renderLog(record, 1).lines.map(l => l.text);
const turn2Alice = forAlice[forAlice.indexOf('Turn 2.') + 1];
const turn2Bob = forBob[forBob.indexOf('Turn 2.') + 1];
assert.doesNotMatch(turn2Alice, /Gold Coast/);
assert.match(turn2Alice, /^bob (drew a card|drew one card|added a card to their hand)\.$/);
assert.match(turn2Bob, /Gold Coast/);
// alice sees her own draw of Dichromorpha viridis by name
assert.ok(forAlice.some(t => /alice.*Dichromorpha viridis|Dichromorpha viridis.*alice/.test(t) && /drew|drawn|hand/.test(t)));
});
test('log: discards are public (Deleted is a public zone)', () => {
const forAlice = renderLog(record, 0).lines.map(l => l.text);
assert.ok(forAlice.some(t => /Agda \(programming language\)/.test(t) && /discard|Deleted/.test(t)));
});
test('determinism: same seed gives the same text; another seed varies it', () => {
assert.deepEqual(recap(record), recap(structuredClone(record)));
const other = recap({ ...record, seed: 'another-seed' });
const a = renderLog(record).lines.map(l => l.text).join('\n');
const b = renderLog({ ...record, seed: 'another-seed' }).lines.map(l => l.text).join('\n');
assert.notEqual(a, b);
assert.equal(other.title, recap(record).title); // the name is data, not a variant
});
test('recap naming: Event fallback, Figure campaign, prefixes, and the decisive and withdrawal results', () => {
const base = { ...record, cards };
const short: MatchRecord = { ...base, events: [
T(1), { kind: 'cast', seat: 0, card: 'b6' }, { kind: 'deploy', seat: 0, card: 'a3' },
T(2), { kind: 'gameOver', winner: 0, reason: 'concede', turn: 2 },
] };
const r1 = recap(short);
assert.equal(r1.title, 'Skirmish at 2025 Tehreek-e-Labbaik Pakistan protests (2026)');
assert.equal(r1.infobox.result, 'alice victory by withdrawal');
assert.equal(r1.infobox.location, 'WikiDeck host testnet-r350');
const figOnly: MatchRecord = { ...base, events: [
T(1), { kind: 'deploy', seat: 1, card: 'b3' },
T(2), { kind: 'playerDamage', seat: 0, amount: 20, life: 0 }, { kind: 'gameOver', winner: 1, reason: 'life', turn: 2 },
] };
const r2 = recap(figOnly);
assert.equal(r2.title, 'Marc Fesneau campaign (2026)');
assert.equal(r2.infobox.result, 'Decisive bob victory');
const empty: MatchRecord = { ...base, events: [T(1), { kind: 'gameOver', winner: 1, reason: 'timeout', turn: 1 }] };
assert.equal(recap(empty).title, 'WikiDeck match of 17 November 2026');
});
test('tone lint: templates are deadpan (DUEL_DESIGN §8.1, critic S7)', () => {
for (const [key, variants] of Object.entries(LOG_TEMPLATES)) {
assert.ok(variants.length >= 3 && variants.length <= 4, `${key} has ${variants.length} variants`);
for (const v of variants) {
assert.doesNotMatch(v, /!/, `${key}: no exclamation marks`);
for (const w of BANNED_WORDS) assert.doesNotMatch(v.toLowerCase(), new RegExp(`\\b${w}\\b`), `${key}: banned word ${w}`);
assert.doesNotMatch(v, /[\u{1F300}-\u{1FAFF}]/u, `${key}: no emoji`);
}
}
const r = recap(record);
const prose = [r.lead, ...r.sections.flatMap(s => s.paragraphs)].join(' ')
.replace(/\*[^*]+\*/g, 'CARD'); // card titles are data; lint only our words
for (const w of BANNED_WORDS) assert.doesNotMatch(prose.toLowerCase(), new RegExp(`\\b${w}\\b`));
assert.doesNotMatch(prose, /!/);
assert.doesNotMatch(prose, /Wikipedia|Wikimedia/); // branding: only in references and the footer
});
test('every sample description glosses without throwing; dates format', () => {
for (const c of sample.cards) assert.equal(typeof gloss(c.description ?? ''), 'string');
assert.equal(gloss('American actor (1909–1994)'), 'American actor, 1909–1994');
assert.equal(gloss(''), '');
assert.equal(longDate('2026-01-05'), '5 January 2026');
});
test('story code is pure: no network or clock access', () => {
const dir = new URL('../shared/duel/story/', import.meta.url);
for (const f of readdirSync(dir)) {
const src = readFileSync(new URL(f, dir), 'utf8');
assert.doesNotMatch(src, /\bfetch\(|XMLHttpRequest|node:http|Date\.now|new Date\(|Math\.random/, f);
}
});
test('golden: full log and recap prose match tests/duel-design-story.golden.json', () => {
// To regenerate after a deliberate template change, dump { log, lead, sections } and review the diff.
const golden = JSON.parse(readFileSync(new URL('./duel-design-story.golden.json', import.meta.url), 'utf8'));
const r = recap(record);
assert.deepEqual({ log: logParagraphs(renderLog(record).lines), lead: r.lead, sections: r.sections }, golden);
});
test('tokens are named plainly and never cited; draws are recorded as inconclusive', () => {
const withToken: MatchRecord = {
...record,
cards: { ...cards, 't:1': { id: 't:1', title: 'Elected Member', type: 'Figure', cost: 0, portal: 'Society', owner: 1, token: true } },
events: [
T(1), { kind: 'cast', seat: 1, card: 'b1' },
{ kind: 'tokenCreated', seat: 1, source: 'b1', token: 'Elected Member', count: 1 },
T(2), { kind: 'attack', seat: 1, card: 't:1', power: 1, toughness: 1 },
{ kind: 'playerDamage', seat: 0, source: 't:1', amount: 20, life: 0 },
{ kind: 'playerDamage', seat: 1, amount: 20, life: 0 },
{ kind: 'gameOver', winner: null, reason: 'life', turn: 2 },
],
};
const { lines, references } = renderLog(withToken);
assert.ok(lines.some(l => /Elected Member \(1\/1\)/.test(l.text) && !/\*Elected Member\*/.test(l.text)));
assert.deepEqual(references.map(r => r.title), ['1954 Gold Coast general election']);
assert.match(lines[lines.length - 1].text, /draw|No winner/);
const r = recap(withToken);
assert.equal(r.infobox.result, 'Inconclusive');
assert.match(r.lead, /ended in a draw\./);
assert.ok(r.references.every(x => x.revisionId !== undefined));
});
test('final Notability: lifeGain is tracked, and gameOver.life wins when present', () => {
const ev: StoryEvent[] = [
T(1), { kind: 'deploy', seat: 0, card: 'a2' },
{ kind: 'playerDamage', seat: 0, amount: 18, life: 2 },
{ kind: 'lifeGain', seat: 0, source: 'a2', amount: 10, life: 12 },
{ kind: 'playerDamage', seat: 1, amount: 20, life: 0 },
{ kind: 'gameOver', winner: 0, reason: 'life', turn: 1 },
];
const r = recap({ ...record, events: ev });
assert.equal(r.infobox.result, 'Decisive alice victory'); // 12 vs 0, not Pyrrhic at 2
assert.ok(renderLog({ ...record, events: ev }).lines.some(l => /Notability/.test(l.text) && /12/.test(l.text)));
const withFinal = recap({ ...record, events: [...ev.slice(0, -1), { kind: 'gameOver', winner: 0, reason: 'life', turn: 1, life: [3, 0] }] });
assert.equal(withFinal.infobox.result, 'Pyrrhic alice victory');
});