diff --git a/apps/app/src/app/routes/HomeRoute.tsx b/apps/app/src/app/routes/HomeRoute.tsx index 3b00a235..d9b78128 100644 --- a/apps/app/src/app/routes/HomeRoute.tsx +++ b/apps/app/src/app/routes/HomeRoute.tsx @@ -1,5 +1,5 @@ import { useNavigate } from 'react-router-dom' -import { useRef, useState } from 'react' +import { useEffect, useRef, useState } from 'react' import type { ArchiveReadOutcome, RebaseOutcome, @@ -10,21 +10,23 @@ import { CoreStoppedBanner } from '@/components/report/CoreStoppedNotice' import ReplaceSessionDialog from '@/components/report/ReplaceSessionDialog' import Button from '@/components/ui/Button' import Card from '@/components/ui/Card' -import { - importAttachment, - ImportError, - MAX_ATTACHMENT_BYTES, - MAX_PDF_BYTES, - readAttachment, - readRescueCopy, -} from '@/pdf/import' +import { coreRuntime, coreStopped } from '@/core/runtime' +import type { ImportSettlement } from '@/core/worker/client' +import { cancelImport, startImport } from '@/core/worker/controller' +import { MAX_COPY_BYTES, MAX_PDF_BYTES } from '@/core/worker/handler' +import { copyRestoreOf, ImportError, pdfImportOf } from '@/core/worker/outcome' +import type { ImportTaskKind } from '@/core/worker/protocol' import { isSessionInProgress, useReportStore, type ImportedSession, } from '@/state/reportStore' import type { SheetIndex } from '@/services/sheetIndex' -import { loadSheetIndex, useSheetAvailability } from '@/sheets/useSheet' +import { + loadSheetBundleText, + loadSheetIndex, + useSheetAvailability, +} from '@/sheets/useSheet' import { DEFAULT_SPECIES_ID } from './NewReportRoute' import { useT } from '@/i18n/useT' import { coreFailureMessage } from '@/core/failure' @@ -119,6 +121,8 @@ function importErrorMessage(err: unknown, t: Translate): string { return t('home.import.error_invalid_copy') case 'core_unavailable': return coreFailureMessage(t, 'home.import.error_core_unavailable') + case 'generic': + return t('home.import.error_generic') } } @@ -143,20 +147,39 @@ function firstContentByte(head: Uint8Array): number | undefined { * is JSON (an object) or is named as such; anything else goes the PDF path and its error. */ function isRescueCopy(file: File, head: Uint8Array): boolean { - const start = new TextDecoder('latin1').decode(head.slice(0, PDF_MAGIC.length)) + const start = new TextDecoder('latin1').decode( + head.slice(0, PDF_MAGIC.length), + ) if (start === PDF_MAGIC) return false if (firstContentByte(head) === 0x7b) return true - return file.name.toLowerCase().endsWith('.json') || file.type === 'application/json' + return ( + file.name.toLowerCase().endsWith('.json') || + file.type === 'application/json' + ) } -/** The copy's text, refused (never altered) when it is over the cap or not valid UTF-8. */ -async function readCopyText(file: File): Promise { - if (file.size > MAX_ATTACHMENT_BYTES) throw new ImportError('invalid_copy') - try { - return new TextDecoder('utf-8', { fatal: true }).decode(await file.arrayBuffer()) - } catch { - throw new ImportError('invalid_copy') +/** + * One task in the disposable import worker (R4.3, plan §B.1.5): the page refuses up front + * when its own engine stopped, hands the file (never read here), the sheet payload and + * its compiled module to the worker, and reads the settlement. Diagnostics in DEV only. + */ +async function runImportTask( + task: ImportTaskKind, + file: File, +): Promise { + if (coreStopped()) throw new ImportError('core_unavailable') + const sheet = await loadSheetBundleText(DEFAULT_SPECIES_ID) + if (!sheet) throw new ImportError('core_unavailable') + const module = await ( + coreRuntime().compiledModule() ?? Promise.resolve(null) + ).catch(() => null) + const settlement = await startImport({ task, file, sheet, module }) + // Diagnostics only (never the outcome: it holds the bilan's names), DEV console only. + if (import.meta.env.DEV) { + const diag = settlement.kind === 'result' ? settlement.diag : settlement + console.debug('[import]', task, diag) } + return settlement } export default function HomeRoute() { @@ -169,48 +192,64 @@ export default function HomeRoute() { const [busy, setBusy] = useState(false) const [confirmingReplace, setConfirmingReplace] = useState(false) const t = useT() + // Leaving Home cancels a running import: its worker is terminated, its result dropped. + useEffect(() => cancelImport, []) - /** A Faunosteo PDF: its attachment, read and rebased by the core on the loaded sheet. */ - async function readPdf(file: File): Promise { - // The engine refuses the same size; checking first keeps a huge file out of memory. - if (file.size > MAX_PDF_BYTES) throw new ImportError('invalid_pdf') - const bytes = new Uint8Array(await file.arrayBuffer()) - const attachment = await readAttachment(bytes) + /** The page's own index, loaded after the worker accepted the file, for `hydrateImport`. */ + async function mainIndex(): Promise { const index = await loadSheetIndex(DEFAULT_SPECIES_ID) if (!index) throw new ImportError('core_unavailable') - const { read: outcome, rebase } = importAttachment(attachment, index) + return index + } + + /** A Faunosteo PDF: its attachment, read and rebased by the worker's core on the sheet. */ + async function readPdf(file: File): Promise { + // The worker and the core refuse the same size; checking first reads nothing. + if (file.size > MAX_PDF_BYTES) throw new ImportError('invalid_pdf') + const { read: outcome, rebase } = pdfImportOf( + await runImportTask('pdf', file), + ) return { session: { report: rebase.report, archive: outcome.archive }, - index, + index: await mainIndex(), lines: importMessages(outcome, rebase, t), } } /** A rescue copy: read before any session change, so a refusal leaves the tab untouched. */ async function readCopy(file: File): Promise { - const text = await readCopyText(file) - const index = await loadSheetIndex(DEFAULT_SPECIES_ID) - if (!index) throw new ImportError('core_unavailable') - const rebase = readRescueCopy(text, index) + if (file.size > MAX_COPY_BYTES) throw new ImportError('invalid_copy') + const { rebase } = copyRestoreOf(await runImportTask('copy', file)) const count = String(rebase.unresolvedZones + rebase.unresolvedFindings) return { session: { report: rebase.report, archive: null }, - index, - lines: rebase.rebased ? [t('editor.draft_rebased').replace('{count}', count)] : [], + index: await mainIndex(), + lines: rebase.rebased + ? [t('editor.draft_rebased').replace('{count}', count)] + : [], } } /** Read, rebase onto the loaded sheet, open; the editor always works on that sheet. */ async function importFile(file: File) { const head = new Uint8Array(await file.slice(0, SNIFF_BYTES).arrayBuffer()) - const read = isRescueCopy(file, head) ? await readCopy(file) : await readPdf(file) + const reportAtPick = useReportStore.getState().report + const read = isRescueCopy(file, head) + ? await readCopy(file) + : await readPdf(file) + // The session changed under the import (another tab action): its result is dropped. + if (useReportStore.getState().report !== reportAtPick) return const opened = hydrateImport(read.session, read.index) // A tab text that could not be set aside would be overwritten: resolve it first. if (!opened.ok) { // A core failure reading the tab's draft is an engine error, not a held text. if (opened.reason !== 'held') throw new ImportError('core_unavailable') window.alert( - t(opened.engine ? 'session.held_blocked_engine' : 'session.held_blocked'), + t( + opened.engine + ? 'session.held_blocked_engine' + : 'session.held_blocked', + ), ) navigate('/editor') return diff --git a/apps/app/src/core/worker/client.ts b/apps/app/src/core/worker/client.ts new file mode 100644 index 00000000..f67a8165 --- /dev/null +++ b/apps/app/src/core/worker/client.ts @@ -0,0 +1,137 @@ +import { + isWorkerMessage, + PROTOCOL_VERSION, + type ImportDiag, + type ImportTaskKind, +} from './protocol' +import { PausableTimer, type Visibility, documentVisibility } from './timers' + +/** + * The page side of one import (R4.3, plan §B.1.5 items 1, 3 and 5): creates the worker + * in a try/catch (a `SecurityError` is synchronous), installs the listeners before posting, + * arms the start timer until `ready` then the task timer, settles once on the first of + * `result`, `failed`, an `error` event, a timer, or a cancel, and terminates the worker in + * every case. Everything after the first settlement is ignored. + */ + +/** What `new Worker(…)` gives, narrowed to what the client uses (a test fake fits). */ +export interface WorkerLike { + postMessage(message: unknown): void + terminate(): void + onmessage: ((event: MessageEvent) => void) | null + onerror: ((event: ErrorEvent) => void) | null + onmessageerror: ((event: MessageEvent) => void) | null +} + +export interface ImportTaskInput { + task: ImportTaskKind + file: File + sheet: string + module: WebAssembly.Module | null +} + +/** + * `worker_unavailable`: the worker could not be created, failed before `ready`, or did not + * answer `ready` in time; `crashed`: a trap or an `error` event during the task; + * `timeout`: the task timer; `read`: the file could not be read; `engine`: the module + * refused the sheet or failed otherwise during the task; `cancelled`: the page gave up. + */ +export type ImportFailureReason = + | 'worker_unavailable' + | 'crashed' + | 'timeout' + | 'read' + | 'engine' + | 'cancelled' + +export type ImportSettlement = + | { kind: 'result'; out: string; diag: ImportDiag } + | { kind: 'failed'; reason: ImportFailureReason; detail: string } + +export interface ImportClientOptions { + spawn: () => WorkerLike + /** Until `ready`: the module's fetch, compile and instantiation. */ + startTimeoutMs: number + /** From `ready` to the result (plan §B.3: 20 s hypothesis, set at J1). */ + taskTimeoutMs: number + visibility?: Visibility +} + +export interface ImportRun { + settled: Promise + /** Terminates the worker and settles `cancelled` unless already settled. */ + cancel(): void +} + +/** The failure reason of a `failed` message, per §B.1.8. */ +function reasonOf(phase: 'start' | 'task', kind: string): ImportFailureReason { + if (phase === 'start') return 'worker_unavailable' + if (kind === 'trap') return 'crashed' + if (kind === 'read') return 'read' + return 'engine' +} + +export function runImportTask( + input: ImportTaskInput, + options: ImportClientOptions, +): ImportRun { + let worker: WorkerLike | null = null + let timer: PausableTimer | null = null + let ready = false + let done = false + let resolve!: (settlement: ImportSettlement) => void + const settled = new Promise((r) => { + resolve = r + }) + const visibility = options.visibility ?? documentVisibility + + const settle = (settlement: ImportSettlement) => { + if (done) return + done = true + timer?.clear() + timer = null + worker?.terminate() + worker = null + resolve(settlement) + } + const fail = (reason: ImportFailureReason, detail: string) => + settle({ kind: 'failed', reason, detail }) + const arm = (ms: number, reason: ImportFailureReason) => { + timer?.clear() + timer = new PausableTimer( + ms, + () => fail(reason, `${reason} after ${ms} ms`), + visibility, + ) + } + + try { + worker = options.spawn() + } catch (error) { + fail( + 'worker_unavailable', + error instanceof Error ? error.name : 'spawn failed', + ) + return { settled, cancel: () => fail('cancelled', 'cancelled') } + } + worker.onmessage = (event) => { + const data: unknown = event.data + if (!isWorkerMessage(data)) return + if (data.type === 'ready') { + ready = true + arm(options.taskTimeoutMs, 'timeout') + } else if (data.type === 'result') { + settle({ kind: 'result', out: data.out, diag: data.diag }) + } else { + fail(reasonOf(data.phase, data.kind), data.detail) + } + } + // An `error` event is never masked: it settles the import (and reaches the console). + worker.onerror = (event) => + fail(ready ? 'crashed' : 'worker_unavailable', event.message) + worker.onmessageerror = () => + fail(ready ? 'engine' : 'worker_unavailable', 'messageerror') + arm(options.startTimeoutMs, 'worker_unavailable') + worker.postMessage({ v: PROTOCOL_VERSION, type: 'task', ...input }) + return { settled, cancel: () => fail('cancelled', 'cancelled') } +} diff --git a/apps/app/src/core/worker/controller.ts b/apps/app/src/core/worker/controller.ts new file mode 100644 index 00000000..5cd5f1f9 --- /dev/null +++ b/apps/app/src/core/worker/controller.ts @@ -0,0 +1,72 @@ +import workerUrl from './import.worker?worker&url' +import { + runImportTask, + type ImportRun, + type ImportSettlement, + type ImportTaskInput, +} from './client' +import type { WorkerLike } from './client' + +/** + * One import at a time for the page (R4.3, plan §B.1.5 items 6 and 7): a new start + * cancels the running one, leaving Home cancels it, and the worker script is prefetched + * once the editor has loaded the engine so that a later offline import can start. + */ + +/** Until `ready`: a cold fetch, compile and instantiation on a slow device. */ +export const IMPORT_START_TIMEOUT_MS = 10_000 +/** From `ready` to the result (plan §B.3: 20 s hypothesis, confirmed or moved at J1). */ +export const IMPORT_TIMEOUT_MS = 20_000 + +type Spawn = () => WorkerLike + +const spawnWorker: Spawn = () => + new Worker(workerUrl, { type: 'module', name: 'faunosteo-import' }) + +let spawn: Spawn = spawnWorker +let running: ImportRun | null = null +let prefetched = false + +/** Starts an import; a running one is cancelled first (its result dropped). */ +export function startImport(input: ImportTaskInput): Promise { + running?.cancel() + const run = runImportTask(input, { + spawn, + startTimeoutMs: IMPORT_START_TIMEOUT_MS, + taskTimeoutMs: IMPORT_TIMEOUT_MS, + }) + running = run + void run.settled.then(() => { + if (running === run) running = null + }) + return run.settled +} + +/** Cancels the running import, if any (leaving Home, a second pick). */ +export function cancelImport(): void { + running?.cancel() + running = null +} + +/** + * Warms the HTTP cache with the worker chunk (an immutable `/assets/` file) so that an + * import works offline once the editor has loaded the engine, as it does today. Best + * effort: a failure changes nothing. + */ +export function prefetchImportWorker(): void { + if ( + prefetched || + typeof Worker === 'undefined' || + typeof fetch !== 'function' + ) + return + prefetched = true + fetch(workerUrl, { credentials: 'same-origin' }) + .then((response) => response.body?.cancel()) + .catch(() => undefined) +} + +/** Test seam: run the worker logic in-process instead of a real `Worker`. */ +export function setImportWorkerSpawn(next: Spawn | null): void { + spawn = next ?? spawnWorker +} diff --git a/apps/app/src/core/worker/handler.ts b/apps/app/src/core/worker/handler.ts new file mode 100644 index 00000000..dda8f4cd --- /dev/null +++ b/apps/app/src/core/worker/handler.ts @@ -0,0 +1,150 @@ +import type { GlueFileBytes, GlueSheetHandle } from '@faunosteo/core-wasm' +import { closedRefusal } from '@faunosteo/core-wasm' +import { + describeError, + failureKindOf, + PROTOCOL_VERSION, + type ImportTaskKind, + type ImportTaskMessage, + type WorkerFailurePhase, + type WorkerMessage, +} from './protocol' + +/** + * The import worker's logic (R4.3, plan §B.1.5 items 2 and 4), apart from the worker + * global so that vitest runs it in-process on the Node module: the engine is injected. + * One task per worker: instantiate, answer `ready`, build the sheet handle, stream the + * file into the module's memory (the file lives once, never as an ArrayBuffer here), run + * the core, answer `result`; every throwable becomes one `failed` with its phase and kind. + */ + +/** What the glue gives once instantiated. */ +export interface WorkerEngine { + SheetHandle: new (bundle: string) => GlueSheetHandle + FileBytes: new (expected: number) => GlueFileBytes + /** The instance's linear memory, for the diag. */ + memory: WebAssembly.Memory | null +} + +export type EngineLoader = ( + module: WebAssembly.Module | null, +) => Promise + +/** The caps the worker checks before reading a byte (the core enforces the same). */ +export const MAX_PDF_BYTES = 50 * 1024 * 1024 +export const MAX_COPY_BYTES = 16 * 1024 * 1024 + +/** The core's failure envelope, for the caps the worker applies itself. */ +function refusal(kind: string, detail: string): string { + return JSON.stringify({ ok: false, kind, detail }) +} + +/** The sheet handle, or an error named `SheetRefused` carrying the module's refusal. */ +function sheetHandle(engine: WorkerEngine, sheet: string): GlueSheetHandle { + try { + return new engine.SheetHandle(sheet) + } catch (error) { + const detail = closedRefusal(error) + if (detail === null) throw error + const refused = new Error(detail) + refused.name = 'SheetRefused' + throw refused + } +} + +interface Gathered { + bytes: GlueFileBytes + chunks: number +} + +/** Streams the file into the module's memory, one chunk live at a time. */ +async function gather( + engine: WorkerEngine, + file: File, +): Promise { + const bytes = new engine.FileBytes(file.size) + const reader = file.stream().getReader() + let chunks = 0 + for (;;) { + const { done, value } = await reader.read() + if (done) return { bytes, chunks } + chunks += 1 + // A push refused means the file is not the size it announced: not a Faunosteo file. + if (!bytes.push(value)) { + await reader.cancel() + bytes.free() + return null + } + } +} + +/** The task's outcome envelope text and the chunk count. */ +async function runTask( + engine: WorkerEngine, + handle: GlueSheetHandle, + task: ImportTaskKind, + file: File, +): Promise<{ out: string; chunks: number }> { + const cap = task === 'pdf' ? MAX_PDF_BYTES : MAX_COPY_BYTES + const kind = task === 'pdf' ? 'invalid_pdf' : 'invalid' + if (file.size > cap) + return { out: refusal(kind, 'over the size cap'), chunks: 0 } + const gathered = await gather(engine, file) + if (!gathered) + return { out: refusal(kind, 'size changed while reading'), chunks: 0 } + const out = + task === 'pdf' + ? handle.import_pdf_bytes(gathered.bytes) + : handle.restore_copy_bytes(gathered.bytes) + return { out, chunks: gathered.chunks } +} + +/** + * The handler of the task message: `load` instantiates the module (the posted one, or + * fetched), `post` sends the answers. Resolves once the task has settled either way. + */ +export function createWorkerHandler( + load: EngineLoader, + post: (message: WorkerMessage) => void, +): (data: unknown) => Promise { + const fail = (phase: WorkerFailurePhase, error: unknown) => + post({ + v: PROTOCOL_VERSION, + type: 'failed', + phase, + kind: failureKindOf(error), + detail: describeError(error), + }) + return async (data) => { + if (!isTaskMessage(data)) return + let phase: WorkerFailurePhase = 'start' + try { + const engine = await load(data.module) + post({ v: PROTOCOL_VERSION, type: 'ready' }) + phase = 'task' + const started = performance.now() + const handle = sheetHandle(engine, data.sheet) + const { out, chunks } = await runTask( + engine, + handle, + data.task, + data.file, + ) + const linearBytes = engine.memory?.buffer.byteLength ?? null + const diag = { ms: performance.now() - started, linearBytes, chunks } + post({ v: PROTOCOL_VERSION, type: 'result', out, diag }) + } catch (error) { + fail(phase, error) + } + } +} + +function isTaskMessage(data: unknown): data is ImportTaskMessage { + if (typeof data !== 'object' || data === null) return false + const record = data as { v?: unknown; type?: unknown; task?: unknown } + return ( + record.v === PROTOCOL_VERSION && + record.type === 'task' && + (record.task === 'pdf' || record.task === 'copy') + ) +} diff --git a/apps/app/src/core/worker/import.worker.ts b/apps/app/src/core/worker/import.worker.ts new file mode 100644 index 00000000..d3e52c25 --- /dev/null +++ b/apps/app/src/core/worker/import.worker.ts @@ -0,0 +1,46 @@ +/// +import init, { + FileBytes, + SheetHandle, +} from '@faunosteo/core-wasm/pkg/faunosteo_wasm.js' +import wasmUrl from '@faunosteo/core-wasm/pkg/faunosteo_wasm_bg.wasm?url' +import { createWorkerHandler, type WorkerEngine } from './handler' +import { describeError, PROTOCOL_VERSION } from './protocol' + +/** + * The import worker entry (R4.3, plan §B.1.5 item 2): the glue is imported statically and + * bundled into this chunk (a same-origin hashed asset the production CSP allows, no + * `import()`, no recovery logic); the module is the compiled one the page posts, else the + * asset fetched here. The listener is installed before any await; the whole life runs + * inside the handler's try/catch, with `unhandledrejection` as a backstop: every throwable + * reaches the page as one `failed` message. The page terminates the worker in every case. + */ + +const scope = self as unknown as DedicatedWorkerGlobalScope + +const loadEngine = async ( + module: WebAssembly.Module | null, +): Promise => { + const exports = (await init({ module_or_path: module ?? wasmUrl })) as { + memory?: WebAssembly.Memory + } + return { SheetHandle, FileBytes, memory: exports.memory ?? null } +} + +const handle = createWorkerHandler(loadEngine, (message) => + scope.postMessage(message), +) + +scope.onmessage = (event: MessageEvent) => { + void handle(event.data) +} + +scope.onunhandledrejection = (event: PromiseRejectionEvent) => { + scope.postMessage({ + v: PROTOCOL_VERSION, + type: 'failed', + phase: 'task', + kind: 'other', + detail: describeError(event.reason), + }) +} diff --git a/apps/app/src/core/worker/outcome.ts b/apps/app/src/core/worker/outcome.ts new file mode 100644 index 00000000..676c1c8e --- /dev/null +++ b/apps/app/src/core/worker/outcome.ts @@ -0,0 +1,115 @@ +import type { ArchiveImport, DraftRestore } from '@faunosteo/core-wasm/types' +import type { ImportSettlement, ImportTaskInput } from './client' + +/** + * What the import worker's settlement means for the page (R4.3, plan §B.1.8): the core's + * outcome envelope mapped to the page's import error kinds, and the worker's own failures + * classified so that a technical error, a resource overflow or a timeout is never shown as + * a corrupt PDF (OD-5: `generic` for a PDF crash or timeout, `core_unavailable` for a copy). + */ + +export type ImportErrorKind = + | 'invalid_pdf' + | 'no_attachment' + | 'attachment_stripped' + | 'incompatible_version' + | 'lone_surrogate' + | 'invalid_copy' + | 'core_unavailable' + | 'generic' + +export class ImportError extends Error { + constructor( + readonly kind: ImportErrorKind, + /** The report version found, for `incompatible_version`. */ + readonly foundVersion: number | null = null, + /** The technical reason, for the DEV console only. */ + readonly detail = '', + ) { + super(kind) + this.name = 'ImportError' + } +} + +interface Envelope { + ok: boolean + value?: T + kind?: string + found?: number + detail?: string +} + +/** The envelope text, or `core_unavailable` when it is not one (never a trusted shape). */ +function parseEnvelope(out: string): Envelope { + try { + const parsed: unknown = JSON.parse(out) + if (typeof parsed === 'object' && parsed !== null && 'ok' in parsed) { + return parsed as Envelope + } + } catch { + // Not JSON: the module answered garbage, treated as an engine failure below. + } + throw new ImportError('core_unavailable', null, 'unreadable envelope') +} + +/** `SheetHandle.import_pdf` failures, one to one with today's kinds. */ +function pdfError(envelope: Envelope): ImportError { + switch (envelope.kind) { + case 'invalid_pdf': + case 'no_attachment': + case 'attachment_stripped': + case 'lone_surrogate': + return new ImportError(envelope.kind, null, envelope.detail) + case 'incompatible_version': + return new ImportError('incompatible_version', envelope.found ?? null) + case 'invalid': + // The rebase refused the loaded sheet's reference: today's generic message. + return new ImportError('generic', null, envelope.detail) + default: + return new ImportError('core_unavailable', null, envelope.detail) + } +} + +/** Kinds that mean the copy itself cannot be read (`reportStore.UNREADABLE_DRAFT_KINDS`). */ +const UNREADABLE_COPY = new Set([ + 'invalid', + 'unsupported_version', + 'lone_surrogate', +]) + +function copyError(envelope: Envelope): ImportError { + if (UNREADABLE_COPY.has(envelope.kind ?? '')) { + return new ImportError('invalid_copy', null, envelope.detail) + } + return new ImportError('core_unavailable', null, envelope.detail) +} + +/** The worker's own failures, by task (OD-5). */ +function workerError( + task: ImportTaskInput['task'], + settlement: ImportSettlement, +): ImportError { + if (settlement.kind !== 'failed') throw new Error('not a failure') + const { reason, detail } = settlement + if (reason === 'read') return new ImportError('generic', null, detail) + if (task === 'pdf' && (reason === 'crashed' || reason === 'timeout')) { + return new ImportError('generic', null, detail) + } + return new ImportError('core_unavailable', null, detail) +} + +/** The imported archive, or the ImportError the page shows. */ +export function pdfImportOf(settlement: ImportSettlement): ArchiveImport { + if (settlement.kind === 'failed') throw workerError('pdf', settlement) + const envelope = parseEnvelope(settlement.out) + if (!envelope.ok || envelope.value === undefined) throw pdfError(envelope) + return envelope.value +} + +/** The restored copy, or the ImportError the page shows. */ +export function copyRestoreOf(settlement: ImportSettlement): DraftRestore { + if (settlement.kind === 'failed') throw workerError('copy', settlement) + const envelope = parseEnvelope(settlement.out) + if (!envelope.ok || envelope.value === undefined) throw copyError(envelope) + return envelope.value +} diff --git a/apps/app/src/core/worker/protocol.ts b/apps/app/src/core/worker/protocol.ts new file mode 100644 index 00000000..dbeca340 --- /dev/null +++ b/apps/app/src/core/worker/protocol.ts @@ -0,0 +1,95 @@ +/** + * Messages between the page and the import worker (R4.3, plan §B.1.5), tagged `v: 1`. + * The page posts one task; the worker answers `ready` once its instance runs, then one + * `result` or one `failed`. Anything after the first settlement is ignored by the page. + */ + +export const PROTOCOL_VERSION = 1 + +export type ImportTaskKind = 'pdf' | 'copy' + +export interface ImportTaskMessage { + v: typeof PROTOCOL_VERSION + type: 'task' + task: ImportTaskKind + /** The picked file, never read on the page's thread. */ + file: File + /** The bundled sheet payload text the page's runtime builds its handle from. */ + sheet: string + /** The compiled module of the page's runtime when it holds one; else the worker fetches. */ + module: WebAssembly.Module | null +} + +export interface WorkerReadyMessage { + v: typeof PROTOCOL_VERSION + type: 'ready' +} + +export interface WorkerResultMessage { + v: typeof PROTOCOL_VERSION + type: 'result' + /** The outcome envelope text of the core (`{"ok":true,…}` or `{"ok":false,"kind":…}`). */ + out: string + diag: ImportDiag +} + +/** Printed in DEV only, never sent anywhere. */ +export interface ImportDiag { + ms: number + linearBytes: number | null + chunks: number +} + +export type WorkerFailurePhase = 'start' | 'task' + +/** + * `trap`: a `WebAssembly.RuntimeError`, or an engine stack overflow (`RangeError`, + * `InternalError`); `read`: the file could not be read; `sheet`: the bundled sheet was + * refused by the module; `other`: anything else (a glue or network failure at start). + */ +export type WorkerFailureKind = 'trap' | 'read' | 'sheet' | 'other' + +export interface WorkerFailedMessage { + v: typeof PROTOCOL_VERSION + type: 'failed' + phase: WorkerFailurePhase + kind: WorkerFailureKind + /** Error name and first message line, for the DEV console only. */ + detail: string +} + +export type WorkerMessage = + | WorkerReadyMessage + | WorkerResultMessage + | WorkerFailedMessage + +/** True for a message of this protocol, from a worker of the same build. */ +export function isWorkerMessage(data: unknown): data is WorkerMessage { + if (typeof data !== 'object' || data === null) return false + const record = data as { v?: unknown; type?: unknown } + return ( + record.v === PROTOCOL_VERSION && + (record.type === 'ready' || + record.type === 'result' || + record.type === 'failed') + ) +} + +/** Error name and first message line, bounded, for a `failed` message. */ +export function describeError(error: unknown): string { + const name = error instanceof Error ? error.name : 'Error' + const message = error instanceof Error ? error.message : String(error) + return `${name}: ${message}`.split('\n')[0]!.slice(0, 200) +} + +/** The failure kind of a throwable, per §B.1.5 item 2. */ +export function failureKindOf(error: unknown): WorkerFailureKind { + if (error instanceof WebAssembly.RuntimeError) return 'trap' + if (!(error instanceof Error)) return 'other' + if (error.name === 'RangeError' || error.name === 'InternalError') + return 'trap' + if (error.name === 'NotReadableError' || error.name === 'NotFoundError') + return 'read' + if (error.name === 'SheetRefused') return 'sheet' + return 'other' +} diff --git a/apps/app/src/core/worker/timers.ts b/apps/app/src/core/worker/timers.ts new file mode 100644 index 00000000..079ff85b --- /dev/null +++ b/apps/app/src/core/worker/timers.ts @@ -0,0 +1,74 @@ +/** + * A one-shot timer that stops counting while the page is hidden (R4.3, plan §B.1.5 item + * 3): a phone that backgrounds the tab must not time an import out on return. The + * visibility source is injected so tests drive it. + */ + +export interface Visibility { + hidden(): boolean + /** Calls `listener` on every change; returns the unsubscribe function. */ + onChange(listener: () => void): () => void +} + +export const documentVisibility: Visibility = { + hidden: () => + typeof document !== 'undefined' && document.visibilityState === 'hidden', + onChange: (listener) => { + if (typeof document === 'undefined') return () => {} + document.addEventListener('visibilitychange', listener) + return () => document.removeEventListener('visibilitychange', listener) + }, +} + +export class PausableTimer { + private remainingMs: number + private startedAt: number | null = null + private handle: ReturnType | null = null + private readonly unsubscribe: () => void + + constructor( + durationMs: number, + private readonly onElapsed: () => void, + private readonly visibility: Visibility = documentVisibility, + private readonly now: () => number = () => performance.now(), + ) { + this.remainingMs = durationMs + this.unsubscribe = visibility.onChange(() => this.sync()) + this.sync() + } + + /** Stops the timer for good; a timer never fires after it. */ + clear(): void { + this.pause() + this.unsubscribe() + this.remainingMs = Number.POSITIVE_INFINITY + } + + private sync(): void { + if (this.visibility.hidden()) this.pause() + else this.resume() + } + + private resume(): void { + if (this.handle !== null || !Number.isFinite(this.remainingMs)) return + this.startedAt = this.now() + this.handle = setTimeout(() => { + this.handle = null + this.remainingMs = 0 + this.unsubscribe() + this.onElapsed() + }, this.remainingMs) + } + + private pause(): void { + if (this.handle === null) return + clearTimeout(this.handle) + this.handle = null + if (this.startedAt !== null) { + this.remainingMs = Math.max( + 0, + this.remainingMs - (this.now() - this.startedAt), + ) + } + } +} diff --git a/apps/app/src/pdf/import.ts b/apps/app/src/pdf/import.ts index 100c0ea6..877413a4 100644 --- a/apps/app/src/pdf/import.ts +++ b/apps/app/src/pdf/import.ts @@ -1,11 +1,10 @@ -import type { ArchiveImport, RebaseOutcome } from '@faunosteo/core-wasm/types' +import type { ArchiveImport } from '@faunosteo/core-wasm/types' import { ArchiveReadError, readAttachedDocument, type ArchiveReadErrorKind, } from '@faunosteo/pdf' import type { SheetIndex } from '@/services/sheetIndex' -import { UNREADABLE_DRAFT_KINDS } from '@/state/reportStore' export { MAX_ATTACHMENT_BYTES, MAX_PDF_BYTES } from '@faunosteo/pdf' @@ -87,17 +86,3 @@ export async function importReportFromPdf( ): Promise { return importAttachment(await readAttachment(pdfBytes), index) } - -/** - * A rescue copy (`JSON.stringify(report)`, the byte format of the tab's draft) - * read by the core's draft restore, no archive beside it. Content the core - * refuses is `invalid_copy`; any other failure is the engine's or the sheet's. - */ -export function readRescueCopy(text: string, index: SheetIndex): RebaseOutcome { - const outcome = index.ops.restoreDraft(text, null) - if (outcome.ok) return outcome.value.rebase - if (UNREADABLE_DRAFT_KINDS.has(outcome.kind)) { - throw new ImportError('invalid_copy') - } - throw new ImportError('core_unavailable') -} diff --git a/apps/app/src/sheets/useSheet.ts b/apps/app/src/sheets/useSheet.ts index 388e5ea9..5419cb35 100644 --- a/apps/app/src/sheets/useSheet.ts +++ b/apps/app/src/sheets/useSheet.ts @@ -1,6 +1,7 @@ import { useEffect, useState } from 'react' import type { SheetIndexData } from '@faunosteo/core-wasm/types' import { coreRuntime } from '@/core/runtime' +import { prefetchImportWorker } from '@/core/worker/controller' import { SheetOps } from '@/core/sheetOps' import { SheetIndex } from '@/services/sheetIndex' import { @@ -50,10 +51,13 @@ async function loadIntoCore(speciesId: string): Promise { const data = session.call('index_data', '') if (data.ok) { const index = new SheetIndex(data.value, new SheetOps(session)) + // The engine is loaded: warm the import worker's chunk for a later offline import. + prefetchImportWorker() return { status: 'ready', index } } return { - status: data.kind === 'invalid_sheet' ? 'invalid_sheet' : 'core_unavailable', + status: + data.kind === 'invalid_sheet' ? 'invalid_sheet' : 'core_unavailable', } } @@ -73,6 +77,17 @@ export function loadSheet(speciesId: string): Promise { return pending } +/** + * The bundled payload as the text the core's `SheetHandle` reads, for the import worker + * (R4.3): the same text the page's own session was built from. Null without a sheet. + */ +export async function loadSheetBundleText( + speciesId: string, +): Promise { + const bundle = await provider.getReferenceSheet(speciesId) + return bundle ? JSON.stringify(bundle) : null +} + /** The ready index, or null (tests and callers that need the sheet or nothing). */ export async function loadSheetIndex( speciesId: string, @@ -99,7 +114,8 @@ export function useSheet(speciesId: string | undefined): SheetState { void loadSheet(speciesId).then((load) => { if (cancelled) return if (load.status === 'ready' || load.status === 'none') setState(load) - else if (load.status === 'invalid_sheet') setState({ status: load.status, retry }) + else if (load.status === 'invalid_sheet') + setState({ status: load.status, retry }) else setState({ status: 'core_unavailable', retry }) }) return () => { diff --git a/apps/app/tests/helpers/core.ts b/apps/app/tests/helpers/core.ts index 691c245c..584b6319 100644 --- a/apps/app/tests/helpers/core.ts +++ b/apps/app/tests/helpers/core.ts @@ -55,6 +55,7 @@ export async function trappingCoreRuntime(marker: string) { core_version: glue.core_version, call: glue.call, SheetHandle: Trapping, + FileBytes: glue.FileBytes, } }, } diff --git a/apps/app/tests/helpers/importWorker.ts b/apps/app/tests/helpers/importWorker.ts new file mode 100644 index 00000000..8f06a75e --- /dev/null +++ b/apps/app/tests/helpers/importWorker.ts @@ -0,0 +1,115 @@ +import { nodeCoreSource } from '@faunosteo/core-wasm/node' +import type { WorkerLike } from '@/core/worker/client' +import { setImportWorkerSpawn } from '@/core/worker/controller' +import { + createWorkerHandler, + type EngineLoader, + type WorkerEngine, +} from '@/core/worker/handler' +import type { WorkerMessage } from '@/core/worker/protocol' + +/** + * The import worker run in-process (happy-dom has no `Worker`): a `WorkerLike` whose + * `postMessage` feeds the worker handler and whose answers come back through `onmessage` + * on a later tick, as a real worker's would; `terminate` drops every later answer. The + * engine is the Node module by default; a test passes its own loader for failures. + */ + +let instances = 0 + +/** The shipped module instantiated afresh (one instance per worker, as in the browser). */ +export const nodeEngineLoader: EngineLoader = async (module) => { + const source = nodeCoreSource('pkg') + instances += 1 + const glue = await source.importGlue(1000 + instances) + const compiled = module ?? (await source.compile()) + const exports = (await glue.default({ module_or_path: compiled })) as { + memory?: WebAssembly.Memory + } + return { + SheetHandle: glue.SheetHandle, + FileBytes: glue.FileBytes, + memory: exports.memory ?? null, + } +} + +export interface FakeWorker extends WorkerLike { + terminated: boolean + /** Every message the page posted to the worker (the task, as the worker receives it). */ + received: unknown[] + /** Every message the worker posted, dropped or delivered. */ + posted: WorkerMessage[] +} + +export function inProcessWorker( + load: EngineLoader = nodeEngineLoader, +): FakeWorker { + const worker: FakeWorker = { + terminated: false, + received: [], + posted: [], + onmessage: null, + onerror: null, + onmessageerror: null, + terminate() { + worker.terminated = true + }, + postMessage(message) { + worker.received.push(message) + void handle(message) + }, + } + const handle = createWorkerHandler(load, (message) => { + worker.posted.push(message) + setTimeout(() => { + if (!worker.terminated) + worker.onmessage?.({ data: message } as MessageEvent) + }, 0) + }) + return worker +} + +/** Routes the page's imports through in-process workers; returns the spawned ones. */ +export function useInProcessImportWorker( + load: EngineLoader = nodeEngineLoader, +): { workers: FakeWorker[]; restore: () => void } { + const workers: FakeWorker[] = [] + setImportWorkerSpawn(() => { + const worker = inProcessWorker(load) + workers.push(worker) + return worker + }) + return { workers, restore: () => setImportWorkerSpawn(null) } +} + +/** An engine whose `SheetHandle` throws `error` on every import call (a trap, say). */ +export function throwingEngineLoader(error: Error): EngineLoader { + return async (module) => { + const engine = await nodeEngineLoader(module) + class Throwing extends engine.SheetHandle { + import_pdf_bytes(): string { + throw error + } + restore_copy_bytes(): string { + throw error + } + } + return { ...engine, SheetHandle: Throwing } as WorkerEngine + } +} + +/** An engine whose import calls answer the envelope text `out` (a core refusal, say). */ +export function answeringEngineLoader(out: string): EngineLoader { + return async (module) => { + const engine = await nodeEngineLoader(module) + class Answering extends engine.SheetHandle { + import_pdf_bytes(): string { + return out + } + restore_copy_bytes(): string { + return out + } + } + return { ...engine, SheetHandle: Answering } as WorkerEngine + } +} diff --git a/apps/app/tests/helpers/pdfBytes.ts b/apps/app/tests/helpers/pdfBytes.ts new file mode 100644 index 00000000..0cc3661e --- /dev/null +++ b/apps/app/tests/helpers/pdfBytes.ts @@ -0,0 +1,86 @@ +/** + * Minimal PDFs for the import tests, byte for byte as `pdfWith` of + * `scripts/browser/lib/hostile-classes.mjs` writes them (uncompressed streams, no + * padding): the core's scanner reads the objects in clear, so an archive is a + * `/Type /EmbeddedFile` stream, a `/Filespec` naming it, and the + * `/Keywords (faunosteo-archive/1)` stamp. + */ + +const ATTACHMENT_NAME = 'osteo-report.json' +const STAMP = '<< /Keywords (faunosteo-archive/1) >>' +const OTHER_PRODUCER = '<< /Producer (another tool) >>' + +const utf8 = (text: string) => new TextEncoder().encode(text) + +/** Bytes a `File` accepts as a part (never a shared buffer). */ +type Bytes = Uint8Array + +interface EmbeddedStream { + bytes: Bytes + /** The Filespec name; none leaves the stream unnamed. */ + name?: string +} + +function concat(parts: Bytes[]): Bytes { + const out = new Uint8Array(parts.reduce((sum, p) => sum + p.byteLength, 0)) + let at = 0 + for (const part of parts) { + out.set(part, at) + at += part.byteLength + } + return out +} + +/** One EmbeddedFile object (number `n`) and its Filespec (`n + 1`) when named. */ +function streamObjects(stream: EmbeddedStream, n: number): Bytes[] { + const length = stream.bytes.byteLength + const parts = [ + utf8(`${n} 0 obj\n<< /Type /EmbeddedFile /Length ${length}`), + utf8(' >>\nstream\n'), + stream.bytes, + utf8('\nendstream\nendobj\n'), + ] + if (stream.name) { + parts.push( + utf8(`${n + 1} 0 obj\n<< /Type /Filespec /F (${stream.name})`), + utf8(` /EF << /F ${n} 0 R >> >>\nendobj\n`), + ) + } + return parts +} + +/** A PDF holding `streams`, then the Faunosteo stamp (or another producer's info). */ +export function pdfWith( + streams: EmbeddedStream[], + { stamp = true }: { stamp?: boolean } = {}, +): Bytes { + const parts = [utf8('%PDF-1.7\n%\xE2\xE3\xCF\xD3\n')] + let n = 1 + for (const stream of streams) { + parts.push(...streamObjects(stream, n)) + n += 2 + } + const info = stamp ? STAMP : OTHER_PRODUCER + parts.push(utf8(`${n} 0 obj\n${info}\nendobj\n%%EOF\n`)) + return concat(parts) +} + +/** A Faunosteo PDF whose `osteo-report.json` attachment holds `json`. */ +export function archivePdf(json: string): Bytes { + return pdfWith([{ bytes: utf8(json), name: ATTACHMENT_NAME }]) +} + +/** The stamp without its attachment: a Faunosteo PDF a tool stripped. */ +export function strippedPdf(): Bytes { + return pdfWith([]) +} + +/** A PDF of another producer: no stamp, no attachment. */ +export function foreignPdf(): Bytes { + return pdfWith([], { stamp: false }) +} + +/** `bytes` as the file the practitioner picks. */ +export function pdfFile(bytes: Bytes, name = 'bilan.pdf'): File { + return new File([bytes], name, { type: 'application/pdf' }) +} diff --git a/apps/app/tests/unit/core.importClient.test.ts b/apps/app/tests/unit/core.importClient.test.ts new file mode 100644 index 00000000..0ebe536d --- /dev/null +++ b/apps/app/tests/unit/core.importClient.test.ts @@ -0,0 +1,280 @@ +/** + * R4.3: the page side of one import (plan §B.1.5 items 1, 3, 5): the worker created in a + * try/catch, listeners before the post, the start timer until `ready`, the task timer + * after, settle once on the first of result / failed / error event / timer / cancel, the + * worker terminated in every case, later messages ignored, timers paused while hidden. + */ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { + runImportTask, + type ImportSettlement, + type WorkerLike, +} from '@/core/worker/client' +import { PROTOCOL_VERSION } from '@/core/worker/protocol' +import type { Visibility } from '@/core/worker/timers' + +/** A scripted worker: the test drives its messages and events. */ +function scriptedWorker() { + const worker: WorkerLike & { terminated: number; sent: unknown[] } = { + terminated: 0, + sent: [], + onmessage: null, + onerror: null, + onmessageerror: null, + postMessage: (m) => worker.sent.push(m), + terminate: () => { + worker.terminated += 1 + }, + } + const emit = (data: unknown) => worker.onmessage?.({ data } as MessageEvent) + return { + worker, + ready: () => emit({ v: PROTOCOL_VERSION, type: 'ready' }), + result: (out = '{"ok":true}') => + emit({ + v: PROTOCOL_VERSION, + type: 'result', + out, + diag: { ms: 1, linearBytes: 0, chunks: 1 }, + }), + failed: (phase: 'start' | 'task', kind: string) => + emit({ + v: PROTOCOL_VERSION, + type: 'failed', + phase, + kind, + detail: `${kind}!`, + }), + error: (message: string) => worker.onerror?.({ message } as ErrorEvent), + } +} + +function visibility(): Visibility & { set: (hidden: boolean) => void } { + let hidden = false + const listeners = new Set<() => void>() + return { + hidden: () => hidden, + onChange: (listener) => { + listeners.add(listener) + return () => listeners.delete(listener) + }, + set: (next) => { + hidden = next + for (const listener of listeners) listener() + }, + } +} + +const file = new File([new Uint8Array([1])], 'a.pdf') +const input = { task: 'pdf' as const, file, sheet: '{}', module: null } + +async function settled(run: { + settled: Promise +}): Promise { + await vi.advanceTimersByTimeAsync(0) + return run.settled +} + +describe('import client', () => { + beforeEach(() => vi.useFakeTimers()) + afterEach(() => vi.useRealTimers()) + + it('posts the task after installing the listeners, then settles on the result and terminates', async () => { + const s = scriptedWorker() + const run = runImportTask(input, { + spawn: () => s.worker, + startTimeoutMs: 100, + taskTimeoutMs: 100, + }) + expect(s.worker.onmessage).not.toBeNull() + expect(s.worker.sent).toEqual([{ v: 1, type: 'task', ...input }]) + s.ready() + s.result('{"ok":true}') + expect(await settled(run)).toMatchObject({ + kind: 'result', + out: '{"ok":true}', + }) + expect(s.worker.terminated).toBe(1) + }) + + it('is worker_unavailable when the spawn throws, fails before ready, or never answers ready', async () => { + const thrown = runImportTask(input, { + spawn: () => { + throw new DOMException('blocked', 'SecurityError') + }, + startTimeoutMs: 100, + taskTimeoutMs: 100, + }) + expect(await settled(thrown)).toEqual({ + kind: 'failed', + reason: 'worker_unavailable', + detail: 'SecurityError', + }) + + const early = scriptedWorker() + const failedEarly = runImportTask(input, { + spawn: () => early.worker, + startTimeoutMs: 100, + taskTimeoutMs: 100, + }) + early.failed('start', 'other') + expect(await settled(failedEarly)).toMatchObject({ + kind: 'failed', + reason: 'worker_unavailable', + }) + + const silent = scriptedWorker() + const timedOut = runImportTask(input, { + spawn: () => silent.worker, + startTimeoutMs: 100, + taskTimeoutMs: 1000, + }) + await vi.advanceTimersByTimeAsync(99) + expect(silent.worker.terminated).toBe(0) + await vi.advanceTimersByTimeAsync(2) + expect(await timedOut.settled).toMatchObject({ + kind: 'failed', + reason: 'worker_unavailable', + }) + expect(silent.worker.terminated).toBe(1) + }) + + it('maps task failures: trap → crashed, read → read, sheet/other → engine, timer → timeout', async () => { + for (const [kind, reason] of [ + ['trap', 'crashed'], + ['read', 'read'], + ['sheet', 'engine'], + ['other', 'engine'], + ]) { + const s = scriptedWorker() + const run = runImportTask(input, { + spawn: () => s.worker, + startTimeoutMs: 100, + taskTimeoutMs: 100, + }) + s.ready() + s.failed('task', kind!) + expect(await settled(run)).toEqual({ + kind: 'failed', + reason, + detail: `${kind}!`, + }) + expect(s.worker.terminated).toBe(1) + } + const slow = scriptedWorker() + const run = runImportTask(input, { + spawn: () => slow.worker, + startTimeoutMs: 50, + taskTimeoutMs: 200, + }) + await vi.advanceTimersByTimeAsync(40) + slow.ready() + await vi.advanceTimersByTimeAsync(199) + expect(slow.worker.terminated).toBe(0) + await vi.advanceTimersByTimeAsync(2) + expect(await run.settled).toMatchObject({ + kind: 'failed', + reason: 'timeout', + }) + }) + + it('settles once: a result after the timeout, a failure after the result, are ignored', async () => { + const s = scriptedWorker() + const run = runImportTask(input, { + spawn: () => s.worker, + startTimeoutMs: 100, + taskTimeoutMs: 100, + }) + s.ready() + await vi.advanceTimersByTimeAsync(101) + s.result('{"ok":true}') + expect(await run.settled).toMatchObject({ + kind: 'failed', + reason: 'timeout', + }) + expect(s.worker.terminated).toBe(1) + + const t = scriptedWorker() + const second = runImportTask(input, { + spawn: () => t.worker, + startTimeoutMs: 100, + taskTimeoutMs: 100, + }) + t.ready() + t.result('{"ok":true}') + t.failed('task', 'trap') + t.error('late') + expect(await settled(second)).toMatchObject({ kind: 'result' }) + expect(t.worker.terminated).toBe(1) + }) + + it('never masks an error event: worker_unavailable before ready, crashed after', async () => { + const before = scriptedWorker() + const first = runImportTask(input, { + spawn: () => before.worker, + startTimeoutMs: 100, + taskTimeoutMs: 100, + }) + before.error('script failed') + expect(await settled(first)).toEqual({ + kind: 'failed', + reason: 'worker_unavailable', + detail: 'script failed', + }) + const after = scriptedWorker() + const second = runImportTask(input, { + spawn: () => after.worker, + startTimeoutMs: 100, + taskTimeoutMs: 100, + }) + after.ready() + after.error('boom') + expect(await settled(second)).toEqual({ + kind: 'failed', + reason: 'crashed', + detail: 'boom', + }) + }) + + it('cancel terminates the worker and settles cancelled, once', async () => { + const s = scriptedWorker() + const run = runImportTask(input, { + spawn: () => s.worker, + startTimeoutMs: 100, + taskTimeoutMs: 100, + }) + s.ready() + run.cancel() + run.cancel() + s.result() + expect(await settled(run)).toMatchObject({ + kind: 'failed', + reason: 'cancelled', + }) + expect(s.worker.terminated).toBe(1) + }) + + it('pauses the task timer while the page is hidden', async () => { + const s = scriptedWorker() + const vis = visibility() + const run = runImportTask(input, { + spawn: () => s.worker, + startTimeoutMs: 100, + taskTimeoutMs: 100, + visibility: vis, + }) + s.ready() + await vi.advanceTimersByTimeAsync(50) + vis.set(true) + await vi.advanceTimersByTimeAsync(10_000) + expect(s.worker.terminated).toBe(0) + vis.set(false) + await vi.advanceTimersByTimeAsync(49) + expect(s.worker.terminated).toBe(0) + await vi.advanceTimersByTimeAsync(2) + expect(await run.settled).toMatchObject({ + kind: 'failed', + reason: 'timeout', + }) + }) +}) diff --git a/apps/app/tests/unit/core.importWorker.test.ts b/apps/app/tests/unit/core.importWorker.test.ts new file mode 100644 index 00000000..7d9c4bcd --- /dev/null +++ b/apps/app/tests/unit/core.importWorker.test.ts @@ -0,0 +1,211 @@ +/** + * R4.3: the import worker's logic in-process on the shipped module (plan §B.1.5 items 2 + * and 4): one task, `ready` then one `result` or one `failed` with its phase and kind; + * the file streamed into the module's memory; the caps checked before any read; every + * throwable classified (trap, read, sheet, other) and the start phase kept apart. + */ +import { readFileSync } from 'node:fs' +import { resolve } from 'node:path' +import { describe, expect, it } from 'vitest' +import { + createWorkerHandler, + MAX_COPY_BYTES, + MAX_PDF_BYTES, +} from '@/core/worker/handler' +import { PROTOCOL_VERSION, type WorkerMessage } from '@/core/worker/protocol' +import { bundledSheetProvider } from '@/sheets/provider' +import { FIXTURES_DIR } from '../helpers/goldens' +import { nodeEngineLoader, throwingEngineLoader } from '../helpers/importWorker' + +const fixture = (name: string) => readFileSync(resolve(FIXTURES_DIR, name)) + +async function sheetText(): Promise { + const bundle = await bundledSheetProvider.getReferenceSheet('equine') + if (!bundle) throw new Error('bundled sheet missing') + return JSON.stringify(bundle) +} + +interface Run { + messages: WorkerMessage[] +} + +async function run( + task: 'pdf' | 'copy', + file: File, + load = nodeEngineLoader, + sheet?: string, +): Promise { + const messages: WorkerMessage[] = [] + const handle = createWorkerHandler(load, (m) => messages.push(m)) + await handle({ + v: PROTOCOL_VERSION, + type: 'task', + task, + file, + sheet: sheet ?? (await sheetText()), + module: null, + }) + return { messages } +} + +function envelope(messages: WorkerMessage[]): { + ok: boolean + kind?: string + value?: unknown +} { + const result = messages.find((m) => m.type === 'result') + if (!result || result.type !== 'result') + throw new Error(`no result: ${JSON.stringify(messages)}`) + return JSON.parse(result.out) +} + +describe('import worker handler (in-process, shipped module)', () => { + it('answers ready then a result for a Faunosteo PDF, streamed in chunks', async () => { + const file = new File([fixture('report-v3.bare.pdf')], 'bilan.pdf') + const { messages } = await run('pdf', file) + expect(messages.map((m) => m.type)).toEqual(['ready', 'result']) + const out = envelope(messages) + expect(out.ok).toBe(true) + expect( + (out.value as { rebase: { report: { version: number } } }).rebase.report + .version, + ).toBe(3) + const result = messages[1] + if (result?.type !== 'result') throw new Error('no result') + expect(result.diag.chunks).toBeGreaterThanOrEqual(1) + expect(result.diag.linearBytes).toBeGreaterThan(0) + }) + + it('reads a rescue copy through the core (strict UTF-8, no JSON wrapping)', async () => { + const file = new File([fixture('report-v3.demo.json')], 'copie.json') + const { messages } = await run('copy', file) + expect(envelope(messages).ok).toBe(true) + const bad = new File([new Uint8Array([0x7b, 0xff, 0x7d])], 'copie.json') + expect(envelope((await run('copy', bad)).messages)).toMatchObject({ + ok: false, + kind: 'invalid', + }) + }) + + it('refuses an oversized file before reading a byte', async () => { + const huge = { + size: MAX_PDF_BYTES + 1, + stream: () => { + throw new Error('read') + }, + } as unknown as File + expect(envelope((await run('pdf', huge)).messages)).toMatchObject({ + ok: false, + kind: 'invalid_pdf', + }) + const copy = { + size: MAX_COPY_BYTES + 1, + stream: () => { + throw new Error('read') + }, + } as unknown as File + expect(envelope((await run('copy', copy)).messages)).toMatchObject({ + ok: false, + kind: 'invalid', + }) + }) + + it('gives the core kinds for a foreign PDF and garbage', async () => { + const garbage = new File([new TextEncoder().encode('hello')], 'x.pdf') + expect(envelope((await run('pdf', garbage)).messages)).toMatchObject({ + ok: false, + kind: 'invalid_pdf', + }) + const stripped = new File( + [new TextEncoder().encode('%PDF-1.7\n/Keywords (faunosteo-archive/1)')], + 'x.pdf', + ) + expect(envelope((await run('pdf', stripped)).messages)).toMatchObject({ + ok: false, + kind: 'attachment_stripped', + }) + }) + + it('classifies a trap during the task as failed/task/trap', async () => { + const file = new File([fixture('report-v3.bare.pdf')], 'bilan.pdf') + const load = throwingEngineLoader( + new WebAssembly.RuntimeError('unreachable'), + ) + const { messages } = await run('pdf', file, load) + expect(messages).toEqual([ + { v: 1, type: 'ready' }, + { + v: 1, + type: 'failed', + phase: 'task', + kind: 'trap', + detail: 'RuntimeError: unreachable', + }, + ]) + const overflow = throwingEngineLoader( + new RangeError('Maximum call stack size exceeded'), + ) + expect((await run('pdf', file, overflow)).messages[1]).toMatchObject({ + kind: 'trap', + }) + }) + + it('classifies a file that cannot be read as failed/task/read', async () => { + const error = new DOMException( + 'The file could not be read', + 'NotReadableError', + ) + const unreadable = { + size: 10, + stream: () => ({ + getReader: () => ({ + read: () => Promise.reject(error), + cancel: async () => {}, + }), + }), + } as unknown as File + const { messages } = await run('pdf', unreadable) + expect(messages[1]).toMatchObject({ + type: 'failed', + phase: 'task', + kind: 'read', + }) + }) + + it('classifies a refused sheet as failed/task/sheet and a load failure as start', async () => { + const file = new File([fixture('report-v3.bare.pdf')], 'bilan.pdf') + const refused = await run( + 'pdf', + file, + nodeEngineLoader, + '{"status":"draft"}', + ) + expect(refused.messages[1]).toMatchObject({ + type: 'failed', + phase: 'task', + kind: 'sheet', + }) + const broken = await run('pdf', file, () => + Promise.reject(new TypeError('no glue')), + ) + expect(broken.messages).toEqual([ + { + v: 1, + type: 'failed', + phase: 'start', + kind: 'other', + detail: 'TypeError: no glue', + }, + ]) + }) + + it('ignores a message that is not a task of this protocol', async () => { + const messages: WorkerMessage[] = [] + const handle = createWorkerHandler(nodeEngineLoader, (m) => + messages.push(m), + ) + await handle({ v: 2, type: 'task' }) + await handle('nope') + expect(messages).toEqual([]) + }) +}) diff --git a/apps/app/tests/unit/routes.HomeRoute.archive.test.tsx b/apps/app/tests/unit/routes.HomeRoute.archive.test.tsx index 2468b3b2..0907419d 100644 --- a/apps/app/tests/unit/routes.HomeRoute.archive.test.tsx +++ b/apps/app/tests/unit/routes.HomeRoute.archive.test.tsx @@ -1,8 +1,10 @@ /** - * T15 (STEP6 §7, §16): the home route on Step 6 archives, with the byte - * scan (`readAttachment`) mocked to hand over the attachment; the layered - * read and the rebase run in the core (R2). Every alert opens with a headline: complete - * restoration or partial recovery. Same sheet: archive kept in the store and + * T15 (STEP6 §7, §16): the home route on Step 6 archives, each envelope + * written into a minimal Faunosteo PDF (`helpers/pdfBytes`) and read by the + * import worker (R4.3: the real worker logic in-process on the shipped + * module): the byte scan, the layered read and the rebase all run in the + * core. Every alert opens with a headline: complete restoration or partial + * recovery. Same sheet: archive kept in the store and * mirrored, complete + archive_ok. Other sheet: the report is rebased on the * loaded sheet (unresolved flags, labels from the archived snapshot, sheet * ref updated) and the alert says degraded with the count; a rebase that @@ -32,21 +34,17 @@ import type { ReportArchiveEnvelope, } from '@faunosteo/core-wasm/types' import HomeRoute from '@/app/routes/HomeRoute' -import { ImportError, readAttachment } from '@/pdf/import' import { useReportStore } from '@/state/reportStore' import { ARCHIVE_KEY } from '@/state/persistence' import { useLocaleStore } from '@/state/localeStore' import { fr } from '@/i18n/fr' import type { SheetIndex } from '@/services/sheetIndex' +import { useInProcessImportWorker } from '../helpers/importWorker' +import { archivePdf, pdfFile, strippedPdf } from '../helpers/pdfBytes' import { archiveEnvelope, loadTestSheet, minimalReport } from '../helpers/sheet' -vi.mock('@/pdf/import', async (importOriginal) => ({ - ...(await importOriginal()), - readAttachment: vi.fn(), -})) -const readMock = vi.mocked(readAttachment) - let sheet: SheetIndex +let restoreSpawn: () => void beforeAll(async () => { sheet = await loadTestSheet() @@ -60,9 +58,10 @@ beforeEach(() => { activeObservationIndex: 0, }) vi.stubGlobal('alert', vi.fn()) - readMock.mockReset() + restoreSpawn = useInProcessImportWorker().restore }) afterEach(() => { + restoreSpawn() cleanup() vi.unstubAllGlobals() }) @@ -125,7 +124,8 @@ function staleReportAndArchive(): { return { report, archive } } -async function mountAndPickPdf(): Promise { +/** Home mounted, then `pdf` picked: a Faunosteo PDF the worker reads in full. */ +async function mountAndPickPdf(pdf: Uint8Array): Promise { render( @@ -137,12 +137,13 @@ async function mountAndPickPdf(): Promise { const button = screen.getByRole('button', { name: fr['home.import.cta'] }) await waitFor(() => expect(button).toBeEnabled()) const input = document.querySelector('input[type="file"]')! - const file = new File([new Uint8Array([37, 80, 68, 70])], 'bilan.pdf', { - type: 'application/pdf', - }) - fireEvent.change(input, { target: { files: [file] } }) + fireEvent.change(input, { target: { files: [pdfFile(pdf)] } }) } +/** The PDF the app exports for `archive`: the envelope as its attachment. */ +const pdfOf = (archive: ReportArchiveEnvelope) => + archivePdf(JSON.stringify(archive)) + const alertMock = () => vi.mocked(window.alert) /** The alert split on its blank lines: headline first, then the detail lines. */ const alertLines = () => (alertMock().mock.calls[0]![0] as string).split('\n\n') @@ -152,8 +153,7 @@ describe('HomeRoute import of a Step 6 archive', () => { it('same sheet: keeps the archive in the store and its mirror, alerts archive_ok, no rebase', async () => { const report = reportWithHip() const archive = archiveEnvelope(sheet, report) - readMock.mockResolvedValue(archive) - await mountAndPickPdf() + await mountAndPickPdf(pdfOf(archive)) await screen.findByTestId('editor-route') const state = useReportStore.getState() expect(state.report).toEqual(report) @@ -172,8 +172,7 @@ describe('HomeRoute import of a Step 6 archive', () => { const { report, archive } = staleReportAndArchive() // The attachment is the envelope of the stale report (read by the core). expect(archive.report).toBe(report) - readMock.mockResolvedValue(archive) - await mountAndPickPdf() + await mountAndPickPdf(pdfOf(archive)) await screen.findByTestId('editor-route') const opened = useReportStore.getState().report! expect(opened.sheet).toEqual(sheet.sheet.ref) @@ -205,8 +204,7 @@ describe('HomeRoute import of a Step 6 archive', () => { }) const archive = archiveEnvelope(sheet, report) archive.sheetSnapshot.ref.documentSha256 = OTHER_SHA - readMock.mockResolvedValue(archive) - await mountAndPickPdf() + await mountAndPickPdf(pdfOf(archive)) await screen.findByTestId('editor-route') const opened = useReportStore.getState().report! expect(opened.sheet).toEqual(sheet.sheet.ref) @@ -224,8 +222,7 @@ describe('HomeRoute import of a Step 6 archive', () => { // A label over the 512-character cap: the core drops the snapshot ('caps'). const archive = archiveEnvelope(sheet, report) archive.sheetSnapshot.document.name.fr = 'x'.repeat(513) - readMock.mockResolvedValue(archive) - await mountAndPickPdf() + await mountAndPickPdf(pdfOf(archive)) await screen.findByTestId('editor-route') expect(useReportStore.getState().report).toEqual(report) expect(useReportStore.getState().archive).toBeNull() @@ -241,8 +238,8 @@ describe('HomeRoute import of a Step 6 archive', () => { }) it('attachment_stripped → its error message, nothing opened', async () => { - readMock.mockRejectedValue(new ImportError('attachment_stripped')) - await mountAndPickPdf() + // The stamp says Faunosteo, the embedded file is gone (a tool rewrote the PDF). + await mountAndPickPdf(strippedPdf()) await waitFor(() => expect(errorText()).not.toBeNull()) expect(errorText()!.textContent).toBe( fr['home.import.error_attachment_stripped'], diff --git a/apps/app/tests/unit/routes.HomeRoute.import.test.tsx b/apps/app/tests/unit/routes.HomeRoute.import.test.tsx index 7c7d3500..24f5e9c9 100644 --- a/apps/app/tests/unit/routes.HomeRoute.import.test.tsx +++ b/apps/app/tests/unit/routes.HomeRoute.import.test.tsx @@ -1,11 +1,15 @@ /** - * Step 6 Phase 0 characterisation of the import flow on the home route, with - * the two import steps mocked (R2: `readAttachment`, the engine's byte scan, - * then `importAttachment`, the core's layered read and rebase on the loaded - * sheet): the migration alert (degraded headline, then the count), the three - * ImportError kinds plus the generic error mapped to the FR messages, and the - * navigation to /editor on success; `lone_surrogate` (L1) has its own message. + * Step 6 Phase 0 characterisation of the import flow on the home route, through the + * import worker (R4.3: the real worker logic in-process on the shipped module, the + * files real fixtures or minimal PDFs from `helpers/pdfBytes`): the picked file reaches + * the worker unread by the page, with the page's sheet and module, and the core's + * result hydrates the store on the loaded sheet; the migration alert (degraded + * headline, then the count), the core's refusal kinds plus a worker trap mapped to the + * FR messages, and the navigation to /editor on success; `lone_surrogate` (L1) has its + * own message. */ +import { readFileSync } from 'node:fs' +import { resolve } from 'node:path' import { describe, it, @@ -25,82 +29,89 @@ import { import { MemoryRouter, Route, Routes } from 'react-router-dom' import type { ArchiveImport } from '@faunosteo/core-wasm/types' import HomeRoute from '@/app/routes/HomeRoute' -import { - ImportError, - importAttachment, - MAX_PDF_BYTES, - readAttachment, -} from '@/pdf/import' +import { MAX_PDF_BYTES, type EngineLoader } from '@/core/worker/handler' +import type { ImportTaskMessage } from '@/core/worker/protocol' import { useReportStore } from '@/state/reportStore' import { useLocaleStore } from '@/state/localeStore' import { fr } from '@/i18n/fr' import type { SheetIndex } from '@/services/sheetIndex' -import { loadTestSheet, minimalReport } from '../helpers/sheet' - -vi.mock('@/pdf/import', async (importOriginal) => ({ - ...(await importOriginal()), - readAttachment: vi.fn(), - importAttachment: vi.fn(), -})) -const readMock = vi.mocked(readAttachment) -const importMock = vi.mocked(importAttachment) -const ATTACHMENT = { version: 3 } +import { FIXTURES_DIR } from '../helpers/goldens' +import { + throwingEngineLoader, + useInProcessImportWorker, + type FakeWorker, +} from '../helpers/importWorker' +import { archivePdf, foreignPdf, pdfFile } from '../helpers/pdfBytes' +import { bundledSheet, loadTestSheet, minimalReport } from '../helpers/sheet' let sheet: SheetIndex +let workers: FakeWorker[] +let restoreSpawn: () => void beforeAll(async () => { sheet = await loadTestSheet() }) beforeEach(() => { useLocaleStore.setState({ locale: 'fr' }) + // A fresh tab: the previous import's draft would be a held text. + sessionStorage.clear() useReportStore.setState({ report: null, archive: null, activeObservationIndex: 0, }) vi.stubGlobal('alert', vi.fn()) - readMock.mockReset() - readMock.mockResolvedValue(ATTACHMENT) - importMock.mockReset() + ;({ workers, restore: restoreSpawn } = useInProcessImportWorker()) }) afterEach(() => { + restoreSpawn() cleanup() vi.unstubAllGlobals() + vi.restoreAllMocks() }) -/** What the import resolves with: the read (bare report, no archive) and no rebase. */ -function outcome(patch: { - migrated: boolean - unresolvedZones?: number - unresolvedFindings?: number -}): ArchiveImport { - const report = minimalReport(sheet) - return { - read: { - report, - origin: patch.migrated ? 'v2' : 'bare_v3', - archive: null, - unresolvedZones: 0, - unresolvedFindings: 0, - ...patch, - }, - rebase: { - report, - unresolvedZones: 0, - unresolvedFindings: 0, - rebased: false, - }, +const fixture = (name: string) => + new Uint8Array(readFileSync(resolve(FIXTURES_DIR, name))) + +/** The demo report exported bare by the Step 6 code: same sheet, no archive. */ +const barePdf = () => pdfFile(fixture('report-v3.bare.pdf')) + +/** A Report v2 holding one zone and one finding the migration map does not know. */ +function lossyV2Pdf(): File { + const v2 = JSON.parse( + readFileSync(resolve(FIXTURES_DIR, 'report-v2.minimal.json'), 'utf8'), + ) + const observation = { + id: 'obs-lost', + zones: [{ boneId: 'point-gone' }], + findings: [ + { + zoneId: 'zone-gone', + path: ['zone-gone-dysfunctions', 'gone'], + labelFrSnapshot: 'Constat disparu', + labelEnSnapshot: 'Gone finding', + }, + ], + freeTextFindings: [], + comment: '', } + const report = { ...v2, observations: [observation] } + return pdfFile(archivePdf(JSON.stringify(report))) } -/** A 4-byte "%PDF" file; the import is mocked, the bytes only travel. */ -function pdfFile(): File { - return new File([new Uint8Array([37, 80, 68, 70])], 'bilan.pdf', { - type: 'application/pdf', - }) +/** The core's import outcome the worker answered (the result message, parsed). */ +function resultOf(worker: FakeWorker): ArchiveImport { + const result = worker.posted.find((m) => m.type === 'result') + if (result?.type !== 'result') throw new Error('the worker gave no result') + const envelope = JSON.parse(result.out) as { + ok: boolean + value: ArchiveImport + } + if (!envelope.ok) throw new Error(`the core refused: ${result.out}`) + return envelope.value } -async function mountAndPickPdf(file: File = pdfFile()): Promise { +async function mountAndPickPdf(file: File = barePdf()): Promise { render( @@ -120,25 +131,44 @@ const errorText = () => screen.queryByText(/./, { selector: 'p.text-red-700' }) describe('HomeRoute import: success paths', () => { it('passes the file bytes to the scan and the attachment to the loaded sheet, hydrates, navigates to /editor', async () => { - importMock.mockReturnValue(outcome({ migrated: false })) - await mountAndPickPdf() - await screen.findByTestId('editor-route') - expect(readMock).toHaveBeenCalledTimes(1) - expect(readMock.mock.calls[0]![0]).toBeInstanceOf(Uint8Array) - expect(importMock).toHaveBeenCalledTimes(1) - const [attachment, index] = importMock.mock.calls[0]! - expect(attachment).toBe(ATTACHMENT) + // Since R4.3 the scan runs in the worker: the page hands it the file unread. + const file = barePdf() + const read = vi.spyOn(file, 'arrayBuffer') + const text = vi.spyOn(file, 'text') + const real = useReportStore.getState().hydrateImport + const hydrate = vi.fn(real) + useReportStore.setState({ hydrateImport: hydrate }) + try { + await mountAndPickPdf(file) + await screen.findByTestId('editor-route') + } finally { + useReportStore.setState({ hydrateImport: real }) + } + expect(workers).toHaveLength(1) + const task = workers[0]!.received[0] as ImportTaskMessage + expect(task).toMatchObject({ type: 'task', task: 'pdf' }) + expect(task.file).toBe(file) + expect(task.sheet).toBe(JSON.stringify(await bundledSheet())) + expect(task.module).toBeInstanceOf(WebAssembly.Module) + expect(read).not.toHaveBeenCalled() + expect(text).not.toHaveBeenCalled() + const imported = resultOf(workers[0]!) + expect(hydrate).toHaveBeenCalledTimes(1) + const [session, index] = hydrate.mock.calls[0]! + expect(session).toEqual({ report: imported.rebase.report, archive: null }) expect(index).toBe(sheet) - expect(useReportStore.getState().report?.id).toBe('r1') + expect(useReportStore.getState().report?.id).toBe('fixture-demo-v3') expect(alertMock()).not.toHaveBeenCalled() }) it('alerts "degraded" then the unresolved count (zones + findings) after a lossy migration', async () => { - importMock.mockReturnValue( - outcome({ migrated: true, unresolvedZones: 1, unresolvedFindings: 1 }), - ) - await mountAndPickPdf() + await mountAndPickPdf(lossyV2Pdf()) await screen.findByTestId('editor-route') + expect(resultOf(workers[0]!).read).toMatchObject({ + migrated: true, + unresolvedZones: 1, + unresolvedFindings: 1, + }) expect(alertMock()).toHaveBeenCalledTimes(1) const message = alertMock().mock.calls[0]![0] as string const [headline, ...lines] = message.split('\n\n') @@ -147,49 +177,66 @@ describe('HomeRoute import: success paths', () => { }) it('stays silent on a migration that lost nothing', async () => { - importMock.mockReturnValue(outcome({ migrated: true })) - await mountAndPickPdf() + // The Step 5 v2 export: every zone and finding has its place on the draft. + await mountAndPickPdf(pdfFile(fixture('report-v2.full.pdf'))) await screen.findByTestId('editor-route') + expect(resultOf(workers[0]!).read).toMatchObject({ + migrated: true, + unresolvedZones: 0, + unresolvedFindings: 0, + }) expect(alertMock()).not.toHaveBeenCalled() }) }) describe('HomeRoute import: error paths', () => { - const cases: Array<[string, Error, string]> = [ + const cases: Array<[string, () => File, string, EngineLoader?]> = [ [ 'incompatible_version → message with the found version', - new ImportError('incompatible_version', 7), + () => + pdfFile( + archivePdf(JSON.stringify({ ...minimalReport(sheet), version: 7 })), + ), fr['home.import.error_incompatible_version']!.replace('{version}', '7'), ], [ 'invalid_pdf → unreadable PDF message', - new ImportError('invalid_pdf'), + () => pdfFile(new TextEncoder().encode('not a PDF at all')), fr['home.import.error_invalid_pdf']!, ], [ 'no_attachment → not a Faunosteo PDF message', - new ImportError('no_attachment'), + () => pdfFile(foreignPdf()), fr['home.import.error_no_attachment']!, ], [ 'lone_surrogate → malformed text message, file untouched', - new ImportError('lone_surrogate'), + () => + pdfFile( + archivePdf( + JSON.stringify(minimalReport(sheet, { conclusion: 'a\ud800b' })), + ), + ), fr['home.import.error_lone_surrogate']!, ], [ 'generic Error → generic message', - new Error('disk on fire'), + // A trap of the worker's engine: never shown as a corrupt PDF (OD-5). + barePdf, fr['home.import.error_generic']!, + throwingEngineLoader(new WebAssembly.RuntimeError('unreachable')), ], ] - it.each(cases)('%s', async (_label, error, expected) => { - importMock.mockImplementation(() => { - throw error - }) - await mountAndPickPdf() + it.each(cases)('%s', async (_label, file, expected, load) => { + // Another engine replaces the seam; afterEach restores the default. + if (load) { + ;({ workers, restore: restoreSpawn } = useInProcessImportWorker(load)) + } + await mountAndPickPdf(file()) await waitFor(() => expect(errorText()).not.toBeNull()) expect(errorText()!.textContent).toBe(expected) + expect(workers).toHaveLength(1) expect(screen.queryByTestId('editor-route')).toBeNull() expect(useReportStore.getState().report).toBeNull() expect(alertMock()).not.toHaveBeenCalled() @@ -198,15 +245,16 @@ describe('HomeRoute import: error paths', () => { describe('HomeRoute import: size gate', () => { it('refuses a file over MAX_PDF_BYTES before reading it: unreadable PDF message', async () => { - const file = pdfFile() + const file = barePdf() Object.defineProperty(file, 'size', { value: MAX_PDF_BYTES + 1 }) const read = vi.spyOn(file, 'arrayBuffer') + const stream = vi.spyOn(file, 'stream') await mountAndPickPdf(file) await waitFor(() => expect(errorText()).not.toBeNull()) expect(errorText()!.textContent).toBe(fr['home.import.error_invalid_pdf']) expect(read).not.toHaveBeenCalled() - expect(readMock).not.toHaveBeenCalled() - expect(importMock).not.toHaveBeenCalled() + expect(stream).not.toHaveBeenCalled() + expect(workers).toHaveLength(0) expect(screen.queryByTestId('editor-route')).toBeNull() expect(useReportStore.getState().report).toBeNull() }) @@ -214,12 +262,13 @@ describe('HomeRoute import: size gate', () => { describe('HomeRoute import: a core failure reading the tab draft', () => { it('shows the engine error line, not the held-session alert', async () => { - importMock.mockReturnValue(outcome({ migrated: false })) const real = useReportStore.getState().hydrateImport useReportStore.setState({ hydrateImport: () => ({ ok: false }) }) try { await mountAndPickPdf() await screen.findByText(fr['home.import.error_core_unavailable']!) + // The worker read the file: the failure is the store's, after the result. + expect(workers[0]!.posted.map((m) => m.type)).toEqual(['ready', 'result']) expect(alertMock()).not.toHaveBeenCalled() expect(screen.queryByTestId('editor-route')).toBeNull() } finally { @@ -228,12 +277,14 @@ describe('HomeRoute import: a core failure reading the tab draft', () => { }) it('still alerts and opens the editor for a held session text', async () => { - importMock.mockReturnValue(outcome({ migrated: false })) const real = useReportStore.getState().hydrateImport - useReportStore.setState({ hydrateImport: () => ({ ok: false, reason: 'held' }) }) + useReportStore.setState({ + hydrateImport: () => ({ ok: false, reason: 'held' }), + }) try { await mountAndPickPdf() await screen.findByTestId('editor-route') + expect(workers[0]!.posted.map((m) => m.type)).toEqual(['ready', 'result']) expect(alertMock()).toHaveBeenCalledWith(fr['session.held_blocked']) } finally { useReportStore.setState({ hydrateImport: real }) diff --git a/apps/app/tests/unit/routes.HomeRoute.messages.test.tsx b/apps/app/tests/unit/routes.HomeRoute.messages.test.tsx new file mode 100644 index 00000000..cea23138 --- /dev/null +++ b/apps/app/tests/unit/routes.HomeRoute.messages.test.tsx @@ -0,0 +1,264 @@ +/** + * R4.3: the Home import's message on every file of the frozen corpora, through the real + * worker logic in-process on the shipped module (plan §B.1.8, OD-5). O8 (the full R3 + * path, 51 PDFs: expected outcome from `tolerance.json`, the declared OD-3 / OD-4 + * differences applied), O7 (the stored reader inputs: expected from `readReportArchive`), + * the O2 PDFs of the R3 build, the O3 envelopes and the Step 5 fixtures (all open the + * editor). A technical failure of the worker is never shown as a corrupt PDF: a trap, a + * timeout and an unreadable file give « Erreur de lecture du PDF. », a worker that + * cannot start the engine message. + */ +import { readdirSync, readFileSync } from 'node:fs' +import { join, resolve } from 'node:path' +import { + afterEach, + beforeAll, + beforeEach, + describe, + expect, + it, + vi, +} from 'vitest' +import { + cleanup, + fireEvent, + render, + screen, + waitFor, +} from '@testing-library/react' +import { MemoryRouter, Route, Routes } from 'react-router-dom' +import HomeRoute from '@/app/routes/HomeRoute' +import { coreRuntime } from '@/core/runtime' +import { setImportWorkerSpawn } from '@/core/worker/controller' +import { useReportStore } from '@/state/reportStore' +import { useLocaleStore } from '@/state/localeStore' +import { fr } from '@/i18n/fr' +import { FIXTURES_DIR } from '../helpers/goldens' +import { + throwingEngineLoader, + useInProcessImportWorker, +} from '../helpers/importWorker' + +const ROOT = resolve(FIXTURES_DIR, '../../../..') +const oracle = (name: string) => + JSON.parse( + readFileSync(join(ROOT, 'crates/core/tests/oracles/r4', name), 'utf8'), + ) + +/** The message of a failure kind (plan §B.1.8), `editor` for a success. */ +function expectedOf(outcome: { + ok: boolean + kind?: string + foundVersion?: number +}): string { + if (outcome.ok) return 'editor' + switch (outcome.kind) { + case 'incompatible_version': + return fr['home.import.error_incompatible_version']!.replace( + '{version}', + String(outcome.foundVersion), + ) + case 'invalid_pdf': + return fr['home.import.error_invalid_pdf']! + case 'attachment_stripped': + return fr['home.import.error_attachment_stripped']! + case 'no_attachment': + return fr['home.import.error_no_attachment']! + case 'lone_surrogate': + return fr['home.import.error_lone_surrogate']! + default: + throw new Error(`unexpected kind ${outcome.kind}`) + } +} + +/** Rust outcomes that differ from the R3 path on purpose (RUST.md §10.3). */ +const DECLARED: Record = { + 'values-1m': { ok: false, kind: 'attachment_stripped' }, + 'surrogate-content-overwritten': { ok: false, kind: 'lone_surrogate' }, + 'surrogate-version-overwritten': { ok: false, kind: 'lone_surrogate' }, + 'two-files-decoy-first': { ok: false, kind: 'lone_surrogate' }, +} + +const ERRORS = [ + 'home.import.error_incompatible_version', + 'home.import.error_invalid_pdf', + 'home.import.error_attachment_stripped', + 'home.import.error_no_attachment', + 'home.import.error_lone_surrogate', + 'home.import.error_invalid_copy', + 'home.import.error_generic', + 'home.import.error_core_unavailable', +] as const + +function renderHome() { + return render( + + + } /> + } /> + + , + ) +} + +/** Picks `file` on a fresh Home and returns `editor` or the error line shown. */ +async function outcomeOf(file: File): Promise { + cleanup() + // A fresh tab for every file: the previous import's draft would be a held text. + sessionStorage.clear() + useReportStore.getState().clearTrapped() + useReportStore.setState({ + report: null, + archive: null, + activeObservationIndex: 0, + }) + renderHome() + const button = screen.getByRole('button', { name: fr['home.import.cta'] }) + await waitFor(() => expect(button).toBeEnabled()) + fireEvent.change(document.querySelector('input[type="file"]')!, { + target: { files: [file] }, + }) + const shown = await waitFor( + () => { + if (screen.queryByTestId('editor-route')) return 'editor' + // A message with a placeholder is matched on its text before it. + const error = ERRORS.map((key) => fr[key]!.split('{')[0]!).find((text) => + screen.queryByText(text, { exact: false }), + ) + if (!error) throw new Error(`pending (${file.name})`) + return screen.getByText(error, { exact: false }).textContent ?? error + }, + { timeout: 10_000 }, + ) + return shown +} + +const pdfFile = (path: string, name = path.split('/').pop() ?? 'bilan.pdf') => + new File([readFileSync(path)], name, { type: 'application/pdf' }) + +beforeAll(() => { + useInProcessImportWorker() +}) +beforeEach(() => { + useLocaleStore.setState({ locale: 'fr' }) + sessionStorage.clear() + vi.stubGlobal('alert', vi.fn()) +}) +afterEach(() => { + cleanup() + vi.unstubAllGlobals() +}) + +describe('Home import messages on the frozen corpora (real worker logic, shipped module)', () => { + it('O8: every tolerance case gives the R3 message, outside the declared differences', async () => { + const cases = oracle('tolerance.json').cases as Array<{ + id: string + pdf: string + outcome: { ok: boolean; kind?: string; foundVersion?: number } + }> + expect(cases).toHaveLength(51) + const mismatches: string[] = [] + for (const c of cases) { + const expected = expectedOf(DECLARED[c.id] ?? c.outcome) + const shown = await outcomeOf(pdfFile(join(ROOT, c.pdf))) + if (shown !== expected) + mismatches.push(`${c.id}: expected ${expected}, shown ${shown}`) + } + expect(mismatches).toEqual([]) + }, 120_000) + + it('O7: every stored reader input gives the reader outcome message', async () => { + const inputs = oracle('read.json').inputs as Array<{ + file: string + kind: string + stored: string + outcomes: { + readReportArchive?: { + ok: boolean + kind?: string + foundVersion?: number + } + } + }> + const mismatches: string[] = [] + let count = 0 + for (const input of inputs) { + const expected = input.outcomes.readReportArchive + if (input.kind !== 'pdf' || input.stored !== 'bytes' || !expected) + continue + count += 1 + const shown = await outcomeOf( + pdfFile(join(FIXTURES_DIR, 'pdf/r4/read', input.file)), + ) + if (shown !== expectedOf(expected)) { + mismatches.push( + `${input.file}: expected ${expectedOf(expected)}, shown ${shown}`, + ) + } + } + expect(mismatches).toEqual([]) + expect(count).toBeGreaterThan(130) + }, 180_000) + + it('O2, O3 and the Step 5 fixtures open the editor', async () => { + const files = [ + join(FIXTURES_DIR, 'report-v2.full.pdf'), + join(FIXTURES_DIR, 'report-v2.minimal.pdf'), + join(FIXTURES_DIR, 'report-v3.bare.pdf'), + ...readdirSync(join(FIXTURES_DIR, 'pdf/r3'), { + recursive: true, + encoding: 'utf8', + }) + .filter((n) => n.endsWith('.pdf')) + .map((n) => join(FIXTURES_DIR, 'pdf/r3', n)), + ...readdirSync(join(FIXTURES_DIR, 'pdf/step6')) + .filter((n) => n.endsWith('.pdf')) + .map((n) => join(FIXTURES_DIR, 'pdf/step6', n)), + ] + expect(files.length).toBeGreaterThanOrEqual(20) + for (const file of files) { + expect(await outcomeOf(pdfFile(file)), file).toBe('editor') + expect(useReportStore.getState().report?.version).toBe(3) + } + }, 60_000) + + it('a worker trap or an unreadable file is « Erreur de lecture du PDF. », never a corrupt-PDF message', async () => { + const trapping = useInProcessImportWorker( + throwingEngineLoader(new WebAssembly.RuntimeError('unreachable')), + ) + try { + expect( + await outcomeOf(pdfFile(join(FIXTURES_DIR, 'report-v3.bare.pdf'))), + ).toBe(fr['home.import.error_generic']) + // The worker's trap never touches the page's own runtime (plan §B.3 isolation). + expect(coreRuntime().status).toBe('ready') + } finally { + trapping.restore() + useInProcessImportWorker() + } + const unreadable = pdfFile(join(FIXTURES_DIR, 'report-v3.bare.pdf')) + Object.defineProperty(unreadable, 'stream', { + value: () => ({ + getReader: () => ({ + read: () => + Promise.reject(new DOMException('gone', 'NotReadableError')), + cancel: async () => {}, + }), + }), + }) + expect(await outcomeOf(unreadable)).toBe(fr['home.import.error_generic']) + }) + + it('a worker that cannot start gives the engine message', async () => { + setImportWorkerSpawn(() => { + throw new DOMException('blocked', 'SecurityError') + }) + try { + expect( + await outcomeOf(pdfFile(join(FIXTURES_DIR, 'report-v3.bare.pdf'))), + ).toBe(fr['home.import.error_core_unavailable']) + } finally { + useInProcessImportWorker() + } + }) +}) diff --git a/apps/app/tests/unit/routes.HomeRoute.rescueCopy.test.tsx b/apps/app/tests/unit/routes.HomeRoute.rescueCopy.test.tsx index 652c3c0f..78cab04a 100644 --- a/apps/app/tests/unit/routes.HomeRoute.rescueCopy.test.tsx +++ b/apps/app/tests/unit/routes.HomeRoute.rescueCopy.test.tsx @@ -1,22 +1,45 @@ /** * The rescue copy (`JSON.stringify(report)`, the downloaded format) imported from Home: - * routed by content from the first KiB, read by the core's draft restore, opened as the - * original report; every refusal leaves the store and the tab's slots untouched. + * routed by content from the first KiB, read in the import worker by the core's copy + * restore (strict UTF-8, one BOM dropped; the real worker logic in-process on the shipped + * module, R4.3), opened as the original report; every refusal leaves the store and the + * tab's slots untouched. */ -import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest' -import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react' +import { + afterEach, + beforeAll, + beforeEach, + describe, + expect, + it, + vi, +} from 'vitest' +import { + cleanup, + fireEvent, + render, + screen, + waitFor, +} from '@testing-library/react' import { MemoryRouter, Route, Routes } from 'react-router-dom' import HomeRoute from '@/app/routes/HomeRoute' -import { MAX_ATTACHMENT_BYTES } from '@/pdf/import' +import { MAX_COPY_BYTES } from '@/core/worker/handler' import { DRAFT_KEY, QUARANTINE_KEYS } from '@/state/persistence' import { useReportStore } from '@/state/reportStore' import { useLocaleStore } from '@/state/localeStore' import { fr } from '@/i18n/fr' import type { SheetIndex } from '@/services/sheetIndex' import { buildGoldenReports, GOLDEN_REPORTS } from '../helpers/goldenReports' +import { + answeringEngineLoader, + useInProcessImportWorker, + type FakeWorker, +} from '../helpers/importWorker' import { loadTestSheet, minimalReport } from '../helpers/sheet' let sheet: SheetIndex +let workers: FakeWorker[] +let restoreSpawn: () => void beforeAll(async () => { sheet = await loadTestSheet() @@ -24,11 +47,17 @@ beforeAll(async () => { beforeEach(() => { useLocaleStore.setState({ locale: 'fr' }) sessionStorage.clear() - useReportStore.setState({ report: null, archive: null, activeObservationIndex: 0 }) + useReportStore.setState({ + report: null, + archive: null, + activeObservationIndex: 0, + }) useReportStore.getState().clearTrapped() vi.stubGlobal('alert', vi.fn()) + ;({ workers, restore: restoreSpawn } = useInProcessImportWorker()) }) afterEach(() => { + restoreSpawn() cleanup() vi.unstubAllGlobals() vi.restoreAllMocks() @@ -54,13 +83,16 @@ const copyFile = (text: string, name = 'faunosteo-brouillon.json') => new File([text], name, { type: 'application/json' }) describe('opening a rescue copy', () => { - it.each(GOLDEN_REPORTS)('reopens the %s report equal to the original', async (name) => { - const { reports } = buildGoldenReports(sheet) - await pick(copyFile(JSON.stringify(reports[name]))) - await screen.findByTestId('editor-route') - expect(useReportStore.getState().report).toEqual(reports[name]) - expect(useReportStore.getState().archive).toBeNull() - }) + it.each(GOLDEN_REPORTS)( + 'reopens the %s report equal to the original', + async (name) => { + const { reports } = buildGoldenReports(sheet) + await pick(copyFile(JSON.stringify(reports[name]))) + await screen.findByTestId('editor-route') + expect(useReportStore.getState().report).toEqual(reports[name]) + expect(useReportStore.getState().archive).toBeNull() + }, + ) it('routes by content: no .json name, no type, leading blanks and a BOM', async () => { const report = minimalReport(sheet, { conclusion: 'sniffed' }) @@ -91,7 +123,11 @@ describe('opening a rescue copy', () => { }) it('still sends a PDF down the PDF path', async () => { - await pick(new File(['%PDF-1.7 not really'], 'bilan.pdf', { type: 'application/pdf' })) + await pick( + new File(['%PDF-1.7 not really'], 'bilan.pdf', { + type: 'application/pdf', + }), + ) await screen.findByText(fr['home.import.error_no_attachment']!) expect(screen.queryByText(fr['home.import.error_invalid_copy']!)).toBeNull() }) @@ -104,7 +140,10 @@ describe('refusing a file', () => { ['an unsupported version', () => copyFile(JSON.stringify({ version: 1 }))], [ 'a lone surrogate', - () => copyFile(JSON.stringify(minimalReport(sheet, { conclusion: 'a\ud800b' }))), + () => + copyFile( + JSON.stringify(minimalReport(sheet, { conclusion: 'a\ud800b' })), + ), ], [ 'invalid UTF-8', @@ -121,29 +160,44 @@ describe('refusing a file', () => { expect(screen.queryByTestId('editor-route')).toBeNull() } - it.each(refused)('%s: error line, nothing changed, nothing held', async (_label, make) => { - sessionStorage.setItem(DRAFT_KEY, unreadable) - await pick(make()) - await expectUntouched() - }) + it.each(refused)( + '%s: error line, nothing changed, nothing held', + async (_label, make) => { + sessionStorage.setItem(DRAFT_KEY, unreadable) + await pick(make()) + await expectUntouched() + expect(workers).toHaveLength(1) + }, + ) it('an over-cap file is refused before any full read', async () => { sessionStorage.setItem(DRAFT_KEY, unreadable) const file = copyFile('{"version":3}') - Object.defineProperty(file, 'size', { value: MAX_ATTACHMENT_BYTES + 1 }) + Object.defineProperty(file, 'size', { value: MAX_COPY_BYTES + 1 }) const read = vi.spyOn(file, 'arrayBuffer') + const stream = vi.spyOn(file, 'stream') await pick(file) await expectUntouched() expect(read).not.toHaveBeenCalled() + expect(stream).not.toHaveBeenCalled() + expect(workers).toHaveLength(0) }) it.each(['internal', 'rebase_failed'])( 'the core kind %s takes the engine message path, not the copy message', async (kind) => { - vi.spyOn(sheet.ops, 'restoreDraft').mockReturnValue({ ok: false, kind } as never) + // The worker's core answers the kind (the seam replaced; afterEach restores it). + const refusal = JSON.stringify({ ok: false, kind, detail: '' }) + ;({ workers, restore: restoreSpawn } = useInProcessImportWorker( + answeringEngineLoader(refusal), + )) await pick(copyFile(JSON.stringify(minimalReport(sheet)))) await screen.findByText(fr['home.import.error_core_unavailable']!) - expect(screen.queryByText(fr['home.import.error_invalid_copy']!)).toBeNull() + // The worker answered: the line is the core's kind, not a worker failure. + expect(workers[0]!.posted.map((m) => m.type)).toEqual(['ready', 'result']) + expect( + screen.queryByText(fr['home.import.error_invalid_copy']!), + ).toBeNull() expect(useReportStore.getState().report).toBeNull() }, ) diff --git a/apps/app/tests/unit/routes.coreStopped.test.tsx b/apps/app/tests/unit/routes.coreStopped.test.tsx index b3c8112e..e365a2b2 100644 --- a/apps/app/tests/unit/routes.coreStopped.test.tsx +++ b/apps/app/tests/unit/routes.coreStopped.test.tsx @@ -2,10 +2,30 @@ * The engine stopped for good (three recoveries spent, owner decision 2026-10-15): the * stopped notice on every core page, its two variants (tab copy saved: reload; tab storage * full: download a copy), no retry anywhere, the editor's save banner with its copy button, - * and the stopped alerts (the beforeunload guard has its own hook test). + * and the stopped alerts (the beforeunload guard has its own hook test). The Home import + * refuses up front once the engine stopped (no import worker spawned); while it runs, the + * worker reads the file (in-process, R4.3) and the page's own index failing after it + * accepted gives the engine line. */ -import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest' -import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react' +import { readFileSync } from 'node:fs' +import { resolve } from 'node:path' +import { + afterEach, + beforeAll, + beforeEach, + describe, + expect, + it, + vi, +} from 'vitest' +import { + act, + cleanup, + fireEvent, + render, + screen, + waitFor, +} from '@testing-library/react' import userEvent from '@testing-library/user-event' import { MemoryRouter } from 'react-router-dom' import EditorRoute from '@/app/routes/EditorRoute' @@ -14,23 +34,25 @@ import NewReportRoute from '@/app/routes/NewReportRoute' import CoreUnavailable from '@/components/report/CoreUnavailable' import { coreRuntime } from '@/core/runtime' import { exportReportToPdf } from '@/pdf/export' -import { readAttachment } from '@/pdf/import' import { loadSheetIndex } from '@/sheets/useSheet' import { useReportStore } from '@/state/reportStore' import { useLocaleStore } from '@/state/localeStore' import { fr } from '@/i18n/fr' import type { SheetIndex } from '@/services/sheetIndex' import { controlStopped } from '../helpers/core' +import { FIXTURES_DIR } from '../helpers/goldens' +import { + useInProcessImportWorker, + type FakeWorker, +} from '../helpers/importWorker' import { loadTestSheet, minimalReport } from '../helpers/sheet' vi.mock('@/pdf/export', () => ({ exportReportToPdf: vi.fn() })) -vi.mock('@/pdf/import', async (importOriginal) => ({ - ...(await importOriginal()), - readAttachment: vi.fn(), -})) vi.mock('@/sheets/useSheet', async (importOriginal) => ({ ...(await importOriginal()), - loadSheetIndex: vi.fn((await importOriginal()).loadSheetIndex), + loadSheetIndex: vi.fn( + (await importOriginal()).loadSheetIndex, + ), })) let sheet: SheetIndex @@ -46,8 +68,14 @@ beforeEach(() => { sessionStorage.setItem('osteo:disclaimer-shown', '1') window.scrollTo = vi.fn() as unknown as typeof window.scrollTo vi.stubGlobal('alert', vi.fn()) - useReportStore.setState({ report: null, archive: null, activeObservationIndex: 0 }) - useReportStore.getState().hydrateImport({ report: minimalReport(sheet), archive: null }, sheet) + useReportStore.setState({ + report: null, + archive: null, + activeObservationIndex: 0, + }) + useReportStore + .getState() + .hydrateImport({ report: minimalReport(sheet), archive: null }, sheet) setStopped = controlStopped(coreRuntime(), true) blobs.length = 0 URL.createObjectURL = vi.fn((blob: Blob | MediaSource) => { @@ -55,7 +83,9 @@ beforeEach(() => { return 'blob:faunosteo-test' }) URL.revokeObjectURL = vi.fn() - vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => undefined) + vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation( + () => undefined, + ) }) afterEach(() => { setStopped(false) @@ -74,9 +104,12 @@ function fillStorage() { expect(useReportStore.getState().saveFailed).toBe(true) } -const retryButton = () => screen.queryByRole('button', { name: fr['sheet.core_retry'] }) -const reloadButton = () => screen.queryByRole('button', { name: fr['core.reload'] }) -const copyButton = () => screen.queryByRole('button', { name: fr['session.held.download'] }) +const retryButton = () => + screen.queryByRole('button', { name: fr['sheet.core_retry'] }) +const reloadButton = () => + screen.queryByRole('button', { name: fr['core.reload'] }) +const copyButton = () => + screen.queryByRole('button', { name: fr['session.held.download'] }) function expectSavedVariant() { expect(screen.getByText(fr['core.stopped']!)).toBeInTheDocument() @@ -92,7 +125,9 @@ async function expectUnsavedVariant() { await userEvent.setup().click(copyButton()!) expect(blobs).toHaveLength(1) expect(blobs[0]!.type).toBe('application/json') - expect(await blobs[0]!.text()).toBe(JSON.stringify(useReportStore.getState().report)) + expect(await blobs[0]!.text()).toBe( + JSON.stringify(useReportStore.getState().report), + ) } const inRouter = (node: React.ReactNode) => @@ -164,22 +199,34 @@ describe('EditorRoute', () => { await screen.findByText(fr['editor.save_failed']!) expect(screen.queryByText(fr['core.stopped_unsaved']!)).toBeNull() await userEvent.setup().click(copyButton()!) - expect(await blobs[0]!.text()).toBe(JSON.stringify(useReportStore.getState().report)) + expect(await blobs[0]!.text()).toBe( + JSON.stringify(useReportStore.getState().report), + ) }) it('says the stopped text when the export fails once the engine stopped', async () => { vi.spyOn(console, 'error').mockImplementation(() => undefined) - vi.mocked(exportReportToPdf).mockRejectedValue(new Error('core_unavailable')) + vi.mocked(exportReportToPdf).mockRejectedValue( + new Error('core_unavailable'), + ) mountEditor() - await userEvent.setup().click(await screen.findByRole('button', { name: fr['editor.export']! })) - await waitFor(() => expect(window.alert).toHaveBeenCalledWith(fr['core.stopped'])) + await userEvent + .setup() + .click(await screen.findByRole('button', { name: fr['editor.export']! })) + await waitFor(() => + expect(window.alert).toHaveBeenCalledWith(fr['core.stopped']), + ) }) it('says the unsaved stopped text for an export that fails with a full storage', async () => { vi.spyOn(console, 'error').mockImplementation(() => undefined) - vi.mocked(exportReportToPdf).mockRejectedValue(new Error('core_unavailable')) + vi.mocked(exportReportToPdf).mockRejectedValue( + new Error('core_unavailable'), + ) mountEditor() - const button = await screen.findByRole('button', { name: fr['editor.export']! }) + const button = await screen.findByRole('button', { + name: fr['editor.export']!, + }) fillStorage() await userEvent.setup().click(button) await waitFor(() => @@ -192,7 +239,9 @@ describe('EditorRoute', () => { vi.spyOn(console, 'error').mockImplementation(() => undefined) vi.mocked(exportReportToPdf).mockRejectedValue(new Error('render exploded')) mountEditor() - await userEvent.setup().click(await screen.findByRole('button', { name: fr['editor.export']! })) + await userEvent + .setup() + .click(await screen.findByRole('button', { name: fr['editor.export']! })) await waitFor(() => expect(window.alert).toHaveBeenCalledWith(fr['editor.export_failed']), ) @@ -201,17 +250,25 @@ describe('EditorRoute', () => { describe('the stopped text on the Home import line and the New report alert', () => { const realLoad = vi.mocked(loadSheetIndex).getMockImplementation()! + let workers: FakeWorker[] + let restoreSpawn: () => void beforeEach(() => { + // The page's own index fails: reached only once the worker accepted the file. vi.mocked(loadSheetIndex).mockResolvedValue(null) - vi.mocked(readAttachment).mockResolvedValue({ version: 3 }) + ;({ workers, restore: restoreSpawn } = useInProcessImportWorker()) + }) + afterEach(() => { + restoreSpawn() + vi.mocked(loadSheetIndex).mockImplementation(realLoad) }) - afterEach(() => vi.mocked(loadSheetIndex).mockImplementation(realLoad)) + /** Picks a valid Faunosteo PDF: a refusal is never the file's. */ async function pickPdf() { inRouter() const button = screen.getByRole('button', { name: fr['home.import.cta'] }) await waitFor(() => expect(button).toBeEnabled()) - const file = new File([new Uint8Array([37, 80, 68, 70])], 'bilan.pdf') + const bytes = readFileSync(resolve(FIXTURES_DIR, 'report-v3.bare.pdf')) + const file = new File([bytes], 'bilan.pdf', { type: 'application/pdf' }) fireEvent.change(document.querySelector('input[type="file"]')!, { target: { files: [file] }, }) @@ -220,37 +277,56 @@ describe('the stopped text on the Home import line and the New report alert', () async function submitNewReport() { const user = userEvent.setup() inRouter() - await user.type(screen.getByLabelText(fr['form.practitioner.name']!), 'Dr X') + await user.type( + screen.getByLabelText(fr['form.practitioner.name']!), + 'Dr X', + ) await user.type(screen.getByLabelText(fr['form.animal.name']!), 'Rex') await user.type(screen.getByLabelText(fr['form.owner.name']!), 'Y') - const submit = screen.getByRole('button', { name: fr['new_report.submit']! }) + const submit = screen.getByRole('button', { + name: fr['new_report.submit']!, + }) await waitFor(() => expect(submit).toBeEnabled()) await user.click(submit) // A report is in progress (beforeEach): replacing it is confirmed first. - await user.click(await screen.findByRole('button', { name: fr['session.replace.confirm']! })) + await user.click( + await screen.findByRole('button', { + name: fr['session.replace.confirm']!, + }), + ) } it('Home import: the engine error line says the stopped text', async () => { await pickPdf() await screen.findByText(fr['core.stopped']!, { selector: 'p.text-red-700' }) - expect(screen.queryByText(fr['home.import.error_core_unavailable']!)).toBeNull() + expect( + screen.queryByText(fr['home.import.error_core_unavailable']!), + ).toBeNull() + expect(workers).toHaveLength(0) }) it('Home import: the unsaved stopped text when storage is full', async () => { fillStorage() await pickPdf() - await screen.findByText(fr['core.stopped_unsaved']!, { selector: 'p.text-red-700' }) + await screen.findByText(fr['core.stopped_unsaved']!, { + selector: 'p.text-red-700', + }) + expect(workers).toHaveLength(0) }) it('Home import: keeps the engine error line while the engine is not stopped', async () => { setStopped(false) await pickPdf() await screen.findByText(fr['home.import.error_core_unavailable']!) + // The worker read the file: the line is the page's index failing after it. + expect(workers[0]!.posted.map((m) => m.type)).toEqual(['ready', 'result']) }) it('New report: the alert says the stopped text', async () => { await submitNewReport() - await waitFor(() => expect(window.alert).toHaveBeenCalledWith(fr['core.stopped'])) + await waitFor(() => + expect(window.alert).toHaveBeenCalledWith(fr['core.stopped']), + ) }) it('New report: the unsaved stopped text when storage is full', async () => { diff --git a/apps/app/tests/unit/routes.trappingDraft.test.tsx b/apps/app/tests/unit/routes.trappingDraft.test.tsx index fc97986c..190a5577 100644 --- a/apps/app/tests/unit/routes.trappingDraft.test.tsx +++ b/apps/app/tests/unit/routes.trappingDraft.test.tsx @@ -4,10 +4,26 @@ * while the engine is not stopped; New report and Import answer the engine message then * open the panel; the trapping (draft, archive) pair is read once (one trap across mount, * New report, Import and remount); only the panel's Retry reads it again; a confirmed - * discard removes the draft and clears the memory. + * discard removes the draft and clears the memory. The Import step reads its file in the + * import worker (R4.3, the real worker logic in-process): the trap is the page's own + * `draft.restore` of the tab draft, reached through `hydrateImport`. */ -import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest' -import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react' +import { + afterEach, + beforeAll, + beforeEach, + describe, + expect, + it, + vi, +} from 'vitest' +import { + cleanup, + fireEvent, + render, + screen, + waitFor, +} from '@testing-library/react' import userEvent from '@testing-library/user-event' import { MemoryRouter, Route, Routes } from 'react-router-dom' import EditorRoute from '@/app/routes/EditorRoute' @@ -22,6 +38,7 @@ import { useLocaleStore } from '@/state/localeStore' import { fr } from '@/i18n/fr' import type { SheetIndex } from '@/services/sheetIndex' import { testCoreRuntime, trappingCoreRuntime } from '../helpers/core' +import { useInProcessImportWorker } from '../helpers/importWorker' import { loadTestSheet, minimalReport } from '../helpers/sheet' const MARKER = 'trap-me' @@ -30,6 +47,7 @@ let draft: string let traps: { count: number } let engineStopped: () => boolean let engineReady: () => Promise +let restoreSpawn: () => void beforeAll(async () => { sheet = await loadTestSheet() @@ -42,7 +60,11 @@ beforeEach(async () => { sessionStorage.setItem('osteo:disclaimer-shown', '1') window.scrollTo = vi.fn() as unknown as typeof window.scrollTo vi.stubGlobal('alert', vi.fn()) - useReportStore.setState({ report: null, archive: null, activeObservationIndex: 0 }) + useReportStore.setState({ + report: null, + archive: null, + activeObservationIndex: 0, + }) useReportStore.getState().clearTrapped() const trapping = await trappingCoreRuntime(MARKER) traps = trapping.traps @@ -50,10 +72,12 @@ beforeEach(async () => { engineReady = () => trapping.runtime.ready() setCoreRuntime(trapping.runtime) setSheetProvider(bundledSheetProvider) + restoreSpawn = useInProcessImportWorker().restore // After the reset (an empty store mirrors no draft): the tab as a reload finds it. sessionStorage.setItem(DRAFT_KEY, draft) }) afterEach(async () => { + restoreSpawn() cleanup() vi.unstubAllGlobals() vi.restoreAllMocks() @@ -76,9 +100,10 @@ const routes = (initial: string) => async function expectEnginePanel() { await screen.findByText(fr['session.held.notice_engine']!) expect(screen.getByTestId('held-draft')).toHaveTextContent( - fr['session.held.draft_engine_failure']!.replace('{size}', /\d+ Ko/.exec( - screen.getByTestId('held-draft').textContent ?? '', - )![0]), + fr['session.held.draft_engine_failure']!.replace( + '{size}', + /\d+ Ko/.exec(screen.getByTestId('held-draft').textContent ?? '')![0], + ), ) expect(screen.queryByText(fr['sheet.core_unavailable']!)).toBeNull() expect(sessionStorage.getItem(DRAFT_KEY)).toBe(draft) @@ -100,13 +125,17 @@ async function pickCopy(user: ReturnType) { const pick = screen.getByRole('button', { name: fr['home.import.cta']! }) await waitFor(() => expect(pick).toBeEnabled()) await user.click(pick) - vi.spyOn(HTMLInputElement.prototype, 'click').mockImplementation(() => undefined) + vi.spyOn(HTMLInputElement.prototype, 'click').mockImplementation( + () => undefined, + ) await user.click( await screen.findByRole('button', { name: fr['session.replace.confirm']! }), ) const copy = JSON.stringify(minimalReport(sheet, { id: 'other' })) fireEvent.change(document.querySelector('input[type="file"]')!, { - target: { files: [new File([copy], 'copie.json', { type: 'application/json' })] }, + target: { + files: [new File([copy], 'copie.json', { type: 'application/json' })], + }, }) } @@ -128,7 +157,9 @@ describe('a draft the engine traps on', () => { routes('/new') await submitNewReport(user) await waitFor(() => - expect(window.alert).toHaveBeenCalledWith(fr['session.held_blocked_engine']), + expect(window.alert).toHaveBeenCalledWith( + fr['session.held_blocked_engine'], + ), ) await expectEnginePanel() cleanup() @@ -136,7 +167,9 @@ describe('a draft the engine traps on', () => { routes('/') await pickCopy(user) await waitFor(() => - expect(window.alert).toHaveBeenCalledWith(fr['session.held_blocked_engine']), + expect(window.alert).toHaveBeenCalledWith( + fr['session.held_blocked_engine'], + ), ) await expectEnginePanel() cleanup() @@ -154,7 +187,9 @@ describe('a draft the engine traps on', () => { await expectEnginePanel() // The instance that trapped is replaced in the background: retry on the fresh one. await engineReady() - await user.click(screen.getByRole('button', { name: fr['session.held.retry'] })) + await user.click( + screen.getByRole('button', { name: fr['session.held.retry'] }), + ) await waitFor(() => expect(traps.count).toBe(2)) await expectEnginePanel() }) @@ -163,7 +198,9 @@ describe('a draft the engine traps on', () => { const user = userEvent.setup() routes('/editor') await expectEnginePanel() - await user.click(screen.getByRole('button', { name: fr['session.held.discard'] })) + await user.click( + screen.getByRole('button', { name: fr['session.held.discard'] }), + ) expect(sessionStorage.getItem(DRAFT_KEY)).toBe(draft) await user.click( screen.getByRole('button', { name: fr['session.held.discard_confirm'] }), diff --git a/apps/app/tests/unit/state.coreFailures.test.tsx b/apps/app/tests/unit/state.coreFailures.test.tsx index 009138dd..0e68ba11 100644 --- a/apps/app/tests/unit/state.coreFailures.test.tsx +++ b/apps/app/tests/unit/state.coreFailures.test.tsx @@ -2,8 +2,11 @@ * R2 plan rev 2 (robustness 7): a store action whose core call fails changes * nothing and answers `{ ok: false }`, and the callers stop: the new-report * page does not open the editor, the home page shows the import error instead - * of opening a report. + * of opening a report (R4.3: after the import worker, which loads its own + * module, read the file). */ +import { readFileSync } from 'node:fs' +import { resolve } from 'node:path' import { afterEach, beforeAll, @@ -11,6 +14,7 @@ import { describe, expect, it, + onTestFinished, vi, } from 'vitest' import { @@ -25,7 +29,6 @@ import { MemoryRouter, Route, Routes } from 'react-router-dom' import HomeRoute from '@/app/routes/HomeRoute' import NewReportRoute from '@/app/routes/NewReportRoute' import { setCoreRuntime } from '@/core/runtime' -import { readAttachment } from '@/pdf/import' import { bundledSheetProvider } from '@/sheets/provider' import { setSheetProvider } from '@/sheets/useSheet' import { useReportStore } from '@/state/reportStore' @@ -33,18 +36,14 @@ import { useLocaleStore } from '@/state/localeStore' import { fr } from '@/i18n/fr' import type { SheetIndex } from '@/services/sheetIndex' import { testCoreRuntime, unavailableCoreRuntime } from '../helpers/core' +import { FIXTURES_DIR } from '../helpers/goldens' +import { useInProcessImportWorker } from '../helpers/importWorker' import { emptyObservation, loadTestSheet, minimalReport, } from '../helpers/sheet' -vi.mock('@/pdf/import', async (importOriginal) => ({ - ...(await importOriginal()), - readAttachment: vi.fn(), -})) -const readMock = vi.mocked(readAttachment) - let sheet: SheetIndex beforeAll(async () => { sheet = await loadTestSheet() @@ -152,7 +151,8 @@ describe('callers stop on a failed core call', () => { }) it('the home page shows the import error when the core cannot load', async () => { - readMock.mockResolvedValue({ version: 3 }) + const { workers, restore } = useInProcessImportWorker() + onTestFinished(restore) setCoreRuntime(unavailableCoreRuntime()) setSheetProvider(bundledSheetProvider) render( @@ -165,13 +165,14 @@ describe('callers stop on a failed core call', () => { ) const button = screen.getByRole('button', { name: fr['home.import.cta'] }) await waitFor(() => expect(button).toBeEnabled()) - const file = new File([new Uint8Array([37, 80, 68, 70])], 'bilan.pdf', { - type: 'application/pdf', - }) + const bytes = readFileSync(resolve(FIXTURES_DIR, 'report-v3.bare.pdf')) + const file = new File([bytes], 'bilan.pdf', { type: 'application/pdf' }) fireEvent.change(document.querySelector('input[type="file"]')!, { target: { files: [file] }, }) await screen.findByText(fr['home.import.error_core_unavailable']!) + // The worker read the file; the page's core, needed to open it, did not load. + expect(workers[0]!.posted.map((m) => m.type)).toEqual(['ready', 'result']) expect(screen.queryByTestId('editor-route')).toBeNull() expect(useReportStore.getState().report).toBeNull() }) diff --git a/apps/app/vite.config.ts b/apps/app/vite.config.ts index ad56635f..b473c9f5 100644 --- a/apps/app/vite.config.ts +++ b/apps/app/vite.config.ts @@ -36,4 +36,6 @@ export default defineConfig(({ command }) => ({ emptyOutDir: true, sourcemap: false, }, + // The import worker (R4.3) is a module worker: the core glue it bundles is ESM. + worker: { format: 'es' }, })) diff --git a/packages/core-wasm/src/index.ts b/packages/core-wasm/src/index.ts index 1b62a47f..c4a371b4 100644 --- a/packages/core-wasm/src/index.ts +++ b/packages/core-wasm/src/index.ts @@ -8,8 +8,10 @@ export { CoreRuntime, SheetSession, + closedRefusal, type CoreSource, type CoreStatus, + type GlueFileBytes, type GlueModule, type GlueSheetHandle, } from './runtime' diff --git a/packages/core-wasm/src/outcome.ts b/packages/core-wasm/src/outcome.ts index af3f2510..0a35484c 100644 --- a/packages/core-wasm/src/outcome.ts +++ b/packages/core-wasm/src/outcome.ts @@ -16,7 +16,9 @@ export const CORE_UNAVAILABLE: CoreFailure = { } export function failure(kind: string, detail?: string): CoreFailure { - return detail === undefined ? { ok: false, kind } : { ok: false, kind, detail } + return detail === undefined + ? { ok: false, kind } + : { ok: false, kind, detail } } /** Parses the JSON text a core call returned. */ diff --git a/packages/core-wasm/src/runtime.ts b/packages/core-wasm/src/runtime.ts index fa842b0b..03c42ef3 100644 --- a/packages/core-wasm/src/runtime.ts +++ b/packages/core-wasm/src/runtime.ts @@ -144,6 +144,15 @@ export class CoreRuntime { if (this.restartable) void this.retry() } + /** + * The compiled module of this runtime, when a load has started: posted to the import + * worker (R4.3, structured clone) so an import needs no second fetch, offline included; + * `null` before the first load, the worker then fetches the asset itself. + */ + compiledModule(): Promise | null { + return this.compiled + } + /** Runs a free operation. */ call(op: string, input: string): CoreOutcome { return this.invoke((glue) => parseOutcome(glue.call(op, input))) @@ -246,7 +255,7 @@ export class CoreRuntime { * `JsError` worded `: `), without its `invalid_sheet: ` kind; `null` when the * error is anything else. */ -function closedRefusal(error: unknown): string | null { +export 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