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

package/src/shared/__tests__/read-capped.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import { readCapped } from '../read-capped.js';
+
+describe('readCapped', () => {
+  /**
+   * Counting a chunk against the budget after decoding it lets a provider that
+   * answers in one huge chunk put the whole thing through the decoder — the
+   * bound bypassed by exactly the party it exists to bound. Asserted on the
+   * reader directly because a caller's short snippet is identical either way.
+   */
+  it('holds one oversized chunk to the byte budget, not just the loop', async () => {
+    const oneHugeChunk = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode('x'.repeat(5_000_000)));
+        controller.close();
+      },
+    });
+
+    const out = await readCapped(new Response(oneHugeChunk), 8 * 1024);
+
+    expect(out.length).toBe(8 * 1024);
+  });
+
+  it('stops pulling at the budget and cancels a stream that never ends', async () => {
+    // Without the cap this never returns: the stream has no end.
+    let pulls = 0;
+    let cancelled = false;
+    const endless = new ReadableStream<Uint8Array>({
+      pull(controller) {
+        pulls += 1;
+        controller.enqueue(new TextEncoder().encode('z'.repeat(1024)));
+      },
+      cancel() {
+        cancelled = true;
+      },
+    });
+
+    const out = await readCapped(new Response(endless), 2048);
+
+    expect(out).toBe('z'.repeat(2048));
+    expect(pulls).toBe(2);
+    expect(cancelled).toBe(true);
+  });
+
+  it('returns at once on a body of exactly the budget whose stream stays open', async () => {
+    // Asking for one more byte here would wait on a chunk that never comes.
+    let pulls = 0;
+    const openAfterFill = new ReadableStream<Uint8Array>({
+      pull(controller) {
+        pulls += 1;
+        if (pulls === 1) {
+          controller.enqueue(new TextEncoder().encode('a'.repeat(8)));
+          return undefined;
+        }
+        return new Promise<void>(() => {});
+      },
+    });
+    expect(await readCapped(new Response(openAfterFill), 8)).toBe('a'.repeat(8));
+    expect(pulls).toBe(1);
+  });
+
+  it('reads a stream-less response whole, cut to the budget', async () => {
+    const res = new Response('abcdef');
+    // Consume the stream so only `text()` is left, as a mocked response may be.
+    Object.defineProperty(res, 'body', { value: null });
+    expect(await readCapped(res, 4)).toBe('abcd');
+  });
+});

package/src/shared/oauth-token-error.ts

@@ -0,0 +1,46 @@
+/**
+ * The error codes a token endpoint may answer with, as RFC 6749 §5.2 and OIDC
+ * Core §3.1.2.6 define them. A finite list, on purpose: a code is taken from
+ * a refusing provider's body only when it is exactly one of these, so no other
+ * string a provider puts in that field (a secret, a secret with a suffix, free
+ * text) reaches a message, a verdict or a log.
+ *
+ * Shared, not a module's own: the OIDC configuration check reads a provider's
+ * refusal through it and the secrets vault a token endpoint's, and one list is
+ * the only way the two cannot disagree about which codes are standard. Each
+ * caller keeps its own sentence per code (what a tool owner should do differs
+ * from what a sign-in administrator should do); the set of codes is one.
+ */
+export const OAUTH_TOKEN_ERROR_CODES: readonly string[] = Object.freeze([
+  'invalid_request',
+  'invalid_client',
+  'invalid_grant',
+  'unauthorized_client',
+  'unsupported_grant_type',
+  'invalid_scope',
+  'access_denied',
+  'server_error',
+  'temporarily_unavailable',
+]);
+
+/** Whether `code` is one of the standard token-endpoint error codes, and so safe to echo. */
+export function isStandardTokenErrorCode(code: unknown): code is string {
+  return typeof code === 'string' && OAUTH_TOKEN_ERROR_CODES.includes(code);
+}
+
+/**
+ * The standard `error` code in a refusing token endpoint's JSON body, or null:
+ * when the body is not JSON, not an object, carries no string `error`, or
+ * carries one that is not a standard code.
+ */
+export function standardTokenErrorCode(bodyText: string): string | null {
+  let json: unknown;
+  try {
+    json = JSON.parse(bodyText);
+  } catch {
+    return null;
+  }
+  if (!json || typeof json !== 'object' || Array.isArray(json)) return null;
+  const { error } = json as Record<string, unknown>;
+  return isStandardTokenErrorCode(error) ? error : null;
+}

package/src/shared/path-order.ts

@@ -1,12 +1,25 @@
 /**
- * The ONE ordering of repository paths: component by component, each
- * component by `localeCompare`, a shorter path before its extensions. It is
- * exactly the order a directory walk that sorts each level's entries visits
- * them in — so a consumer that must agree with the walk on "first by path"
- * (plugin discovery keeps the first of two folders sharing a slug; principal
- * synthesis must pick the same one) sorts with this and nothing else. A
- * whole-string `localeCompare` does not agree: it weighs the separator
- * against the next character (`a-b/x` before `a/b/x`), the walk never does.
+ * The TWO orderings of repository paths, and which consumer takes which:
+ *
+ * - {@link comparePathComponents} is the platform's own walk order — component
+ *   by component, each by `localeCompare`, a shorter path before its
+ *   extensions — exactly the order a directory walk that sorts each level's
+ *   entries visits them in. A consumer that must agree with THAT walk on
+ *   "first by path" (plugin discovery keeps the first of two folders sharing a
+ *   slug; principal synthesis must pick the same one) sorts with it and
+ *   nothing else.
+ * - {@link compareSearchPaths} is ripgrep's walk order (`--sort path`):
+ *   component by component, each by its UTF-8 bytes. A `grep` answer is
+ *   assembled from several ripgrep runs and a document pass, and it has to
+ *   sort as ripgrep itself sorts, or the search could not tell which files a
+ *   run has passed. The two orders differ where collation and bytes do
+ *   (`B.md` sorts before `a.md` by bytes, after it by collation), which is why
+ *   a grep answer and the explorer tree can list two siblings the other way
+ *   round. Nothing but the search uses it.
+ *
+ * Both agree on the shape: a whole-string compare does not — it weighs the
+ * separator against the next character (`a-b/x` before `a/b/x`), a walk never
+ * does.
  *
  * TOTAL over distinct paths: two components the collation cannot tell apart
  * (a precomposed `é` and its decomposed spelling) fall through to code-unit
@@ -31,3 +44,19 @@ function compareComponent(a: string, b: string): number {
   if (order !== 0) return order;
   return a < b ? -1 : a > b ? 1 : 0;
 }
+
+/**
+ * The order every `grep` search answers in — ripgrep's: path component by
+ * component, each compared by its UTF-8 bytes, so a folder's files come before
+ * a sibling file whose name extends the folder's. See the note above on how it
+ * differs from {@link comparePathComponents}, and why the search needs it.
+ */
+export function compareSearchPaths(a: string, b: string): number {
+  const as = a.split('/');
+  const bs = b.split('/');
+  for (let i = 0; i < Math.min(as.length, bs.length); i++) {
+    const c = Buffer.compare(Buffer.from(as[i]!, 'utf8'), Buffer.from(bs[i]!, 'utf8'));
+    if (c !== 0) return c;
+  }
+  return as.length - bs.length;
+}

package/src/shared/read-capped.ts

@@ -0,0 +1,40 @@
+/**
+ * At most `limit` bytes of a response body, decoded as text, the rest of the
+ * stream cancelled.
+ *
+ * Each CHUNK is sliced to the remaining budget before being decoded, not just
+ * counted against it: a provider that answers in one 5MB chunk would otherwise
+ * put the whole thing through the decoder before the loop noticed it was over,
+ * which is the bound bypassed by the very party it is meant to bound. Never a
+ * byte past the limit: once the budget is spent the read stops without asking
+ * for more, so a body of exactly `limit` bytes on a stream that stays open
+ * returns at once. And the read never falls back to `res.text()` on a live
+ * stream: a cap applied after that read bounds nothing.
+ *
+ * Shared, not a module's own: the connection probe reads a provider's
+ * rejection with it and the secrets vault a token endpoint's refusal, and one
+ * reader is the only way the two cannot disagree about what "bounded" means.
+ */
+export async function readCapped(res: Response, limit: number): Promise<string> {
+  const reader = res.body?.getReader();
+  // No stream (a mocked or already-consumed response): fall back to the whole
+  // body, which for those cases is ours and small.
+  if (!reader) return (await res.text()).slice(0, limit);
+  const decoder = new TextDecoder();
+  let out = '';
+  let read = 0;
+  try {
+    while (read < limit) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const remaining = limit - read;
+      const chunk = value.byteLength > remaining ? value.subarray(0, remaining) : value;
+      read += chunk.byteLength;
+      out += decoder.decode(chunk, { stream: true });
+      if (chunk.byteLength < value.byteLength) break;
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+  return out;
+}

package/starter-packs/engineering/Plugins/engineering-starter/access.md

@@ -9,7 +9,7 @@ read:
 # manifest. A starter plugin is for the whole team, so everyone may use it
 # and admins change it. To narrow it, replace `everyone` under `read:` with a
 # role from roles.yaml (as `role/<Name>`, so a group of the same name can
-# never stand in for it), a group from groups.yaml, or a person as
+# never stand in for it), a group as `group/<Name>`, or a person as
 # `Name <email>`. Keep this block pure YAML; explanations go in `#` lines.
 read:
   - everyone

package/starter-packs/general/Plugins/general-starter/access.md

@@ -9,7 +9,7 @@ read:
 # manifest. A starter plugin is for the whole team, so everyone may use it
 # and admins change it. To narrow it, replace `everyone` under `read:` with a
 # role from roles.yaml (as `role/<Name>`, so a group of the same name can
-# never stand in for it), a group from groups.yaml, or a person as
+# never stand in for it), a group as `group/<Name>`, or a person as
 # `Name <email>`. Keep this block pure YAML; explanations go in `#` lines.
 read:
   - everyone

package/starter-packs/operations/Plugins/operations-starter/access.md

@@ -9,7 +9,7 @@ read:
 # manifest. A starter plugin is for the whole team, so everyone may use it
 # and admins change it. To narrow it, replace `everyone` under `read:` with a
 # role from roles.yaml (as `role/<Name>`, so a group of the same name can
-# never stand in for it), a group from groups.yaml, or a person as
+# never stand in for it), a group as `group/<Name>`, or a person as
 # `Name <email>`. Keep this block pure YAML; explanations go in `#` lines.
 read:
   - everyone

package/starter-packs/sales/Plugins/sales-starter/access.md

@@ -9,7 +9,7 @@ read:
 # manifest. A starter plugin is for the whole team, so everyone may use it
 # and admins change it. To narrow it, replace `everyone` under `read:` with a
 # role from roles.yaml (as `role/<Name>`, so a group of the same name can
-# never stand in for it), a group from groups.yaml, or a person as
+# never stand in for it), a group as `group/<Name>`, or a person as
 # `Name <email>`. Keep this block pure YAML; explanations go in `#` lines.
 read:
   - everyone

package/starter-packs/support/Plugins/support-starter/access.md

@@ -9,7 +9,7 @@ read:
 # manifest. A starter plugin is for the whole team, so everyone may use it
 # and admins change it. To narrow it, replace `everyone` under `read:` with a
 # role from roles.yaml (as `role/<Name>`, so a group of the same name can
-# never stand in for it), a group from groups.yaml, or a person as
+# never stand in for it), a group as `group/<Name>`, or a person as
 # `Name <email>`. Keep this block pure YAML; explanations go in `#` lines.
 read:
   - everyone

package/agent-guide/finding-things.md

@@ -1,7 +0,0 @@
-## Finding things
-
-- `grep` for keywords across `{{knowledgeBaseDir}}/`.
-- Follow markdown links: when you read `[Some Page](relative/path/Some Page.md)`,
-  that path is relative to the file you are reading.
-- `list_files` to see the shape of a folder before assuming where something
-  lives.

package/agent-guide/introduction.md

@@ -1,27 +0,0 @@
-# Knowledge base
-
-This is a git-backed knowledge base. You are the primary agent responsible for
-maintaining it.
-
-> **This guide is served by the platform.** It is not a file in the
-> repository: `get_agent_guide` returns it, whole or one section at a time,
-> and so does `read_file` on `AGENTS.md` at the repository root — after the
-> knowledge base's own `AGENTS.md`, when it has one; `grep` searches it there
-> too. An `AGENTS.md` you find on disk is the organisation's own conventions
-> file, written by its people; follow it, and never write this text into it.
-> Deployment- or team-specific conventions belong there, or in files of your
-> own anywhere under `{{knowledgeBaseDir}}/`, linked from wherever they are
-> needed.
-
-**Read `mcp-description.md` at the repository root first.** It says what this
-knowledge base contains and when to consult it. Agents connected over MCP
-receive the default branch's copy inline at the start of every session; a
-clone reads the copy on its own branch.
-
-**There is no required format for knowledge.** Write markdown the way the
-subject wants to be written: prose, tables, checklists, diagrams, whatever
-serves the reader. Nothing here parses your files into a schema or rejects a
-document for having the wrong shape. If a deployment layers a structured
-knowledge graph on top, it brings its own conventions, in sections of this
-guide of its own; what follows describes the platform underneath, which stores
-files and controls who may change them.

package/dist/modules/workspace/bounded-matcher.d.ts

@@ -1,73 +0,0 @@
-import { type IPatternMatcher, type IPatternSearch } from './pattern-matcher.contract.js';
-/**
- * The one place a CALLER'S regular expression is run (see
- * {@link IPatternMatcher}).
- *
- * The pattern never runs on the request thread: the lines go to a worker, the
- * worker answers which of them match, and a search whose matching outlives its
- * budget has its worker terminated (which interrupts even a regex
- * mid-backtrack) and is answered with {@link PatternTooExpensiveError}.
- * Nothing partial is returned: a search that blew its budget answers the 400
- * alone.
- *
- * The semantics are the engine's own — the worker compiles the same source with
- * 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 (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. */
-    budgetMs?: number;
-    /** Workers kept for searches at once; a search past this waits for one to free up. Default 4. */
-    poolMax?: number;
-    /**
-     * Searches that may wait for a worker at once. A waiting search holds the
-     * lines it was handed, so the queue is capped: past it a search is refused
-     * with a 503 rather than piling file contents up in memory. Default 16.
-     */
-    maxWaiting?: number;
-    /**
-     * Longest pattern accepted. The pattern is compiled on the request thread
-     * (that is how a syntax error earns its 400 there), so its length is what
-     * bounds that. Default 1000.
-     */
-    maxPatternLength?: number;
-    /**
-     * Characters handed to the worker in one message. Posting a message copies
-     * it on the request thread, so a large file goes over in pieces of about
-     * this size rather than in one copy that would stall every other request.
-     * A single line longer than this is not posted at all: it is written into
-     * shared memory this many characters at a time, yielding between pieces,
-     * and the worker reads it from there. Default 1 MB.
-     */
-    batchChars?: number;
-    /**
-     * Lines handed to the worker in one message. Each line is an entry the
-     * copy has to walk whatever its length, so a file of empty lines is bounded
-     * by this, not by `batchChars`. Default 10,000.
-     */
-    batchLines?: number;
-}
-export declare class WorkerPatternMatcher implements IPatternMatcher {
-    private readonly budgetMs;
-    private readonly maxPatternLength;
-    private readonly batchChars;
-    private readonly batchLines;
-    private readonly pool;
-    private readonly lease;
-    constructor(opts?: WorkerPatternMatcherOptions);
-    search(source: string, flags: string): IPatternSearch;
-    close(): Promise<void>;
-    /**
-     * Where the batch starting at `from` ends: about `batchChars` characters on,
-     * at most `batchLines` lines on, and never empty. A batch of one line past
-     * `batchChars` is handed over through shared memory instead (see
-     * {@link BoundedSearch.matchBatch}).
-     */
-    private batchEnd;
-}
-//# sourceMappingURL=bounded-matcher.d.ts.map

package/dist/modules/workspace/bounded-matcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bounded-matcher.d.ts","sourceRoot":"","sources":["../../../src/modules/workspace/bounded-matcher.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,cAAc,EAGpB,MAAM,+BAA+B,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,2BAA2B;IAC1C,2FAA2F;IAC3F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iGAAiG;IACjG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA4CD,qBAAa,oBAAqB,YAAW,eAAe;IAC1D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;gBAElB,IAAI,GAAE,2BAAgC;IAwBlD,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc;IAgBrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;CAOjB"}

package/dist/modules/workspace/bounded-matcher.js

@@ -1,200 +0,0 @@
-import { Worker } from 'node:worker_threads';
-import { exchange, MAX_TIMER_MS, sizingOption, WorkerPool } from './worker-pool.js';
-import { ToolError } from '../tool-helpers/index.js';
-import { PatternTooExpensiveError, SearchBusyError, } from './pattern-matcher.contract.js';
-/**
- * Slack on top of the remaining budget before a batch is given up on: the
- * budget counts only the worker's own matching time, so handing the lines over
- * and the answer back must not be what trips it.
- */
-const TRANSFER_GRACE_MS = 250;
-/** The worker: compiles the pattern it is handed and answers the indices of the lines it matches. */
-const WORKER_SOURCE = `
-const { parentPort } = require('node:worker_threads');
-const { performance } = require('node:perf_hooks');
-let cached = { key: null, re: null };
-parentPort.on('message', ({ source, flags, lines, shared, limit }) => {
-  try {
-    // One line too long to post, written into shared memory as raw UTF-16 code units.
-    if (shared) lines = [Buffer.from(shared).toString('utf16le')];
-    const key = flags + '/' + source;
-    if (cached.key !== key) cached = { key, re: new RegExp(source, flags) };
-    const re = cached.re;
-    const started = performance.now();
-    const hits = [];
-    for (let i = 0; i < lines.length && hits.length < limit; i++) {
-      re.lastIndex = 0;
-      if (re.test(lines[i])) hits.push(i);
-    }
-    parentPort.postMessage({ hits, elapsed: performance.now() - started });
-  } catch (err) {
-    parentPort.postMessage({ error: String(err && err.message ? err.message : err) });
-  }
-});
-`;
-export class WorkerPatternMatcher {
-    budgetMs;
-    maxPatternLength;
-    batchChars;
-    batchLines;
-    pool;
-    lease;
-    constructor(opts = {}) {
-        this.budgetMs = option('budgetMs', opts.budgetMs ?? 5_000, 1, MAX_TIMER_MS - TRANSFER_GRACE_MS);
-        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.pool.acquire(),
-            release: (w) => this.pool.release(w),
-            discard: (w) => this.pool.discard(w),
-            batchEnd: (lines, from) => this.batchEnd(lines, from),
-            batchChars: this.batchChars,
-        };
-    }
-    search(source, flags) {
-        if (source.length > this.maxPatternLength) {
-            throw new ToolError(`Pattern too long: ${source.length} characters, and a search pattern may have at most ${this.maxPatternLength}.`, 400, { code: 'pattern_too_long' });
-        }
-        try {
-            new RegExp(source, flags);
-        }
-        catch (err) {
-            throw new ToolError(`Invalid regex: ${err.message}`, 400);
-        }
-        return new BoundedSearch(this.lease, source, flags, this.budgetMs);
-    }
-    close() {
-        return this.pool.close();
-    }
-    /**
-     * Where the batch starting at `from` ends: about `batchChars` characters on,
-     * at most `batchLines` lines on, and never empty. A batch of one line past
-     * `batchChars` is handed over through shared memory instead (see
-     * {@link BoundedSearch.matchBatch}).
-     */
-    batchEnd(lines, from) {
-        let to = from;
-        let chars = 0;
-        const last = Math.min(lines.length, from + this.batchLines);
-        while (to < last && (to === from || chars + lines[to].length <= this.batchChars))
-            chars += lines[to++].length;
-        return to;
-    }
-}
-/** One search: a caller's pattern, matched off the event loop under one budget. */
-class BoundedSearch {
-    pool;
-    source;
-    flags;
-    budgetMs;
-    spentMs = 0;
-    constructor(pool, source, flags, budgetMs) {
-        this.pool = pool;
-        this.source = source;
-        this.flags = flags;
-        this.budgetMs = budgetMs;
-    }
-    async matchingLines(lines, limit) {
-        if (limit <= 0 || lines.length === 0)
-            return [];
-        if (this.spentMs >= this.budgetMs)
-            throw new PatternTooExpensiveError(this.source, this.budgetMs);
-        const w = await this.pool.acquire();
-        const hits = [];
-        try {
-            for (let from = 0; from < lines.length && hits.length < limit;) {
-                const to = this.pool.batchEnd(lines, from);
-                for (const i of await this.matchBatch(w, lines.slice(from, to), limit - hits.length))
-                    hits.push(from + i);
-                from = to;
-            }
-        }
-        catch (err) {
-            // Terminating is what stops a regex mid-backtrack; the pool replaces it.
-            this.pool.discard(w);
-            throw err;
-        }
-        this.pool.release(w);
-        return hits;
-    }
-    /**
-     * One handoff to the worker, charged to this search's budget. No handoff
-     * copies more than `batchChars` characters on the request thread at once: a
-     * line longer than that goes over in shared memory, not in the message.
-     */
-    async matchBatch(w, lines, limit) {
-        if (this.spentMs >= this.budgetMs)
-            throw new PatternTooExpensiveError(this.source, this.budgetMs);
-        const oversized = lines.length === 1 && lines[0].length > this.pool.batchChars;
-        const payload = oversized ? { shared: await shareLine(w, lines[0], this.pool.batchChars) } : { lines };
-        const remaining = this.budgetMs - this.spentMs;
-        const reply = await run(w, { source: this.source, flags: this.flags, ...payload, limit }, remaining + TRANSFER_GRACE_MS);
-        if (reply === 'timeout') {
-            this.spentMs = this.budgetMs;
-            throw new PatternTooExpensiveError(this.source, this.budgetMs);
-        }
-        if ('error' in reply)
-            throw new ToolError(`Invalid regex: ${reply.error}`, 400);
-        this.spentMs += reply.elapsed;
-        if (this.spentMs > this.budgetMs)
-            throw new PatternTooExpensiveError(this.source, this.budgetMs);
-        return reply.hits;
-    }
-}
-/**
- * A line as raw UTF-16 code units in shared memory, which a message hands the
- * worker without copying. It is written `chunkChars` at a time with a turn of
- * the event loop between, so a line of any length never holds the request
- * thread for longer than one chunk. Raw code units keep the line exact, lone
- * surrogates included.
- *
- * The worker it is meant for can be terminated by `close()` during those turns,
- * before {@link run} listens for its exit; a message posted to it then would
- * never be answered. So its exit is watched here too: writing stops and the
- * search is answered busy, as one terminated under `run` is.
- */
-async function shareLine(w, line, chunkChars) {
-    let exited = false;
-    const onExit = () => {
-        exited = true;
-    };
-    w.once('exit', onExit);
-    try {
-        const shared = new SharedArrayBuffer(line.length * 2);
-        const bytes = Buffer.from(shared);
-        for (let at = 0; at < line.length && !exited; at += chunkChars) {
-            if (at > 0)
-                await new Promise((resolve) => setImmediate(resolve));
-            bytes.write(line.slice(at, at + chunkChars), at * 2, 'utf16le');
-        }
-        if (exited)
-            throw new SearchBusyError();
-        return shared;
-    }
-    finally {
-        w.off('exit', onExit);
-    }
-}
-async function run(w, message, timeoutMs) {
-    const outcome = await exchange(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();
-}
-/** A sizing option as given, refused at construction unless it is an integer from `min` to `max`. */
-function option(name, value, min, max = Number.MAX_SAFE_INTEGER) {
-    return sizingOption('WorkerPatternMatcher', name, value, min, max);
-}
-//# sourceMappingURL=bounded-matcher.js.map

package/dist/modules/workspace/bounded-matcher.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bounded-matcher.js","sourceRoot":"","sources":["../../../src/modules/workspace/bounded-matcher.ts"],"names":[],"mappings":"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"}