@bevel-software/platform-core-backend 0.32.0 → 0.33.0

package/src/modules/workspace/bounded-matcher.ts

@@ -1,5 +1,6 @@
 import { Worker } from 'node:worker_threads';
-import { ToolError } from '../tool-helpers/tool.contract.js';
+import { exchange, MAX_TIMER_MS, sizingOption, WorkerPool } from './worker-pool.js';
+import { ToolError } from '../tool-helpers/index.js';
 import {
   type IPatternMatcher,
   type IPatternSearch,
@@ -22,8 +23,10 @@ import {
  * the same flags and calls `test` on each line — so a pattern within budget
  * matches exactly the lines it always did.
  *
- * The pool is this instance's own: the composition root builds one per graph
- * and closes it when the graph stops, so no worker outlives what it served.
+ * The pool is this instance's own (its mechanics are the shared
+ * {@link WorkerPool}; the regex worker below is this kind's): the composition
+ * root builds one per graph and closes it when the graph stops, so no worker
+ * outlives what it served.
  */
 export interface WorkerPatternMatcherOptions {
   /** Matching time one search may spend, summed over every file it searches. Default 5 s. */
@@ -96,36 +99,38 @@ type Reply = { hits: number[]; elapsed: number } | { error: string };
 type Lease = {
   acquire(): Promise<Worker>;
   release(w: Worker): void;
+  discard(w: Worker): void;
   batchEnd(lines: string[], from: number): number;
   readonly batchChars: number;
 };
-type Waiter = { resolve: (w: Worker) => void; reject: (err: Error) => void };
 
 export class WorkerPatternMatcher implements IPatternMatcher {
   private readonly budgetMs: number;
-  private readonly poolMax: number;
-  private readonly maxWaiting: number;
   private readonly maxPatternLength: number;
   private readonly batchChars: number;
   private readonly batchLines: number;
-  private readonly idle: Worker[] = [];
-  private readonly all = new Set<Worker>();
-  private readonly waiting: Waiter[] = [];
-  private closed = false;
+  private readonly pool: WorkerPool;
   private readonly lease: Lease;
 
   constructor(opts: WorkerPatternMatcherOptions = {}) {
     this.budgetMs = option('budgetMs', opts.budgetMs ?? 5_000, 1, MAX_TIMER_MS - TRANSFER_GRACE_MS);
-    // A pool of none would leave every search waiting for a worker that never comes.
-    this.poolMax = option('poolMax', opts.poolMax ?? 4, 1);
-    // No queue at all is allowed: every search past the pool is refused busy.
-    this.maxWaiting = option('maxWaiting', opts.maxWaiting ?? 16, 0);
+    this.pool = new WorkerPool(
+      () => new Worker(WORKER_SOURCE, { eval: true }),
+      {
+        // A pool of none would leave every search waiting for a worker that never comes.
+        poolMax: option('poolMax', opts.poolMax ?? 4, 1),
+        // No queue at all is allowed: every search past the pool is refused busy.
+        maxWaiting: option('maxWaiting', opts.maxWaiting ?? 16, 0),
+      },
+      () => new SearchBusyError(),
+    );
     this.maxPatternLength = option('maxPatternLength', opts.maxPatternLength ?? 1_000, 1);
     this.batchChars = option('batchChars', opts.batchChars ?? 1_000_000, 1);
     this.batchLines = option('batchLines', opts.batchLines ?? 10_000, 1);
     this.lease = {
-      acquire: () => this.acquire(),
-      release: (w) => this.release(w),
+      acquire: () => this.pool.acquire(),
+      release: (w) => this.pool.release(w),
+      discard: (w) => this.pool.discard(w),
       batchEnd: (lines, from) => this.batchEnd(lines, from),
       batchChars: this.batchChars,
     };
@@ -147,12 +152,8 @@ export class WorkerPatternMatcher implements IPatternMatcher {
     return new BoundedSearch(this.lease, source, flags, this.budgetMs);
   }
 
-  async close(): Promise<void> {
-    this.closed = true;
-    for (const waiter of this.waiting.splice(0)) waiter.reject(new SearchBusyError());
-    const workers = [...this.all];
-    this.idle.length = 0;
-    await Promise.all(workers.map((w) => w.terminate()));
+  close(): Promise<void> {
+    return this.pool.close();
   }
 
   /**
@@ -168,43 +169,6 @@ export class WorkerPatternMatcher implements IPatternMatcher {
     while (to < last && (to === from || chars + lines[to]!.length <= this.batchChars)) chars += lines[to++]!.length;
     return to;
   }
-
-  private async acquire(): Promise<Worker> {
-    if (this.closed) throw new SearchBusyError();
-    if (this.idle.length === 0 && this.all.size >= this.poolMax && this.waiting.length >= this.maxWaiting) {
-      throw new SearchBusyError();
-    }
-    const w =
-      this.idle.pop() ??
-      (this.all.size < this.poolMax
-        ? this.spawn()
-        : await new Promise<Worker>((resolve, reject) => this.waiting.push({ resolve, reject })));
-    w.ref();
-    return w;
-  }
-
-  private release(w: Worker): void {
-    const next = this.waiting.shift();
-    if (next) return next.resolve(w);
-    // An idle worker must not hold a process's exit open.
-    w.unref();
-    this.idle.push(w);
-  }
-
-  private spawn(): Worker {
-    const w = new Worker(WORKER_SOURCE, { eval: true });
-    this.all.add(w);
-    // A worker that dies — terminated over budget, or out of memory — leaves the pool.
-    w.once('exit', () => {
-      this.all.delete(w);
-      const at = this.idle.indexOf(w);
-      if (at >= 0) this.idle.splice(at, 1);
-      if (this.closed) return;
-      const next = this.waiting.shift();
-      if (next) next.resolve(this.spawn());
-    });
-    return w;
-  }
 }
 
 /** One search: a caller's pattern, matched off the event loop under one budget. */
@@ -231,7 +195,7 @@ class BoundedSearch implements IPatternSearch {
       }
     } catch (err) {
       // Terminating is what stops a regex mid-backtrack; the pool replaces it.
-      void w.terminate();
+      this.pool.discard(w);
       throw err;
     }
     this.pool.release(w);
@@ -292,37 +256,16 @@ async function shareLine(w: Worker, line: string, chunkChars: number): Promise<S
   }
 }
 
-function run(w: Worker, message: object, timeoutMs: number): Promise<Reply | 'timeout'> {
-  return new Promise((resolve, reject) => {
-    const settle = (fn: () => void) => {
-      clearTimeout(timer);
-      w.off('message', onMessage);
-      w.off('error', onError);
-      w.off('exit', onExit);
-      fn();
-    };
-    const onMessage = (reply: Reply) => settle(() => resolve(reply));
-    const onError = (err: Error) => settle(() => reject(err));
-    // Terminated under the search by `close()`: answered as busy, not left hanging until the timer.
-    const onExit = () => settle(() => reject(new SearchBusyError()));
-    const timer = setTimeout(() => settle(() => resolve('timeout')), timeoutMs);
-    w.on('message', onMessage);
-    w.on('error', onError);
-    w.on('exit', onExit);
-    w.postMessage(message);
-  });
+async function run(w: Worker, message: object, timeoutMs: number): Promise<Reply | 'timeout'> {
+  const outcome = await exchange<Reply>(w, message, timeoutMs);
+  if ('reply' in outcome) return outcome.reply;
+  if ('timeout' in outcome) return 'timeout';
+  if ('error' in outcome) throw outcome.error;
+  // Terminated under the search by `close()`: answered as busy, not left hanging until the timer.
+  throw new SearchBusyError();
 }
 
-/**
- * The longest delay `setTimeout` honours. A longer one fires after 1 ms, so a
- * budget past this (less the grace added to it) would stop every search at once.
- */
-const MAX_TIMER_MS = 2_147_483_647;
-
 /** A sizing option as given, refused at construction unless it is an integer from `min` to `max`. */
 function option(name: string, value: number, min: number, max = Number.MAX_SAFE_INTEGER): number {
-  if (!Number.isInteger(value) || value < min || value > max) {
-    throw new RangeError(`WorkerPatternMatcher: ${name} must be an integer from ${min} to ${max}, got ${value}.`);
-  }
-  return value;
+  return sizingOption('WorkerPatternMatcher', name, value, min, max);
 }

package/src/modules/workspace/file-readers/README.md

@@ -8,6 +8,15 @@ under an `[extracted text of …]` marker whose summary states what was left out
 When an extractor's OUTPUT changes, bump `EXTRACTION_SCHEMA` in
 `doc-extract.service.ts` so cached extractions of unchanged bytes refresh.
 
+No extractor runs on the server's request thread: `DocExtractService` hands the
+bytes to `WorkerDocumentExtractor` (`extract-in-worker.ts`), a pool of worker
+threads running `extract.worker.ts` (the table in `document-extractors.ts`)
+under a 10-second budget per file. A failed extraction is cached under the same
+key — a parser's refusal for good, a timeout or crash for an hour — and a fresh
+failure is reported as the `document-unreadable` event. A new format is added
+to `document-formats.ts` and to the worker's table; the compiler holds the two
+together.
+
 ## Word (`.docx`)
 
 - Paragraphs become lines; table rows become lines of tab-separated cells.

package/src/modules/workspace/file-readers/__tests__/doc-extract.service.test.ts

@@ -0,0 +1,165 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { DocExtractService, TIMEOUT_MEMORY_MS, type UnreadableDocument } from '../doc-extract.service.js';
+import type { IDocumentExtractor, IsolatedExtraction } from '../document-extractor.contract.js';
+import { WorkerDocumentExtractor } from '../extract-in-worker.js';
+import { xrefPdf } from './fixtures/damaged-pdf.js';
+
+/**
+ * What `DocExtractService` remembers about a failed extraction, and whom it
+ * tells: a parser's refusal for good, a timeout or crash for an hour, "busy"
+ * not at all; a fresh failure reported once, a remembered one never.
+ */
+
+/** An extractor that answers what each test scripts, and counts the extractions it was asked for. */
+function scriptedExtractor(answer: (extension: string, bytes: Buffer) => IsolatedExtraction): IDocumentExtractor & { calls: number } {
+  return {
+    calls: 0,
+    async extract(extension, bytes) {
+      this.calls++;
+      return answer(extension, bytes);
+    },
+    close: async () => {},
+  };
+}
+
+const TIMEOUT: IsolatedExtraction = {
+  ok: false,
+  failure: 'timeout',
+  message: 'could not be read: extracting its text took longer than 10 seconds',
+};
+const ORIGIN = { workspaceId: 'main' };
+
+let cacheRoot = '';
+let clock = 0;
+let told: UnreadableDocument[] = [];
+const now = () => clock;
+const onUnreadable = (doc: UnreadableDocument) => told.push(doc);
+
+beforeEach(async () => {
+  cacheRoot = await mkdtemp(join(tmpdir(), 'doc-extract-service-'));
+  clock = 1_800_000_000_000;
+  told = [];
+});
+afterEach(() => rm(cacheRoot, { recursive: true, force: true }));
+
+describe('DocExtractService — a damaged PDF, through the real worker', () => {
+  let extractor: WorkerDocumentExtractor;
+  beforeEach(() => {
+    extractor = new WorkerDocumentExtractor();
+  });
+  afterEach(() => extractor.close());
+
+  it('is extracted once; every later read and the cheap lookup answer the remembered notice', async () => {
+    let extractions = 0;
+    const counting: IDocumentExtractor = {
+      extract: (ext, bytes) => {
+        extractions++;
+        return extractor.extract(ext, bytes);
+      },
+      close: () => extractor.close(),
+    };
+    const service = new DocExtractService(cacheRoot, counting, { now, onUnreadable });
+    const pdf = xrefPdf('Hello', { damage: true });
+    const first = await service.extract('kb/Supplier-Agreement.pdf', pdf, ORIGIN);
+    expect(first).toEqual({ ok: false, message: "could not extract the PDF's text (Bad (uncompressed) XRef entry: 4R)" });
+    expect(await service.extract('kb/Supplier-Agreement.pdf', pdf, ORIGIN)).toEqual(first);
+    expect(await service.getCached('kb/Supplier-Agreement.pdf', pdf)).toEqual(first);
+    expect(extractions).toBe(1);
+    // Told once, for the fresh failure only — under the reason the explorer shows.
+    expect(told).toEqual([
+      { workspaceId: 'main', path: 'kb/Supplier-Agreement.pdf', reason: "could not extract the PDF's text (Bad (uncompressed) XRef entry: 4R)" },
+    ]);
+  });
+
+  it('extracts the repaired file — new content — and reads it normally', async () => {
+    const service = new DocExtractService(cacheRoot, extractor, { now, onUnreadable });
+    await service.extract('a.pdf', xrefPdf('Hello', { damage: true }), ORIGIN);
+    const repaired = await service.extract('a.pdf', xrefPdf('Hello', { damage: false }), ORIGIN);
+    expect(repaired).toMatchObject({ ok: true, text: '[page 1]\nHello' });
+  });
+});
+
+describe('DocExtractService — how long a failure is remembered', () => {
+  it('remembers a parser failure for good — even long past an hour', async () => {
+    const extractor = scriptedExtractor(() => ({ ok: false, failure: 'parser', message: 'could not be parsed as a PDF (x)' }));
+    const service = new DocExtractService(cacheRoot, extractor, { now });
+    const bytes = Buffer.from('damaged');
+    await service.extract('a.pdf', bytes);
+    clock += 30 * TIMEOUT_MEMORY_MS;
+    expect(await service.extract('a.pdf', bytes)).toEqual({ ok: false, message: 'could not be parsed as a PDF (x)' });
+    expect(extractor.calls).toBe(1);
+  });
+
+  it('remembers a timeout for one hour, then extracts again', async () => {
+    let answer: IsolatedExtraction = TIMEOUT;
+    const extractor = scriptedExtractor(() => answer);
+    const service = new DocExtractService(cacheRoot, extractor, { now, onUnreadable });
+    const bytes = Buffer.from('slow');
+    expect(await service.extract('big.pdf', bytes, ORIGIN)).toEqual({ ok: false, message: TIMEOUT.message });
+    // Within the hour: the notice, at once, from every read and from the cheap lookup.
+    clock += TIMEOUT_MEMORY_MS - 1;
+    expect(await service.extract('big.pdf', bytes, ORIGIN)).toEqual({ ok: false, message: TIMEOUT.message });
+    expect(await service.getCached('big.pdf', bytes)).toEqual({ ok: false, message: TIMEOUT.message });
+    expect(extractor.calls).toBe(1);
+    // After it: tried again, and this time the server had the moment to spare.
+    clock += 1;
+    expect(await service.getCached('big.pdf', bytes)).toBeUndefined();
+    answer = { ok: true, summary: '1 page', text: '[page 1]\nfinally' };
+    expect(await service.extract('big.pdf', bytes, ORIGIN)).toMatchObject({ ok: true, text: '[page 1]\nfinally' });
+    expect(extractor.calls).toBe(2);
+    expect(told).toEqual([{ workspaceId: 'main', path: 'big.pdf', reason: 'extracting its text took longer than 10 seconds' }]);
+  });
+
+  it('remembers a crashed extraction for an hour, like a timeout', async () => {
+    const extractor = scriptedExtractor(() => ({ ok: false, failure: 'crashed', message: 'could not be read: its extraction stopped unexpectedly (exit code 3)' }));
+    const service = new DocExtractService(cacheRoot, extractor, { now });
+    const bytes = Buffer.from('oom');
+    await service.extract('a.pdf', bytes);
+    await service.extract('a.pdf', bytes);
+    expect(extractor.calls).toBe(1);
+    clock += TIMEOUT_MEMORY_MS;
+    await service.extract('a.pdf', bytes);
+    expect(extractor.calls).toBe(2);
+  });
+
+  it('remembers nothing, and tells no one, when no worker was free', async () => {
+    const extractor = scriptedExtractor(() => ({ ok: false, failure: 'busy', message: 'could not be read: too many documents are being extracted at once; try again in a few seconds' }));
+    const service = new DocExtractService(cacheRoot, extractor, { now, onUnreadable });
+    const bytes = Buffer.from('fine');
+    expect((await service.extract('a.pdf', bytes, ORIGIN)).ok).toBe(false);
+    expect(await service.getCached('a.pdf', bytes)).toBeUndefined();
+    await service.extract('a.pdf', bytes, ORIGIN);
+    expect(extractor.calls).toBe(2);
+    expect(told).toEqual([]);
+  });
+
+  it('tells no one about a failure of a read with no origin', async () => {
+    const extractor = scriptedExtractor(() => TIMEOUT);
+    const service = new DocExtractService(cacheRoot, extractor, { now, onUnreadable });
+    await service.extract('a.pdf', Buffer.from('x'));
+    expect(told).toEqual([]);
+  });
+
+  it('tells once when two reads of the same document fail together', async () => {
+    const extractor = scriptedExtractor(() => TIMEOUT);
+    const service = new DocExtractService(cacheRoot, extractor, { now, onUnreadable });
+    const bytes = Buffer.from('twice');
+    await Promise.all([service.extract('a.pdf', bytes, ORIGIN), service.extract('a.pdf', bytes, ORIGIN)]);
+    expect(extractor.calls).toBe(1);
+    expect(told).toHaveLength(1);
+  });
+
+  it('still answers the read when whoever is told throws', async () => {
+    const extractor = scriptedExtractor(() => TIMEOUT);
+    const service = new DocExtractService(cacheRoot, extractor, {
+      now,
+      onUnreadable: () => {
+        throw new Error('listener broke');
+      },
+    });
+    expect(await service.extract('a.pdf', Buffer.from('x'), ORIGIN)).toEqual({ ok: false, message: TIMEOUT.message });
+  });
+});

package/src/modules/workspace/file-readers/__tests__/doc-extract.test.ts

@@ -7,18 +7,18 @@ import AdmZip from 'adm-zip';
 import * as XLSX from 'xlsx';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { extractDocx } from '../extract-docx.js';
-import { extractPptx } from '../extract-pptx.js';
+import { extractPptx, notesTargetFromRels } from '../extract-pptx.js';
 import { extractXlsx } from '../extract-xlsx.js';
 import { extractPdf } from '../extract-pdf.js';
 import { extractOdt } from '../extract-odt.js';
 import { extractOdp } from '../extract-odp.js';
 import { extractOds } from '../extract-ods.js';
 import { DocExtractService, EXTRACTION_SCHEMA } from '../doc-extract.service.js';
+import { WorkerDocumentExtractor } from '../extract-in-worker.js';
 import { DocExtractionCache, gitBlobSha } from '../extraction-cache.js';
 import { fileExtension } from '../doc-extract.types.js';
 import { MAX_ODF_NS_ALIASES, normalizeOdfPrefixes, odfParagraphBlocks } from '../odf-text.js';
 import { decodeXmlEntities, xmlAttrValue, xmlAttrValueByLocalName } from '../ooxml-text.js';
-import { notesTargetFromRels } from '../extract-pptx.js';
 
 /**
  * REAL fixtures, no mocks: docx/pptx are handcrafted OOXML zips built with
@@ -612,7 +612,7 @@ describe('DocExtractService cache', () => {
 
   beforeEach(async () => {
     cacheRoot = await mkdtemp(join(tmpdir(), 'doc-extract-cache-'));
-    service = new DocExtractService(cacheRoot);
+    service = new DocExtractService(cacheRoot, new WorkerDocumentExtractor());
   });
   afterEach(async () => {
     await rm(cacheRoot, { recursive: true, force: true });
@@ -620,7 +620,7 @@ describe('DocExtractService cache', () => {
 
   it('extracts ONCE per content: the second read is served from the cache file', async () => {
     const bytes = docxBytes(para('Cache me once'));
-    const first = await service.extract('a.docx', bytes, extractDocx);
+    const first = await service.extract('a.docx', bytes);
     expect(first.ok).toBe(true);
     const entries = await readdir(cacheRoot);
     expect(entries).toEqual([`${gitBlobSha(bytes)}.docx.${EXTRACTION_SCHEMA}.json`]);
@@ -629,7 +629,7 @@ describe('DocExtractService cache', () => {
     // text, it came from the cache — the parser did NOT run again. (Real-files
     // proof without spying on module internals.)
     await writeFile(join(cacheRoot, entries[0]), JSON.stringify({ summary: 'tampered summary', text: 'FROM CACHE' }), 'utf8');
-    const second = await service.extract('a.docx', bytes, extractDocx);
+    const second = await service.extract('a.docx', bytes);
     if (!second.ok) throw new Error(second.message);
     expect(second.text).toBe('FROM CACHE');
     expect(second.marker).toBe('[extracted text of a.docx — tampered summary]');
@@ -638,9 +638,9 @@ describe('DocExtractService cache', () => {
   it('is invalidated by CONTENT change (new blob sha → fresh extraction, new entry)', async () => {
     const v1 = docxBytes(para('version one'));
     const v2 = docxBytes(para('version two'));
-    await service.extract('a.docx', v1, extractDocx);
+    await service.extract('a.docx', v1);
     const after1 = await readdir(cacheRoot);
-    const res = await service.extract('a.docx', v2, extractDocx);
+    const res = await service.extract('a.docx', v2);
     if (!res.ok) throw new Error(res.message);
     expect(res.text).toBe('version two');
     const after2 = await readdir(cacheRoot);
@@ -650,9 +650,9 @@ describe('DocExtractService cache', () => {
 
   it('keys by content, not path: the same bytes under another path reuse the entry, marker names the read path', async () => {
     const bytes = docxBytes(para('Shared content'));
-    await service.extract('one.docx', bytes, extractDocx);
+    await service.extract('one.docx', bytes);
     expect(await readdir(cacheRoot)).toHaveLength(1);
-    const other = await service.extract('two/other.docx', bytes, extractDocx);
+    const other = await service.extract('two/other.docx', bytes);
     if (!other.ok) throw new Error(other.message);
     expect(other.marker).toMatch(/^\[extracted text of two\/other\.docx — /);
     expect(await readdir(cacheRoot)).toHaveLength(1);
@@ -661,15 +661,20 @@ describe('DocExtractService cache', () => {
   it('getCached misses before extraction and hits after — the grep budget contract', async () => {
     const bytes = docxBytes(para('Budget line'));
     expect(await service.getCached('a.docx', bytes)).toBeUndefined();
-    await service.extract('a.docx', bytes, extractDocx);
+    await service.extract('a.docx', bytes);
     const hit = await service.getCached('a.docx', bytes);
     expect(hit?.text).toBe('Budget line');
   });
 
-  it('does NOT cache failures — a corrupt file is re-tried on the next read', async () => {
-    const res = await service.extract('bad.docx', Buffer.from('junk'), extractDocx);
+  it('remembers a parser failure under the content key — a corrupt file is answered from the cache', async () => {
+    // Reversed on purpose (Damaged-Document-Never-Hangs): a damaged file was
+    // extracted again on every read and every grep; now its failure is kept
+    // like a success, and the cheap lookup answers it too.
+    const junk = Buffer.from('junk');
+    const res = await service.extract('bad.docx', junk);
     expect(res.ok).toBe(false);
-    expect(await readdir(cacheRoot)).toHaveLength(0);
+    expect(await readdir(cacheRoot)).toEqual([`${gitBlobSha(junk)}.docx.${EXTRACTION_SCHEMA}.json`]);
+    expect(await service.getCached('bad.docx', junk)).toEqual(res);
   });
 
   it('computes the git blob sha (matches `git hash-object`)', async () => {
@@ -679,7 +684,7 @@ describe('DocExtractService cache', () => {
 
   it('the cached entry on disk is the {summary, text} JSON', async () => {
     const bytes = docxBytes(para('On disk'));
-    await service.extract('a.docx', bytes, extractDocx);
+    await service.extract('a.docx', bytes);
     const raw = JSON.parse(await readFile(join(cacheRoot, `${gitBlobSha(bytes)}.docx.${EXTRACTION_SCHEMA}.json`), 'utf8')) as { summary: string; text: string };
     expect(raw.text).toBe('On disk');
     expect(typeof raw.summary).toBe('string');
@@ -694,12 +699,12 @@ describe('DocExtractService cache', () => {
         `${odsCell('cell')}` +
         '</table:table-row></table:table></office:text>',
     );
-    const asOdt = await service.extract('doc.odt', bytes, extractOdt);
+    const asOdt = await service.extract('doc.odt', bytes);
     if (!asOdt.ok) throw new Error(asOdt.message);
     expect(asOdt.text).toContain('Prose line');
 
     // Same bytes, renamed .ods: the odt extraction must NOT come back.
-    const asOds = await service.extract('doc.ods', bytes, extractOds);
+    const asOds = await service.extract('doc.ods', bytes);
     if (!asOds.ok) throw new Error(asOds.message);
     expect(asOds.text.split('\n')[0]).toBe('[sheet: Grid]');
     expect(asOds.marker).toContain('sheet');