wehub-resource-sync
070959e133
landing-page-staging / Deploy landing page to staging (push) Has been skipped
landing-page-ci / Validate landing page (push) Failing after 4s
visual-baseline / Capture visual baselines (push) Has been cancelled
bake-plugin-previews / Bake plugin previews (push) Has been cancelled
633 lines
27 KiB
TypeScript
633 lines
27 KiB
TypeScript
import { describe, expect, it } from 'vitest';
|
|
import { readFileSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import type { PanelEvent } from '@open-design/contracts/critique';
|
|
import { parseCritiqueStream } from '../src/critique/parser.js';
|
|
import {
|
|
MalformedBlockError,
|
|
OversizeBlockError,
|
|
MissingArtifactError,
|
|
} from '../src/critique/errors.js';
|
|
|
|
function fixture(name: string): string {
|
|
return readFileSync(
|
|
join(__dirname, '..', 'src', 'critique', '__fixtures__', 'v1', name),
|
|
'utf8',
|
|
);
|
|
}
|
|
|
|
async function* chunkify(s: string, size = 64): AsyncGenerator<string> {
|
|
for (let i = 0; i < s.length; i += size) yield s.slice(i, i + size);
|
|
}
|
|
|
|
async function collect(iter: AsyncIterable<PanelEvent>): Promise<PanelEvent[]> {
|
|
const out: PanelEvent[] = [];
|
|
for await (const e of iter) out.push(e);
|
|
return out;
|
|
}
|
|
|
|
describe('parseCritiqueStream -- happy', () => {
|
|
const happy = fixture('happy-3-rounds.txt');
|
|
|
|
it('emits run_started, exactly 3 round_end, and 1 ship for the happy fixture', async () => {
|
|
const events = await collect(parseCritiqueStream(chunkify(happy), {
|
|
runId: 't1', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
}));
|
|
expect(events.find(e => e.type === 'run_started')).toBeDefined();
|
|
expect(events.filter(e => e.type === 'round_end').length).toBe(3);
|
|
expect(events.filter(e => e.type === 'ship').length).toBe(1);
|
|
});
|
|
|
|
it('emits panelist_open before any panelist_dim within the same role and round', async () => {
|
|
const events = await collect(parseCritiqueStream(chunkify(happy), {
|
|
runId: 't1', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
}));
|
|
const opened = new Set<string>();
|
|
for (const e of events) {
|
|
if (e.type === 'panelist_open') opened.add(`${e.round}:${e.role}`);
|
|
if (e.type === 'panelist_dim') {
|
|
expect(opened.has(`${e.round}:${e.role}`)).toBe(true);
|
|
}
|
|
}
|
|
});
|
|
|
|
it('emits panelist_close after panelist_dim and panelist_must_fix for the same role/round', async () => {
|
|
const events = await collect(parseCritiqueStream(chunkify(happy), {
|
|
runId: 't1', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
}));
|
|
const lastEventForKey = new Map<string, string>();
|
|
for (const e of events) {
|
|
if (
|
|
e.type === 'panelist_open' ||
|
|
e.type === 'panelist_dim' ||
|
|
e.type === 'panelist_must_fix' ||
|
|
e.type === 'panelist_close'
|
|
) {
|
|
lastEventForKey.set(`${e.round}:${e.role}`, e.type);
|
|
}
|
|
}
|
|
for (const value of lastEventForKey.values()) {
|
|
expect(value).toBe('panelist_close');
|
|
}
|
|
});
|
|
|
|
it('happy fixture parses identically when chunked at 1 byte vs 64 bytes vs all-at-once', async () => {
|
|
const a = await collect(parseCritiqueStream(chunkify(happy, 1), { runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144 }));
|
|
const b = await collect(parseCritiqueStream(chunkify(happy, 64), { runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144 }));
|
|
const c = await collect(parseCritiqueStream(chunkify(happy, 1 << 20),{ runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144 }));
|
|
// Strip parser_warning because positions vary by chunk size
|
|
const strip = (xs: PanelEvent[]) => xs.filter(e => e.type !== 'parser_warning');
|
|
expect(strip(a)).toEqual(strip(b));
|
|
expect(strip(b)).toEqual(strip(c));
|
|
});
|
|
|
|
it('ship event has shipped status and matches happy round=3, composite >= 8.0', async () => {
|
|
const events = await collect(parseCritiqueStream(chunkify(happy), {
|
|
runId: 't1', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
}));
|
|
const ship = events.find(e => e.type === 'ship');
|
|
expect(ship).toBeDefined();
|
|
if (ship && ship.type === 'ship') {
|
|
expect(ship.status).toBe('shipped');
|
|
expect(ship.round).toBe(3);
|
|
expect(ship.composite).toBeGreaterThanOrEqual(8.0);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('parseCritiqueStream -- failure modes', () => {
|
|
it('throws MalformedBlockError on unbalanced tags', async () => {
|
|
const text = fixture('malformed-unbalanced.txt');
|
|
await expect(collect(parseCritiqueStream(chunkify(text), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
}))).rejects.toBeInstanceOf(MalformedBlockError);
|
|
});
|
|
|
|
it('throws OversizeBlockError when a single block exceeds the cap', async () => {
|
|
const text = fixture('malformed-oversize.txt');
|
|
await expect(collect(parseCritiqueStream(chunkify(text), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
}))).rejects.toBeInstanceOf(OversizeBlockError);
|
|
});
|
|
|
|
it('throws MissingArtifactError when designer round 1 has no <ARTIFACT>', async () => {
|
|
const text = fixture('missing-artifact.txt');
|
|
await expect(collect(parseCritiqueStream(chunkify(text), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
}))).rejects.toBeInstanceOf(MissingArtifactError);
|
|
});
|
|
|
|
it('emits parser_warning with kind=duplicate_ship and keeps the first SHIP', async () => {
|
|
const text = fixture('duplicate-ship.txt');
|
|
const events = await collect(parseCritiqueStream(chunkify(text), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
}));
|
|
expect(events.filter(e => e.type === 'ship').length).toBe(1);
|
|
expect(
|
|
events.find(e => e.type === 'parser_warning' && e.kind === 'duplicate_ship')
|
|
).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe('parseCritiqueStream -- review-driven invariants', () => {
|
|
it('rejects a PANELIST that appears before any <ROUND n="..."> opens', async () => {
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="3" threshold="8.0" scale="10">
|
|
<PANELIST role="critic" score="6.4"><DIM name="contrast" score="4">x</DIM></PANELIST>
|
|
</CRITIQUE_RUN>`;
|
|
await expect(
|
|
collect(parseCritiqueStream(chunkify(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
})),
|
|
).rejects.toBeInstanceOf(MalformedBlockError);
|
|
});
|
|
|
|
it('clamps a panelist score against the run-declared scale, not 100', async () => {
|
|
// scale=10 so a score of 42 is out of range and should clamp + emit a warning.
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="3" threshold="8.0" scale="10">
|
|
<ROUND n="1">
|
|
<PANELIST role="designer">
|
|
<NOTES>v1 draft</NOTES>
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>v1</p>]]></ARTIFACT>
|
|
</PANELIST>
|
|
<PANELIST role="critic" score="42">
|
|
<DIM name="contrast" score="42">over scale</DIM>
|
|
</PANELIST>
|
|
<PANELIST role="brand" score="8"><DIM name="palette" score="8">ok</DIM></PANELIST>
|
|
<PANELIST role="a11y" score="8"><DIM name="contrast" score="8">ok</DIM></PANELIST>
|
|
<PANELIST role="copy" score="8"><DIM name="voice" score="8">ok</DIM></PANELIST>
|
|
<ROUND_END n="1" composite="8" must_fix="0" decision="ship"><REASON>ok</REASON></ROUND_END>
|
|
</ROUND>
|
|
<SHIP round="1" composite="8" status="shipped">
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>final</p>]]></ARTIFACT>
|
|
<SUMMARY>ok</SUMMARY>
|
|
</SHIP>
|
|
</CRITIQUE_RUN>`;
|
|
const events = await collect(parseCritiqueStream(chunkify(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
}));
|
|
const critic = events.find(
|
|
e => e.type === 'panelist_close' && e.role === 'critic',
|
|
);
|
|
expect(critic).toBeDefined();
|
|
if (critic && critic.type === 'panelist_close') {
|
|
// Clamped to scale=10, not the legacy 100 ceiling.
|
|
expect(critic.score).toBe(10);
|
|
}
|
|
const dim = events.find(
|
|
e => e.type === 'panelist_dim' && e.role === 'critic' && e.dimName === 'contrast',
|
|
);
|
|
expect(dim).toBeDefined();
|
|
if (dim && dim.type === 'panelist_dim') {
|
|
expect(dim.dimScore).toBe(10);
|
|
}
|
|
expect(
|
|
events.filter(e => e.type === 'parser_warning' && e.kind === 'score_clamped').length,
|
|
).toBeGreaterThanOrEqual(1);
|
|
});
|
|
|
|
it('still ships when scale=20 and threshold=18 is below the cap', async () => {
|
|
// Confirms scale plumbing flows past the parser without losing the value.
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="3" threshold="18" scale="20">
|
|
<ROUND n="1">
|
|
<PANELIST role="designer">
|
|
<NOTES>scale-20 draft</NOTES>
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>v1</p>]]></ARTIFACT>
|
|
</PANELIST>
|
|
<PANELIST role="critic" score="19"><DIM name="hierarchy" score="19">strong</DIM></PANELIST>
|
|
<PANELIST role="brand" score="18"><DIM name="palette" score="18">ok</DIM></PANELIST>
|
|
<PANELIST role="a11y" score="18"><DIM name="contrast" score="18">ok</DIM></PANELIST>
|
|
<PANELIST role="copy" score="18"><DIM name="voice" score="18">ok</DIM></PANELIST>
|
|
<ROUND_END n="1" composite="18.4" must_fix="0" decision="ship"><REASON>ok</REASON></ROUND_END>
|
|
</ROUND>
|
|
<SHIP round="1" composite="18.4" status="shipped">
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>final</p>]]></ARTIFACT>
|
|
<SUMMARY>ok</SUMMARY>
|
|
</SHIP>
|
|
</CRITIQUE_RUN>`;
|
|
const events = await collect(parseCritiqueStream(chunkify(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
}));
|
|
const run = events.find(e => e.type === 'run_started');
|
|
expect(run).toBeDefined();
|
|
if (run && run.type === 'run_started') expect(run.scale).toBe(20);
|
|
expect(
|
|
events.filter(e => e.type === 'parser_warning' && e.kind === 'score_clamped').length,
|
|
).toBe(0);
|
|
expect(events.find(e => e.type === 'ship')).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe('parseCritiqueStream -- per-block size enforcement (mrcfps review)', () => {
|
|
// Yield the whole stream in one chunk, mimicking a transport that batches the
|
|
// model output. Without per-block enforcement the body would be sliced and
|
|
// emitted before drain returned, bypassing the post-drain buf-size check.
|
|
async function* oneChunk(s: string): AsyncGenerator<string> { yield s; }
|
|
|
|
it('throws OversizeBlockError for a complete oversized PANELIST arriving in one chunk', async () => {
|
|
const cap = 4096;
|
|
const giantNote = 'x'.repeat(cap + 1024);
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="3" threshold="8.0" scale="10">
|
|
<ROUND n="1">
|
|
<PANELIST role="designer">
|
|
<NOTES>${giantNote}</NOTES>
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>v1</p>]]></ARTIFACT>
|
|
</PANELIST>
|
|
</ROUND>
|
|
</CRITIQUE_RUN>`;
|
|
await expect(
|
|
collect(parseCritiqueStream(oneChunk(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: cap,
|
|
})),
|
|
).rejects.toBeInstanceOf(OversizeBlockError);
|
|
});
|
|
|
|
it('throws OversizeBlockError for the malformed-oversize fixture parsed all-at-once', async () => {
|
|
const text = fixture('malformed-oversize.txt');
|
|
await expect(
|
|
collect(parseCritiqueStream(oneChunk(text), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
})),
|
|
).rejects.toBeInstanceOf(OversizeBlockError);
|
|
});
|
|
|
|
it('throws OversizeBlockError for a complete oversized SHIP arriving in one chunk', async () => {
|
|
const cap = 4096;
|
|
const giantSummary = 'y'.repeat(cap + 512);
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="3" threshold="8.0" scale="10">
|
|
<ROUND n="1">
|
|
<PANELIST role="designer">
|
|
<NOTES>v1</NOTES>
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>v1</p>]]></ARTIFACT>
|
|
</PANELIST>
|
|
<PANELIST role="critic" score="8"><DIM name="contrast" score="8">ok</DIM></PANELIST>
|
|
<PANELIST role="brand" score="8"><DIM name="palette" score="8">ok</DIM></PANELIST>
|
|
<PANELIST role="a11y" score="8"><DIM name="contrast" score="8">ok</DIM></PANELIST>
|
|
<PANELIST role="copy" score="8"><DIM name="voice" score="8">ok</DIM></PANELIST>
|
|
<ROUND_END n="1" composite="8" must_fix="0" decision="ship"><REASON>ok</REASON></ROUND_END>
|
|
</ROUND>
|
|
<SHIP round="1" composite="8" status="shipped">
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>final</p>]]></ARTIFACT>
|
|
<SUMMARY>${giantSummary}</SUMMARY>
|
|
</SHIP>
|
|
</CRITIQUE_RUN>`;
|
|
await expect(
|
|
collect(parseCritiqueStream(oneChunk(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: cap,
|
|
})),
|
|
).rejects.toBeInstanceOf(OversizeBlockError);
|
|
});
|
|
});
|
|
|
|
describe('parseCritiqueStream -- v1 envelope and shape invariants (mrcfps review 2)', () => {
|
|
async function* oneChunk(s: string): AsyncGenerator<string> { yield s; }
|
|
|
|
it('throws MalformedBlockError when ROUND appears before any <CRITIQUE_RUN>', async () => {
|
|
const stream = `<ROUND n="1">
|
|
<PANELIST role="critic" score="6"><DIM name="contrast" score="4">x</DIM></PANELIST>
|
|
</ROUND>`;
|
|
await expect(
|
|
collect(parseCritiqueStream(oneChunk(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
})),
|
|
).rejects.toBeInstanceOf(MalformedBlockError);
|
|
});
|
|
|
|
it('throws MalformedBlockError when SHIP appears before any <CRITIQUE_RUN>', async () => {
|
|
const stream = `<SHIP round="1" composite="8" status="shipped">
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>x</p>]]></ARTIFACT>
|
|
<SUMMARY>x</SUMMARY>
|
|
</SHIP>`;
|
|
await expect(
|
|
collect(parseCritiqueStream(oneChunk(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
})),
|
|
).rejects.toBeInstanceOf(MalformedBlockError);
|
|
});
|
|
|
|
it('measures parserMaxBlockBytes as UTF-8 bytes, so multibyte content over the byte cap fails', async () => {
|
|
const cap = 4096;
|
|
// Each CJK char encodes to 3 UTF-8 bytes. 1500 chars = 4500 bytes, over the
|
|
// 4096-byte cap, but the JS string length is only 1500, well under the cap.
|
|
// The pre-fix code (string-length comparison) would let this through.
|
|
const giant = '汉'.repeat(1500);
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="3" threshold="8.0" scale="10">
|
|
<ROUND n="1">
|
|
<PANELIST role="designer">
|
|
<NOTES>${giant}</NOTES>
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>v1</p>]]></ARTIFACT>
|
|
</PANELIST>
|
|
</ROUND>
|
|
</CRITIQUE_RUN>`;
|
|
await expect(
|
|
collect(parseCritiqueStream(oneChunk(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: cap,
|
|
})),
|
|
).rejects.toBeInstanceOf(OversizeBlockError);
|
|
});
|
|
|
|
it('throws MalformedBlockError when a PANELIST opener has no > before </PANELIST>', async () => {
|
|
// The opening tag is missing its closing >. Without the headEnd-ordering
|
|
// guard the parser would pick up the > of </PANELIST> as the opener end
|
|
// and emit panelist events for an invalid block.
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="3" threshold="8.0" scale="10">
|
|
<ROUND n="1">
|
|
<PANELIST role="critic" score="8"</PANELIST>
|
|
</ROUND>
|
|
</CRITIQUE_RUN>`;
|
|
await expect(
|
|
collect(parseCritiqueStream(oneChunk(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
})),
|
|
).rejects.toBeInstanceOf(MalformedBlockError);
|
|
});
|
|
});
|
|
|
|
describe('parseCritiqueStream -- Defects 3+5 regressions', () => {
|
|
async function* oneChunk(s: string): AsyncGenerator<string> { yield s; }
|
|
|
|
it('SHIP before any ROUND_END throws MalformedBlockError (Defect 5)', async () => {
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="3" threshold="8.0" scale="10">
|
|
<SHIP round="1" composite="9" status="shipped">
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>x</p>]]></ARTIFACT>
|
|
<SUMMARY>skipped rounds</SUMMARY>
|
|
</SHIP>
|
|
</CRITIQUE_RUN>`;
|
|
await expect(
|
|
collect(parseCritiqueStream(oneChunk(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
})),
|
|
).rejects.toBeInstanceOf(MalformedBlockError);
|
|
});
|
|
|
|
it('SHIP without inner <ARTIFACT> throws MissingArtifactError (Defect 5)', async () => {
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="3" threshold="8.0" scale="10">
|
|
<ROUND n="1">
|
|
<PANELIST role="designer">
|
|
<NOTES>v1</NOTES>
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>v1</p>]]></ARTIFACT>
|
|
</PANELIST>
|
|
<PANELIST role="critic" score="9"><DIM name="h" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="brand" score="9"><DIM name="v" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="a11y" score="9"><DIM name="c" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="copy" score="9"><DIM name="cl" score="9">ok</DIM></PANELIST>
|
|
<ROUND_END n="1" composite="9" must_fix="0" decision="ship"><REASON>ok</REASON></ROUND_END>
|
|
</ROUND>
|
|
<SHIP round="1" composite="9" status="shipped">
|
|
<SUMMARY>no artifact block here</SUMMARY>
|
|
</SHIP>
|
|
</CRITIQUE_RUN>`;
|
|
await expect(
|
|
collect(parseCritiqueStream(oneChunk(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
})),
|
|
).rejects.toBeInstanceOf(MissingArtifactError);
|
|
});
|
|
|
|
it('artifactRef is populated from parser options projectId+artifactId (Defect 3)', async () => {
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="3" threshold="8.0" scale="10">
|
|
<ROUND n="1">
|
|
<PANELIST role="designer">
|
|
<NOTES>v1</NOTES>
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>v1</p>]]></ARTIFACT>
|
|
</PANELIST>
|
|
<PANELIST role="critic" score="9"><DIM name="h" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="brand" score="9"><DIM name="v" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="a11y" score="9"><DIM name="c" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="copy" score="9"><DIM name="cl" score="9">ok</DIM></PANELIST>
|
|
<ROUND_END n="1" composite="9" must_fix="0" decision="ship"><REASON>ok</REASON></ROUND_END>
|
|
</ROUND>
|
|
<SHIP round="1" composite="9" status="shipped">
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>final</p>]]></ARTIFACT>
|
|
<SUMMARY>done</SUMMARY>
|
|
</SHIP>
|
|
</CRITIQUE_RUN>`;
|
|
const events = await collect(parseCritiqueStream(oneChunk(stream), {
|
|
runId: 't', adapter: 'test', parserMaxBlockBytes: 262_144,
|
|
projectId: 'p1', artifactId: 'a1',
|
|
}));
|
|
const ship = events.find(e => e.type === 'ship');
|
|
expect(ship).toBeDefined();
|
|
if (ship && ship.type === 'ship') {
|
|
expect(ship.artifactRef.projectId).toBe('p1');
|
|
expect(ship.artifactRef.artifactId).toBe('a1');
|
|
}
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// SHIP <ARTIFACT> body extraction
|
|
//
|
|
// The earlier extractor used a single `<ARTIFACT\b([^>]*)>([\s\S]*?)</ARTIFACT>`
|
|
// match, which truncated at the first literal `</ARTIFACT>` inside the
|
|
// body. Real shipped HTML / SVG / JS bodies wrapped in CDATA can legitimately
|
|
// contain that sentinel inside a string or comment. The CDATA-aware
|
|
// extractor scans for `]]></ARTIFACT>` instead so the round-trip preserves
|
|
// arbitrary bytes the agent shipped (mrcfps follow-up on PR #1085).
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('parseCritiqueStream -- SHIP <ARTIFACT> CDATA-aware extraction', () => {
|
|
// Build a minimal complete v1 stream around a SHIP whose <ARTIFACT> body
|
|
// is the literal text we want to test.
|
|
function streamWithArtifact(body: string, mime = 'text/html'): string {
|
|
return `<CRITIQUE_RUN version="1" maxRounds="1" threshold="8.0" scale="10">
|
|
<ROUND n="1">
|
|
<PANELIST role="designer">
|
|
<NOTES>v1</NOTES>
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>v1</p>]]></ARTIFACT>
|
|
</PANELIST>
|
|
<PANELIST role="critic" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="brand" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="a11y" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="copy" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<ROUND_END n="1" composite="9" must_fix="0" decision="ship"><REASON>ok</REASON></ROUND_END>
|
|
</ROUND>
|
|
<SHIP round="1" composite="9" status="shipped">
|
|
<ARTIFACT mime="${mime}">${body}</ARTIFACT>
|
|
<SUMMARY>Done.</SUMMARY>
|
|
</SHIP>
|
|
</CRITIQUE_RUN>`;
|
|
}
|
|
|
|
it('preserves a CDATA-wrapped JS body that contains the literal `</ARTIFACT>` sentinel inside a string', async () => {
|
|
const dangerousBody = `<![CDATA[<script>const s = "</ARTIFACT>";</script>]]>`;
|
|
const captured: Array<{ round: number; mime: string; body: string }> = [];
|
|
await collect(
|
|
parseCritiqueStream(chunkify(streamWithArtifact(dangerousBody)), {
|
|
runId: 't-cdata',
|
|
adapter: 'test',
|
|
parserMaxBlockBytes: 262_144,
|
|
onArtifact: (info) => captured.push(info),
|
|
}),
|
|
);
|
|
|
|
expect(captured).toHaveLength(1);
|
|
// The CDATA wrapper is stripped; the embedded `</ARTIFACT>` sentinel
|
|
// travels through verbatim and the writer would persist it byte-for-byte.
|
|
expect(captured[0]?.body).toBe(`<script>const s = "</ARTIFACT>";</script>`);
|
|
expect(captured[0]?.mime).toBe('text/html');
|
|
});
|
|
|
|
it('preserves a CDATA body that contains the literal `</ARTIFACT>` sentinel inside an HTML comment', async () => {
|
|
const body = `<![CDATA[<!-- bookmark: </ARTIFACT> --><p>real</p>]]>`;
|
|
const captured: Array<{ round: number; mime: string; body: string }> = [];
|
|
await collect(
|
|
parseCritiqueStream(chunkify(streamWithArtifact(body)), {
|
|
runId: 't-cdata-comment',
|
|
adapter: 'test',
|
|
parserMaxBlockBytes: 262_144,
|
|
onArtifact: (info) => captured.push(info),
|
|
}),
|
|
);
|
|
|
|
expect(captured).toHaveLength(1);
|
|
expect(captured[0]?.body).toBe(`<!-- bookmark: </ARTIFACT> --><p>real</p>`);
|
|
});
|
|
|
|
it('still extracts a non-CDATA inline body that does NOT contain the sentinel', async () => {
|
|
const body = `<p>plain inline body</p>`;
|
|
const captured: Array<{ round: number; mime: string; body: string }> = [];
|
|
await collect(
|
|
parseCritiqueStream(chunkify(streamWithArtifact(body)), {
|
|
runId: 't-inline',
|
|
adapter: 'test',
|
|
parserMaxBlockBytes: 262_144,
|
|
onArtifact: (info) => captured.push(info),
|
|
}),
|
|
);
|
|
|
|
expect(captured).toHaveLength(1);
|
|
expect(captured[0]?.body).toBe(`<p>plain inline body</p>`);
|
|
});
|
|
|
|
it('tolerates whitespace between the `]]>` CDATA terminator and `</ARTIFACT>`', async () => {
|
|
const body = `<![CDATA[<p>spaced</p>]]>\n `;
|
|
// Intentionally insert a newline + spaces between the CDATA close and
|
|
// the `</ARTIFACT>` tag so a regex that requires the close to be
|
|
// immediately followed by `</ARTIFACT>` would miss it.
|
|
const stream = `<CRITIQUE_RUN version="1" maxRounds="1" threshold="8.0" scale="10">
|
|
<ROUND n="1">
|
|
<PANELIST role="designer">
|
|
<NOTES>v1</NOTES>
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>v1</p>]]></ARTIFACT>
|
|
</PANELIST>
|
|
<PANELIST role="critic" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="brand" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="a11y" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="copy" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<ROUND_END n="1" composite="9" must_fix="0" decision="ship"><REASON>ok</REASON></ROUND_END>
|
|
</ROUND>
|
|
<SHIP round="1" composite="9" status="shipped">
|
|
<ARTIFACT mime="text/html">${body}
|
|
</ARTIFACT>
|
|
<SUMMARY>Done.</SUMMARY>
|
|
</SHIP>
|
|
</CRITIQUE_RUN>`;
|
|
|
|
const captured: Array<{ round: number; mime: string; body: string }> = [];
|
|
await collect(
|
|
parseCritiqueStream(chunkify(stream), {
|
|
runId: 't-pretty',
|
|
adapter: 'test',
|
|
parserMaxBlockBytes: 262_144,
|
|
onArtifact: (info) => captured.push(info),
|
|
}),
|
|
);
|
|
|
|
expect(captured).toHaveLength(1);
|
|
expect(captured[0]?.body).toBe('<p>spaced</p>');
|
|
});
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// SHIP boundary sentinel safety
|
|
//
|
|
// The parser walks the SHIP block by `indexOf('</SHIP>')` and the ship
|
|
// summary by `<SUMMARY>` regex on the SHIP inner. Both used to be
|
|
// non-CDATA-aware, so an agent shipping arbitrary HTML / JS bodies that
|
|
// happened to contain those literal sentinels inside a CDATA wrapper
|
|
// could either truncate the SHIP block early (lefarcen P2) or hijack the
|
|
// ship summary text (mrcfps follow-up). Both lookups now skip CDATA
|
|
// spans, so the streamed bytes round-trip intact and the sibling tags
|
|
// resolve to the real outer occurrences.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
describe('parseCritiqueStream -- SHIP sentinel safety inside CDATA', () => {
|
|
function streamWithArtifactAndSummary(
|
|
artifactBody: string,
|
|
summary: string,
|
|
): string {
|
|
return `<CRITIQUE_RUN version="1" maxRounds="1" threshold="8.0" scale="10">
|
|
<ROUND n="1">
|
|
<PANELIST role="designer">
|
|
<NOTES>v1</NOTES>
|
|
<ARTIFACT mime="text/html"><![CDATA[<p>v1</p>]]></ARTIFACT>
|
|
</PANELIST>
|
|
<PANELIST role="critic" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="brand" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="a11y" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<PANELIST role="copy" score="9"><DIM name="x" score="9">ok</DIM></PANELIST>
|
|
<ROUND_END n="1" composite="9" must_fix="0" decision="ship"><REASON>ok</REASON></ROUND_END>
|
|
</ROUND>
|
|
<SHIP round="1" composite="9" status="shipped">
|
|
<ARTIFACT mime="text/html">${artifactBody}</ARTIFACT>
|
|
<SUMMARY>${summary}</SUMMARY>
|
|
</SHIP>
|
|
</CRITIQUE_RUN>`;
|
|
}
|
|
|
|
it('uses the real ship summary even when the artifact CDATA contains a literal <SUMMARY> pair before it', async () => {
|
|
// The artifact body contains `<SUMMARY>artifact text</SUMMARY>` BEFORE
|
|
// the real sibling SUMMARY. A naive regex against the full SHIP inner
|
|
// would grab the artifact-internal pair first and emit "artifact text"
|
|
// as the ship summary.
|
|
const artifactBody =
|
|
`<![CDATA[<div><SUMMARY>artifact text</SUMMARY></div><p>real artifact body</p>]]>`;
|
|
const realSummary = 'Design converged after one round.';
|
|
|
|
const events = await collect(
|
|
parseCritiqueStream(chunkify(streamWithArtifactAndSummary(artifactBody, realSummary)), {
|
|
runId: 't-summary-hijack',
|
|
adapter: 'test',
|
|
parserMaxBlockBytes: 262_144,
|
|
}),
|
|
);
|
|
|
|
const ship = events.find((e) => e.type === 'ship');
|
|
expect(ship).toBeDefined();
|
|
if (ship && ship.type === 'ship') {
|
|
expect(ship.summary).toBe(realSummary);
|
|
}
|
|
});
|
|
|
|
it('finds the real </SHIP> closer even when the artifact CDATA contains a literal </SHIP> string', async () => {
|
|
// The artifact body contains `</SHIP>` inside a JS string. A naive
|
|
// `slice.indexOf('</SHIP>')` would treat that as the SHIP closer,
|
|
// truncating before the real `</ARTIFACT>` and `</SUMMARY>` siblings
|
|
// and leaving the parser in a corrupted state.
|
|
const artifactBody =
|
|
`<![CDATA[<script>const s = "</SHIP>";</script><p>real body</p>]]>`;
|
|
const realSummary = 'Honored the closer outside CDATA.';
|
|
|
|
const captured: Array<{ round: number; mime: string; body: string }> = [];
|
|
const events = await collect(
|
|
parseCritiqueStream(chunkify(streamWithArtifactAndSummary(artifactBody, realSummary)), {
|
|
runId: 't-ship-close-hijack',
|
|
adapter: 'test',
|
|
parserMaxBlockBytes: 262_144,
|
|
onArtifact: (info) => captured.push(info),
|
|
}),
|
|
);
|
|
|
|
expect(captured).toHaveLength(1);
|
|
expect(captured[0]?.body).toBe(
|
|
`<script>const s = "</SHIP>";</script><p>real body</p>`,
|
|
);
|
|
|
|
const ship = events.find((e) => e.type === 'ship');
|
|
expect(ship).toBeDefined();
|
|
if (ship && ship.type === 'ship') {
|
|
expect(ship.summary).toBe(realSummary);
|
|
}
|
|
});
|
|
});
|