/** * V1-2.1 timing at the caps on the real stack (contract §15: "save, submit and * publish under 2 s each", measured in V1-2.1, fixed at the V1-2.3 * checkpoint), after the independent audit (M4). * * The core's at-caps fixture belongs to V1-2.2, which has not started. This * suite builds an equivalent document for what SQL does with one: the * structural guards, the 2 MiB size (UTF-8 bytes of the JSON text), the status walk at approval * and publication, the group coverage, the drawing checks. It reaches every * cap those depend on: 64 views (one main, three with their own drawing, the * rest crops), 1 024 annotations, 8 192 finding nodes counting categories * (1 024 zones, each a category and a chain of seven nodes: depth 8), four * drawings near 2 MiB, labels sized so the document's text (`::text`, the * contract's measure, §12.2) is as close to 2 MiB as the variants allow; its * binary jsonb, larger, is reported and is not the measure, every status * `reviewed`, a verdict of 1 089 groups (general, 64 views, 1 024 zones). The * core never parses it (SQL holds no business rule, §12.2), so it says nothing * about the verifier's 120 s budget, which V1-2.3 measures. * * Every call is timed over HTTP as the page would make it (PostgREST, real * GoTrue aal2 token). Run through `pnpm db:sandbox test tests/sandbox/sheets-perf.sandbox.ts`. */ import { performance } from 'node:perf_hooks' import { rpc, sql } from './stack' import type { SteppedAccount } from './mfa' import { drawing, holder, ok, sha256, upload } from './sheet-fixtures' const BUDGET_MS = 2000 const DOC_CAP = 2_097_152 const VIEWS = 64 const ANNOTATIONS = 1024 const ZONES = 1024 const CHAIN = 7 /** The at-caps document; `variant` changes one text so each save differs. */ function capsDocument(assets: string[], labelLength: number, variant: number): Record { const text = (base: string) => (base + ' ').padEnd(labelLength, 'x') const name = (base: string) => ({ fr: text(`${base} fr`), en: text(`${base} en`) }) const views = Array.from({ length: VIEWS }, (_, i) => i === 0 ? { id: 'main', kind: 'main', name: name('main'), svg_asset_id: assets[0], view_box: null } : i < 4 ? { id: `v${i}`, kind: 'detail', parent_view_id: 'main', name: name(`v${i}`), svg_asset_id: assets[i], view_box: null } : { id: `v${i}`, kind: 'detail', parent_view_id: 'main', name: name(`v${i}`), svg_asset_id: null, view_box: { min_x: i, min_y: i, width: 100, height: 80 } }) const node = (zone: number, level: number): Record => ({ id: `n${level}`, name: name(`z${zone} n${level}`), review_status: 'reviewed', requires_vet_referral: level === CHAIN, reference_ids: level === 1 ? ['r0'] : [], ...(level < CHAIN ? { children: [node(zone, level + 1)] } : {}), }) return { schema_version: 2, species_id: 'equine', name: name(`caps ${variant}`), description: name('caps document'), scope_disclaimer: { fr: 'x'.repeat(500), en: 'y'.repeat(480) }, attribution: { authors: ['Sandbox'], license: null, notes: null }, vertebral_config: { regions: ['C', 'T', 'L', 'S', 'Cd'].map((code, i) => ({ code, name: name(code), count: 5 + i })) }, references: Array.from({ length: 64 }, (_, i) => ({ id: `r${i}`, type: 'manual', citation: text(`reference ${i}`), url: null, doi: null })), categories: Array.from({ length: 8 }, (_, i) => ({ id: `c${i}`, name: name(`c${i}`), color: '#123456' })), views, annotations: Array.from({ length: ANNOTATIONS }, (_, i) => ({ id: `a${i}`, kind: i % 4 === 0 ? 'zone' : 'point', view_id: views[i % VIEWS].id, category_id: `c${i % 8}`, laterality: 'unpaired', geometry: i % 4 === 0 ? { type: 'polygon', points: [[i, 1], [i + 5, 2], [i + 9, 7], [i + 3, 9]] } : { type: 'circle', cx: i, cy: i, r: 5 }, review_status: 'reviewed', name: name(`a${i}`), finding_zone_id: `z${i % ZONES}`, vertebral_region_code: null, })), finding_zones: Array.from({ length: ZONES }, (_, z) => ({ id: `z${z}`, name: name(`z${z}`), categories: [{ id: 'cat', kind: 'dysfunction', name: name(`z${z} cat`), review_status: 'reviewed', children: [node(z, 1)] }], })), } } /** * The two sizes PostgreSQL gives the document: its text (`octet_length`, the * contract's measure, read by the save guard and the table CHECK) and its * binary jsonb (`pg_column_size`, reported only: not the measure). */ const pgSizes = async (doc: Record) => { const [text, jsonb] = (await sql(`select octet_length(d::text) || ' ' || pg_column_size(d) from (select $caps$${JSON.stringify(doc)}$caps$::jsonb d) x`)).split(' ').map(Number) return { text, jsonb } } /** The largest label length whose document's text stays under the cap (with 4 KiB for the variants). */ async function calibrate(assets: string[]): Promise { let low = 1 let high = 200 while (low < high) { const mid = Math.ceil((low + high) / 2) const size = await pgSizes(capsDocument(assets, mid, 0)) if (size.text <= DOC_CAP - 4096) low = mid else high = mid - 1 } return low } async function timed(call: () => Promise<{ status: number; text: string }>): Promise { const start = performance.now() const result = await call() const ms = performance.now() - start if (result.status !== 200) throw new Error(`HTTP ${result.status}: ${result.text.slice(0, 300)}`) return ms } const stats = (samples: number[]) => { const sorted = [...samples].sort((a, b) => a - b) return { n: sorted.length, min: Math.round(sorted[0]), median: Math.round(sorted[Math.floor(sorted.length / 2)]), max: Math.round(sorted[sorted.length - 1]), } } describe('timing at the caps (§15)', () => { let E: SteppedAccount let V: SteppedAccount const samples: Record = { save: [], submit: [], approve: [], publish: [] } beforeAll(async () => { E = await holder('perf-editor', 'admin', ['sheet_editor', 'sheet_publisher']) V = await holder('perf-reviewer', null, ['sheet_reviewer']) }, 120_000) it('saves, submits, approves and publishes an at-caps document within the budget', async () => { // The sheet and its four drawings near 2 MiB, uploaded through the INSERT policy. const sheet = ok(await rpc('create_official_sheet', { slug: `perf-${Date.now().toString(36)}`, document: { ...capsDocument([null, null, null, null] as unknown as string[], 8, 0) } }, E.aal2)) as string const draft = await sql(`select id from public.anatomical_sheet_versions where sheet_id = '${sheet}' and status = 'draft'`) const assets: string[] = [] const shas: string[] = [] for (let i = 0; i < 4; i++) { const bytes = drawing(2_000_000) const asset = ok(await rpc('register_sheet_asset', { sheet_id: sheet, sha256: sha256(bytes), byte_size: bytes.length, file_name: `d${i}.svg` }, E.aal2)) as string expect(await upload(E.aal2, bytes)).toBe(200) ok(await rpc('confirm_sheet_asset_upload', { asset_id: asset }, E.aal2)) assets.push(asset) shas.push(sha256(bytes)) } const labelLength = await calibrate(assets) const docSize = await pgSizes(capsDocument(assets, labelLength, 1)) let revision = Number(await sql(`select revision from public.anatomical_sheet_versions where id = '${draft}'`)) let version = draft let variant = 0 const save = async () => { variant += 1 samples.save.push(await timed(() => rpc('save_sheet_draft', { version_id: version, expected_revision: revision, document: capsDocument(assets, labelLength, variant), change_note: 'caps' }, E.aal2))) revision += 1 } const submit = async () => { const start = performance.now() const result = await rpc('submit_sheet_review', { version_id: version, expected_revision: revision, note: 'caps' }, E.aal2) samples.submit.push(performance.now() - start) return ok(result) as string } // The verdict of the worker's stand-in: 1 089 groups, the four drawings. const groups = ['general', ...Array.from({ length: VIEWS }, (_, i) => (i === 0 ? 'view:main' : `view:v${i}`)), ...Array.from({ length: ZONES }, (_, z) => `zone:z${z}`)] const open = (review: string) => sql(`update public.anatomical_sheet_reviews set status = 'open', verified_at = now(), verified_with = 'sandbox', verdict = '${JSON.stringify({ fingerprint: 'a'.repeat(64), drawings: assets.map((asset_id, i) => ({ asset_id, sha256: shas[i] })), groups: groups.map((key) => ({ key, digest: sha256(Buffer.from(key)), coverable: true })), })}'::jsonb where id = '${review}'`) const approveAndPublish = async (review: string) => { samples.approve.push(await timed(() => rpc('decide_sheet_review', { review_id: review, approve: true, note: 'caps' }, V.aal2))) samples.publish.push(await timed(() => rpc('publish_sheet_version', { review_id: review }, E.aal2))) } // Cycle 1, no base: five saves, three submissions (two withdrawn), every // group acknowledged by the reviewer, approval, publication. for (let i = 0; i < 5; i++) await save() for (let i = 0; i < 2; i++) ok(await rpc('withdraw_sheet_review', { review_id: await submit(), note: 'again' }, E.aal2)) const first = await submit() await open(first) await sql(`insert into public.anatomical_sheet_review_acknowledgments (review_id, group_key, group_digest, reviewer) select '${first}', g ->> 'key', g ->> 'digest', '${V.id}' from public.anatomical_sheet_reviews r, jsonb_array_elements(r.verdict -> 'groups') g where r.id = '${first}'`) await approveAndPublish(first) // Cycles 2 and 3: a new draft on the published base, one save, one // submission, the same digests (covered by the base), approval, publication. for (let cycle = 0; cycle < 2; cycle++) { version = ok(await rpc('create_sheet_draft', { sheet_id: sheet, from_version_id: null, change_note: 'next' }, E.aal2)) as string revision = 0 await save() const review = await submit() await open(review) await approveAndPublish(review) } ok(await rpc('archive_anatomical_sheet', { sheet_id: sheet }, E.aal2)) const report = { document: { textBytes: docSize.text, jsonbBytes: docSize.jsonb, cap: DOC_CAP, labelLength, views: VIEWS, annotations: ANNOTATIONS, findingNodes: ZONES * (CHAIN + 1), depth: CHAIN + 1, groups: groups.length, drawings: 4, drawingBytes: 2_000_000 }, budgetMs: BUDGET_MS, save: stats(samples.save), submit: stats(samples.submit), approve: stats(samples.approve), publish: stats(samples.publish), } console.info(`AT-CAPS TIMING ${JSON.stringify(report)}`) expect(docSize.text).toBeGreaterThan(DOC_CAP - 64 * 1024) expect(docSize.text).toBeLessThanOrEqual(DOC_CAP) for (const op of ['save', 'submit', 'publish']) expect(Math.max(...samples[op]), `${op} at the caps`).toBeLessThan(BUDGET_MS) }, 600_000) // The size guard's number walk at the caps (security gate on 7c4bf12): a // document of many small numbers within the cap saves within the budget, one // just over the cap answers the closed code within it, never a statement timeout. it('measures a document of many small numbers within the budget', async () => { // A small valid base (empty collections), so the numbers carry the size. const base = { ...capsDocument([null, null, null, null] as unknown as string[], 8, 0), references: [], categories: [], views: [], annotations: [], finding_zones: [] } const sheet = ok(await rpc('create_official_sheet', { slug: `perf-n-${Date.now().toString(36)}`, document: base }, E.aal2)) as string const draft = await sql(`select id from public.anatomical_sheet_versions where sheet_id = '${sheet}' and status = 'draft'`) const revision = Number(await sql(`select revision from public.anatomical_sheet_versions where id = '${draft}'`)) const withNumbers = (count: number) => ({ ...base, pad: new Array(count).fill(0) }) const within = await pgSizes(withNumbers(600_000)) expect(within.text).toBeLessThanOrEqual(DOC_CAP) const saveMs = await timed(() => rpc('save_sheet_draft', { version_id: draft, expected_revision: revision, document: withNumbers(600_000), change_note: 'numbers' }, E.aal2)) const start = performance.now() const over = await rpc('save_sheet_draft', { version_id: draft, expected_revision: revision + 1, document: withNumbers(1_000_000), change_note: 'numbers' }, E.aal2) const overMs = performance.now() - start console.info(`NUMBER WALK ${JSON.stringify({ within: { numbers: 600_000, textBytes: within.text, ms: Math.round(saveMs) }, over: { numbers: 1_000_000, status: over.status, ms: Math.round(overMs) } })}`) expect(over.text).toContain('document.too_large') expect(saveMs).toBeLessThan(BUDGET_MS) expect(overMs).toBeLessThan(BUDGET_MS) ok(await rpc('archive_anatomical_sheet', { sheet_id: sheet }, E.aal2)) }, 120_000) })