From 43a370aed163f4fd4614f50d3b729aabab7c3f10 Mon Sep 17 00:00:00 2001 From: bchanot Date: Wed, 14 Oct 2026 23:55:22 +0200 Subject: [PATCH] feat(anatomy): text and output caps, hostile corpus through the shipped wasm within budgets; SheetSession poisons on non-closed throws --- crates/core/src/anatomy/svg/sanitize.rs | 9 +- crates/core/src/ops.rs | 5 +- .../tests/fixtures/svg/hostile/long-title.svg | 1 + crates/core/tests/oracles/r3/sanitiser.json | 22 +++ crates/core/tests/svg_sanitiser.rs | 2 + packages/core-wasm/src/runtime.ts | 21 ++- packages/core-wasm/tests/anatomy.test.ts | 149 ++++++++++++++++++ packages/core-wasm/tests/runtime.test.ts | 24 +++ 8 files changed, 227 insertions(+), 6 deletions(-) create mode 100644 crates/core/tests/fixtures/svg/hostile/long-title.svg create mode 100644 packages/core-wasm/tests/anatomy.test.ts diff --git a/crates/core/src/anatomy/svg/sanitize.rs b/crates/core/src/anatomy/svg/sanitize.rs index 015bc3a6..90ff1b18 100644 --- a/crates/core/src/anatomy/svg/sanitize.rs +++ b/crates/core/src/anatomy/svg/sanitize.rs @@ -150,6 +150,9 @@ const PRESENTATION_ATTRIBUTES: [&str; 27] = [ /// The engine's cap on `` elements and on each `stdDeviation` number. pub const MAX_USES: usize = 256; pub const MAX_STD_DEVIATION: f64 = 100.0; +/// A `title` or `desc` text is a tooltip: longer is refused whole (never cut), so a text +/// node cannot inflate the composed view (`>` is written `>`). +pub const MAX_TEXT_BYTES: usize = 4 * 1024; const STYLE_FORBIDDEN: [&str; 5] = [ "expression(", @@ -209,7 +212,11 @@ impl Walk { element.children.push(Node::Element(child)); } Node::Element(child) => self.removed.push(child.qname), - Node::Text(text) if keeps_text || is_xml_space(&text) => { + Node::Text(text) if is_xml_space(&text) => element.children.push(Node::Text(text)), + Node::Text(text) if keeps_text => { + if text.len() > MAX_TEXT_BYTES { + return Err(SvgRejection::TooComplex); + } element.children.push(Node::Text(text)); } Node::Text(_) => {} diff --git a/crates/core/src/ops.rs b/crates/core/src/ops.rs index f3bf5f23..a00e8bcc 100644 --- a/crates/core/src/ops.rs +++ b/crates/core/src/ops.rs @@ -360,8 +360,9 @@ pub struct CanvasView { pub svg: String, } -/// A composed view larger than this is refused (plan R3 C2: output bounded). -pub const MAX_COMPOSED_BYTES: usize = 8 * 1024 * 1024; +/// A composed view larger than this is refused (plan R3 C2: output bounded; the product +/// drawing composes to 143 KiB). +pub const MAX_COMPOSED_BYTES: usize = 4 * 1024 * 1024; fn view_canvas(sheet: &LoadedSheet, input: &str) -> Outcome { let input: CanvasViewInput = parse_input(input)?; diff --git a/crates/core/tests/fixtures/svg/hostile/long-title.svg b/crates/core/tests/fixtures/svg/hostile/long-title.svg new file mode 100644 index 00000000..42a35684 --- /dev/null +++ b/crates/core/tests/fixtures/svg/hostile/long-title.svg @@ -0,0 +1 @@ +xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \ No newline at end of file diff --git a/crates/core/tests/oracles/r3/sanitiser.json b/crates/core/tests/oracles/r3/sanitiser.json index a962b7ac..3799ac9f 100644 --- a/crates/core/tests/oracles/r3/sanitiser.json +++ b/crates/core/tests/oracles/r3/sanitiser.json @@ -498,6 +498,28 @@ ] } }, + "long-title.svg": { + "removed": [], + "tree": { + "ns": "http://www.w3.org/2000/svg", + "name": "svg", + "attrs": { + "xmlns": "http://www.w3.org/2000/svg" + }, + "children": [ + { + "ns": "http://www.w3.org/2000/svg", + "name": "title", + "attrs": {}, + "children": [ + { + "text": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + } + ] + } + ] + } + }, "malformed.svg": { "rejected": "malformed" }, diff --git a/crates/core/tests/svg_sanitiser.rs b/crates/core/tests/svg_sanitiser.rs index 021e4129..463910bf 100644 --- a/crates/core/tests/svg_sanitiser.rs +++ b/crates/core/tests/svg_sanitiser.rs @@ -24,6 +24,8 @@ fn declared(file: &str) -> Option { Some(match file { // C3 reference graph: a `` cycle is refused (TS accepts it). "use-self-cycle.svg" | "use-mutual-cycle.svg" => json!({ "rejected": "reference_cycle" }), + // C3 text: a `title`/`desc` text over 4 KiB is refused whole (TS keeps it). + "long-title.svg" => json!({ "rejected": "too_complex" }), // C3 namespace: `` is removed too (TS keeps it). "namespaces.svg" => json!({ "removed": [ "svg@xmlns:s", "svg@xmlns:inkscape", "s:path", "path", diff --git a/packages/core-wasm/src/runtime.ts b/packages/core-wasm/src/runtime.ts index 2034df5c..3b114ba2 100644 --- a/packages/core-wasm/src/runtime.ts +++ b/packages/core-wasm/src/runtime.ts @@ -172,6 +172,18 @@ export class CoreRuntime { } } +/** + * The detail of a refusal the module's `SheetHandle` constructor threw (crates/wasm: a + * `JsError` worded `: `), without its `invalid_sheet: ` kind; `null` when the + * error is anything else. + */ +function closedRefusal(error: unknown): string | null { + if (!(error instanceof Error) || error.name !== 'Error') return null + const match = /^([a-z_]+): /.exec(error.message) + if (!match) return null + return match[1] === 'invalid_sheet' ? error.message.slice(match[0].length) : error.message +} + /** The calls that need the session's sheet (`SheetHandle` in the module's memory). */ export class SheetSession { private handle: GlueSheetHandle | null = null @@ -209,9 +221,12 @@ export class SheetSession { try { this.handle = new glue.SheetHandle(this.bundleText) } catch (error) { - if (error instanceof WebAssembly.RuntimeError) throw error - const message = error instanceof Error ? error.message : '' - return failure('invalid_sheet', message.replace(/^invalid_sheet: /, '')) + // Only the module's closed refusal (a plain Error worded `: `) is a + // refused sheet; anything else (a trap, an engine stack overflow surfacing as + // RangeError or InternalError) poisons the instance. + const refusal = closedRefusal(error) + if (refusal === null) throw error + return failure('invalid_sheet', refusal) } this.handleGeneration = this.runtime.generation return { ok: true, value: this.handle } diff --git a/packages/core-wasm/tests/anatomy.test.ts b/packages/core-wasm/tests/anatomy.test.ts new file mode 100644 index 00000000..d93c6e8e --- /dev/null +++ b/packages/core-wasm/tests/anatomy.test.ts @@ -0,0 +1,149 @@ +/** + * R3 thresholds (plan rev 2 §5 item 4) on the shipped module: every hostile SVG of the + * corpus, plus generated floods at the caps, loaded as a sheet drawing and composed through + * `view.canvas`, answers a closed outcome with no trap (the instance stays the same), within + * 150 ms and 32 MiB of linear memory growth per case (each case in a fresh instance: the + * application loads one sheet per page; sessions never freed in one instance would add up + * their drawings, an artefact of the loop); the product drawing composes within 15 ms warm. Numbers printed for docs/development/RUST.md §9. + */ +import { readFileSync, readdirSync } from 'node:fs' +import { fileURLToPath } from 'node:url' + +import { CoreRuntime, type GlueModule } from '../src/index' +import { nodeCoreSource } from '../src/node' + +const ROOT = '../../../' +const SEED = `${ROOT}supabase/seed/anatomical-sheets/equine/draft/` +const HOSTILE = `${ROOT}crates/core/tests/fixtures/svg/hostile/` +const HORSE_ID = '7f767f74-3b36-51a7-8465-52dd7e2ead4a' +const path = (p: string) => fileURLToPath(new URL(p, import.meta.url)) +const read = (p: string) => readFileSync(path(p), 'utf8') + +const document = JSON.parse(read(`${SEED}document.json`)) +const migrationMap = JSON.parse(read(`${SEED}report-migration-map.json`)) + +function bundle(horse: string): string { + return JSON.stringify({ + status: 'draft', + ref: { + sheet_id: 'sheet', + version_id: null, + document_sha256: '0'.repeat(64), + schema_version: 2, + species_id: 'equine', + }, + document, + migrationMap, + assets: { [HORSE_ID]: horse }, + assetHashes: { [HORSE_ID]: '0'.repeat(64) }, + }) +} + +const OPEN = '' + +/** Floods at and past the caps: nesting, nodes, markup, attributes, size, references. */ +function floods(): Record { + const attrs = (n: number) => + Array.from({ length: n }, (_, i) => ` a${i}="${i}"`).join('') + let chain = '' + for (let level = 1; level <= 12; level++) { + chain += `${``.repeat(20)}` + } + return { + 'deep 99,000 levels': `${OPEN}${''.repeat(99_000)}`, + 'deep 65 levels': `${OPEN}${''.repeat(64)}${''.repeat(64)}`, + 'nodes 20,001': `${OPEN}${''.repeat(20_000)}`, + 'brackets in a comment': `${OPEN}`, + 'attributes 257 on one element': `${OPEN}`, + 'bytes 2 MiB + 1': `${OPEN}`, + 'use chain 12 x 20': `${OPEN}${chain}`, + 'text 1.9 MiB of >': `${OPEN}${'>'.repeat(1_900_000)}`, + } +} + +function corpus(): Record { + const files = readdirSync(path(HOSTILE)).filter((f) => f.endsWith('.svg')) + return { + ...Object.fromEntries(files.map((f) => [f, read(`${HOSTILE}${f}`)])), + ...floods(), + } +} + +async function measuredRuntime() { + let memory: WebAssembly.Memory | undefined + const source = nodeCoreSource('pkg') + const runtime = new CoreRuntime({ + compile: source.compile, + importGlue: async (n) => { + const glue = await source.importGlue(n) + return { + ...glue, + default: async (input: { module_or_path: WebAssembly.Module }) => { + const exports = (await glue.default(input)) as { memory?: WebAssembly.Memory } + memory = exports.memory + return exports + }, + } as GlueModule + }, + }) + expect(await runtime.ready()).toBe(true) + return { runtime, memoryMiB: () => (memory?.buffer.byteLength ?? 0) / 1024 / 1024 } +} + +describe('R3 anatomy on the shipped module', () => { + it('answers every hostile drawing with a closed outcome, no trap, within the budgets', async () => { + let slowest = { name: '', ms: 0 } + let largest = { name: '', mib: 0 } + const kinds: Record = {} + for (const [name, text] of Object.entries(corpus())) { + const { runtime, memoryMiB } = await measuredRuntime() + const generation = runtime.generation + const before = memoryMiB() + const started = performance.now() + const session = runtime.sheet(bundle(text)) + const outcome = session.call<{ svg: string }>('view.canvas', '{"viewId":"main"}') + const ms = performance.now() - started + if (ms > slowest.ms) slowest = { name, ms } + kinds[name] = outcome.ok ? 'ok' : `${outcome.kind}:${outcome.detail}` + expect(['ok', 'svg_rejected'], name).toContain(outcome.ok ? 'ok' : outcome.kind) + expect(ms, name).toBeLessThan(150) + expect(runtime.generation, name).toBe(generation) + expect(runtime.status, name).toBe('ready') + const growth = memoryMiB() - before + if (growth > largest.mib) largest = { name, mib: growth } + expect(growth, name).toBeLessThan(32) + } + console.info( + `[core-wasm] R3 hostile corpus: ${Object.keys(kinds).length} cases, slowest ${slowest.name} ` + + `${slowest.ms.toFixed(1)} ms, largest linear memory growth ${largest.name} ${largest.mib.toFixed(1)} MiB`, + ) + expect(kinds['deep 99,000 levels']).toBe('svg_rejected:too_deep') + expect(kinds['use chain 12 x 20']).toBe('svg_rejected:too_complex') + }) + + it('composes the product drawing within budget', async () => { + const { runtime, memoryMiB } = await measuredRuntime() + let started = performance.now() + const session = runtime.sheet(bundle(read(`${SEED}assets/horse.svg`))) + expect(session.open()).toEqual({ ok: true, value: null }) + const loadMs = performance.now() - started + started = performance.now() + const first = session.call<{ svg: string }>('view.canvas', '{"viewId":"main"}') + const firstMs = performance.now() - started + expect(first.ok).toBe(true) + const times: number[] = [] + for (let i = 0; i < 20; i++) { + const t = performance.now() + session.call('view.canvas', '{"viewId":"head"}') + times.push(performance.now() - t) + } + times.sort((a, b) => a - b) + const warm = times[10]! + console.info( + `[core-wasm] R3 sheet handle with the drawing ${loadMs.toFixed(1)} ms, view.canvas main first ` + + `${firstMs.toFixed(1)} ms, head warm median ${warm.toFixed(2)} ms, ` + + `${first.ok ? (first.value.svg.length / 1024).toFixed(0) : '?'} KiB, linear memory ${memoryMiB().toFixed(1)} MiB`, + ) + expect(warm).toBeLessThan(15) + }) +}) diff --git a/packages/core-wasm/tests/runtime.test.ts b/packages/core-wasm/tests/runtime.test.ts index 5c22923e..cc4fcfe9 100644 --- a/packages/core-wasm/tests/runtime.test.ts +++ b/packages/core-wasm/tests/runtime.test.ts @@ -143,5 +143,29 @@ describe('core runtime', () => { expect(outcome).toMatchObject({ ok: false, kind: 'invalid_sheet' }) expect(runtime.status).toBe('ready') expect(runtime.sheet(BUNDLE).open()).toEqual({ ok: true, value: null }) + // Not JSON at all: a closed refusal too (invalid_json), not a poison. + expect(runtime.sheet('not json').open()).toMatchObject({ ok: false, kind: 'invalid_sheet' }) + expect(runtime.status).toBe('ready') + }) + + it('poisons the instance when the handle constructor throws anything but a closed refusal', async () => { + const inner = nodeCoreSource('pkg') + const source: CoreSource = { + compile: () => inner.compile(), + importGlue: async (n) => { + const glue = await inner.importGlue(n) + // An engine stack overflow reaches JavaScript as a RangeError (V8). + class ThrowingHandle { + constructor() { + throw new RangeError('Maximum call stack size exceeded') + } + } + return n === 1 ? ({ ...glue, SheetHandle: ThrowingHandle } as unknown as GlueModule) : glue + }, + } + const runtime = new CoreRuntime(source) + await runtime.ready() + expect(runtime.sheet(BUNDLE).open()).toMatchObject({ ok: false, kind: 'internal' }) + expect(runtime.status).not.toBe('ready') }) })