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

package/src/modules/workspace/write-denial.ts

@@ -1,10 +1,9 @@
 import { branchAuthorLocalpart, suggestionsBranchPrefixFor } from '@bevel-software/platform-shared';
 import type { KbContext } from '../../shared/kb-context.js';
-import { ToolError } from '../tool-helpers/tool.contract.js';
-import { AccessDeniedError } from '../access-model/access-errors.js';
-import type { IChangeReadGate } from '../access-model/change-gate.js';
-import { toKbRelative } from '../access-model/kb-read-filter.js';
-import type { IAccessControl } from '../access/access-control.interface.js';
+import { ToolError } from '../tool-helpers/index.js';
+import { AccessDeniedError, toKbRelative } from '../access-model/index.js';
+import type { IChangeReadGate } from '../access-model/index.js';
+import type { IAccessControl } from '../access/index.js';
 import { workspaceIdForBranch } from '../../shared/workspace-id.js';
 
 /** One step of the proposal route, named by the tool the agent calls. */

package/src/modules/write-access/index.ts

@@ -0,0 +1,7 @@
+/**
+ * What the write-access module offers the other modules. A consumer outside the
+ * module imports from here, never from the files: they are the module's own
+ * layout and free to move. Export what another module needs; nothing more.
+ */
+export { READ_ONLY_CODE, alwaysWritable, refuseWriteTool } from './write-access.js';
+export type { IWriteAccess } from './write-access.js';

package/src/shared/__tests__/module-boundaries.lint.test.ts

@@ -0,0 +1,301 @@
+import { describe, it, expect } from 'vitest';
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname, relative, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { ESLint } from 'eslint';
+
+/**
+ * Module boundaries are linted.
+ *
+ * The Module Map says a module under `src/modules/` is reached through its
+ * `index.ts`; the repo's `eslint.config.js` enforces that with
+ * `no-restricted-imports` patterns built by `eslint.module-boundaries.js`,
+ * for this package and for core-frontend. CI lints only the files a change
+ * touches, so this suite runs the same rule from the same config over every
+ * module file, and holds the exception list to what it says it is: the
+ * backlog, every entry of which still needs to be there.
+ */
+
+const SRC = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const REPO_ROOT = resolve(SRC, '..', '..', '..');
+const BACKEND = join(REPO_ROOT, 'packages', 'core-backend', 'src');
+const FRONTEND = join(REPO_ROOT, 'packages', 'core-frontend', 'src');
+const RULE = 'no-restricted-imports';
+const BOUNDARY = 'Modular Domain-Driven Design: reach another module through its index';
+/** Every message the rule gives starts so: the boundary itself, and the normal-form guard on it. */
+const RULE_NAME = 'Modular Domain-Driven Design:';
+
+/** One instance for the suite: loading the flat config and the parser is the slow part. */
+let instance: ESLint | null = null;
+function eslint(): ESLint {
+  instance ??= new ESLint({ cwd: REPO_ROOT, ruleFilter: ({ ruleId }) => ruleId === RULE });
+  return instance;
+}
+
+/** Lint `code` as the file at `path` (relative to the repo root), with the repo's config. */
+async function lintAs(path: string, code: string): Promise<string[]> {
+  const [result] = await eslint().lintText(code, { filePath: join(REPO_ROOT, path) });
+  return result.messages.map((m) => m.message);
+}
+
+const boundaryHits = (messages: string[]) => messages.filter((m) => m.includes(BOUNDARY));
+
+function moduleSources(dir: string, out: string[] = []): string[] {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      if (entry !== '__tests__') moduleSources(full, out);
+    } else if (/\.tsx?$/.test(entry) && !/\.test\.tsx?$/.test(entry)) out.push(full);
+  }
+  return out;
+}
+
+async function boundaryModule() {
+  // A plain-JS module at the repo root, outside this package's types.
+  const url = pathToFileURL(join(REPO_ROOT, 'eslint.module-boundaries.js')).href;
+  return (await import(url)) as {
+    moduleBoundaries: (o: { root: string; exceptions?: Record<string, string> }) => unknown[];
+    MODULE_BOUNDARY_EXCEPTIONS: Record<string, string>;
+  };
+}
+
+const BE = 'packages/core-backend/src';
+const FE = 'packages/core-frontend/src';
+
+describe('lint: module boundaries', () => {
+  it("rejects a backend import of another module's internals, naming the index to use", async () => {
+    const messages = await lintAs(
+      `${BE}/modules/mcp/__lint_fixture__.ts`,
+      "import { recordRequest } from '../audit/request-audit.js';\nexport const a = recordRequest;\n",
+    );
+    expect(boundaryHits(messages)).toHaveLength(1);
+    expect(messages[0]).toContain('modules/audit/index.ts');
+    // The first lint of the suite pays for loading the config and the parser.
+  }, 60_000);
+
+  it("allows the other module's index, with or without the extension", async () => {
+    for (const spec of ['../audit/index.js', '../audit/index.ts', '../audit/index']) {
+      expect(await lintAs(`${BE}/modules/mcp/__lint_fixture__.ts`, `import { a } from '${spec}';\nexport { a };\n`)).toEqual(
+        [],
+      );
+    }
+  });
+
+  it('allows imports inside one module, at any depth', async () => {
+    expect(
+      await lintAs(
+        `${BE}/modules/workspace/__lint_fixture__.ts`,
+        "import { a } from './file-readers/doc-extract.service.js';\nexport { a };\n",
+      ),
+    ).toEqual([]);
+    expect(
+      await lintAs(`${BE}/modules/mcp/oauth/__lint_fixture__.ts`, "import { a } from '../mcp.routes.js';\nexport { a };\n"),
+    ).toEqual([]);
+    expect(
+      await lintAs(
+        `${BE}/modules/mcp/oauth/__lint_fixture__.ts`,
+        "import { a } from '../../mcp/mcp.routes.js';\nexport { a };\n",
+      ),
+    ).toEqual([]);
+  });
+
+  it('measures the way out of the module from the importing file\'s own folder', async () => {
+    // From a sub-folder, one `../` stays inside the module…
+    expect(
+      await lintAs(`${BE}/modules/mcp/oauth/__lint_fixture__.ts`, "import { a } from '../audit/x.js';\nexport { a };\n"),
+    ).toEqual([]);
+    // …and two lead into another one.
+    const nested = await lintAs(
+      `${BE}/modules/mcp/oauth/__lint_fixture__.ts`,
+      "import { a } from '../../audit/request-audit.js';\nexport { a };\n",
+    );
+    expect(boundaryHits(nested)).toHaveLength(1);
+    // Through `modules/` from above is the same reach.
+    const viaModules = await lintAs(
+      `${BE}/modules/mcp/__lint_fixture__.ts`,
+      "import { a } from '../../modules/audit/request-audit.js';\nexport { a };\n",
+    );
+    expect(boundaryHits(viaModules)).toHaveLength(1);
+  });
+
+  it('sees type-only imports and re-exports too', async () => {
+    const typeOnly = await lintAs(
+      `${BE}/modules/mcp/__lint_fixture__.ts`,
+      "import type { A } from '../audit/audit.contract.js';\nexport type B = A;\n",
+    );
+    expect(boundaryHits(typeOnly)).toHaveLength(1);
+    const reExport = await lintAs(`${BE}/modules/mcp/__lint_fixture__.ts`, "export { a } from '../audit/request-audit.js';\n");
+    expect(boundaryHits(reExport)).toHaveLength(1);
+  });
+
+  it('refuses a relative path not in normal form, so no spelling slips past the count', async () => {
+    const specs = [
+      './../audit/request-audit.js',
+      '../mcp/../audit/request-audit.js',
+      '../audit/./request-audit.js',
+      '..//audit/request-audit.js',
+    ];
+    for (const spec of specs) {
+      const messages = await lintAs(`${BE}/modules/mcp/__lint_fixture__.ts`, `import { a } from '${spec}';\nexport { a };\n`);
+      expect(
+        messages.filter((m) => m.includes('normal form')),
+        spec,
+      ).toHaveLength(1);
+    }
+    // A longer way round through `modules/` is still the same reach.
+    const around = await lintAs(
+      `${BE}/modules/mcp/__lint_fixture__.ts`,
+      "import { a } from '../../../../packages/core-backend/src/modules/audit/request-audit.js';\nexport { a };\n",
+    );
+    expect(boundaryHits(around)).toHaveLength(1);
+    // A trailing slash is the module's folder, which is its index.
+    expect(await lintAs(`${BE}/modules/mcp/__lint_fixture__.ts`, "import { a } from '../audit/';\nexport { a };\n")).toEqual([]);
+    // Inside one module too: only the normal-form spelling of the same import passes.
+    const roundabout = await lintAs(
+      `${BE}/modules/mcp/__lint_fixture__.ts`,
+      "import { a } from './oauth/../mcp.routes.js';\nexport { a };\n",
+    );
+    expect(roundabout.filter((m) => m.includes('normal form'))).toHaveLength(1);
+    expect(await lintAs(`${BE}/modules/mcp/__lint_fixture__.ts`, "import { a } from './mcp.routes.js';\nexport { a };\n")).toEqual([]);
+  });
+
+  it("rejects a package naming another module's internals through its own exports", async () => {
+    const cases = [
+      [`${BE}/modules/mcp/__lint_fixture__.ts`, '@bevel-software/platform-core-backend/modules/', 'audit', 'request-audit.js'],
+      [`${BE}/modules/mcp/oauth/__lint_fixture__.ts`, '@bevel-software/platform-core-backend/modules/', 'audit', 'request-audit.js'],
+      [`${FE}/modules/library/__lint_fixture__.tsx`, '@bevel-software/platform-core-frontend/src/modules/', 'workspace', 'hooks/useFileTree'],
+    ] as const;
+    for (const [file, prefix, other, internal] of cases) {
+      const deep = await lintAs(file, `import { a } from '${prefix}${other}/${internal}';\nexport { a };\n`);
+      expect(boundaryHits(deep), `${file}: ${prefix}${other}/${internal}`).toHaveLength(1);
+      expect(deep[0]).toContain(`modules/${other}/index.ts`);
+      for (const entry of [`${prefix}${other}`, `${prefix}${other}/index.js`]) {
+        expect(await lintAs(file, `import { a } from '${entry}';\nexport { a };\n`), entry).toEqual([]);
+      }
+    }
+  });
+
+  it('covers every folder depth a module has, with no ceiling', async () => {
+    // A throwaway tree: module `deep` nests eight folders, deeper than any today.
+    const { moduleBoundaries } = await boundaryModule();
+    const root = mkdtempSync(join(tmpdir(), 'module-boundaries-'));
+    try {
+      const nested = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
+      for (const pkg of ['core-backend', 'core-frontend']) {
+        mkdirSync(join(root, 'packages', pkg, 'src', 'modules', 'other'), { recursive: true });
+      }
+      mkdirSync(join(root, 'packages', 'core-backend', 'src', 'modules', 'deep', ...nested), { recursive: true });
+      const tseslint = (await import('typescript-eslint')).default;
+      const overrideConfig = [
+        { files: ['**/*.{ts,tsx}'], languageOptions: { parser: tseslint.parser } },
+        ...moduleBoundaries({ root }),
+      ] as ESLint.Options['overrideConfig'];
+      const bare = new ESLint({ cwd: root, overrideConfigFile: true, overrideConfig });
+      const file = join(root, 'packages', 'core-backend', 'src', 'modules', 'deep', ...nested, 'x.ts');
+      const lint = async (spec: string) =>
+        (await bare.lintText(`import { a } from '${spec}';\nexport { a };\n`, { filePath: file }))[0].messages.map((m) => m.message);
+      const out = '../'.repeat(nested.length + 1);
+      expect(boundaryHits(await lint(`${out}other/x.js`))).toHaveLength(1);
+      expect(await lint(`${out}other/index.js`)).toEqual([]);
+      expect(await lint(`${'../'.repeat(nested.length)}deep.service.js`)).toEqual([]);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+  it('leaves shared/ and core/ alone: they are not modules', async () => {
+    expect(
+      await lintAs(`${BE}/modules/mcp/__lint_fixture__.ts`, "import { a } from '../../shared/logging.js';\nexport { a };\n"),
+    ).toEqual([]);
+    for (const dir of ['shared', 'core']) {
+      expect(
+        await lintAs(`${BE}/${dir}/__lint_fixture__.ts`, "import { a } from '../modules/audit/request-audit.js';\nexport { a };\n"),
+      ).toEqual([]);
+    }
+  });
+
+  it("lets tests reach into another module's internals for a fixture", async () => {
+    expect(
+      await lintAs(
+        `${BE}/modules/mcp/__tests__/__lint_fixture__.test.ts`,
+        "import { a } from '../../audit/request-audit.js';\nexport { a };\n",
+      ),
+    ).toEqual([]);
+  });
+
+  it('keeps the backend live-binding restriction in the same files', async () => {
+    // A later block's options replace an earlier one's, so the boundary blocks
+    // carry the live-binding `paths` along; this proves they still apply.
+    const messages = await lintAs(
+      `${BE}/modules/mcp/__lint_fixture__.ts`,
+      "import { DEFAULT_BRANCH } from '@bevel-software/platform-shared';\nexport const b = DEFAULT_BRANCH;\n",
+    );
+    expect(messages).toHaveLength(1);
+    expect(messages[0]).toContain('KbContext');
+  });
+
+  it('holds core-frontend modules to the same rule', async () => {
+    const deep = await lintAs(
+      `${FE}/modules/library/__lint_fixture__.tsx`,
+      "import { useFileTree } from '../workspace/hooks/useFileTree';\nexport const a = useFileTree;\n",
+    );
+    expect(boundaryHits(deep)).toHaveLength(1);
+    expect(deep[0]).toContain('modules/workspace/index.ts');
+    for (const spec of ['../workspace', '../workspace/index', './components/Thing', '../../shared/api']) {
+      expect(await lintAs(`${FE}/modules/library/__lint_fixture__.tsx`, `import { a } from '${spec}';\nexport { a };\n`)).toEqual(
+        [],
+      );
+    }
+  });
+
+  it("lets a core-frontend module compose another module's components and stylesheets by their file, and nothing else", async () => {
+    // A component is composed into a screen, not called; an index that
+    // re-exported components would load every screen behind any hook — see
+    // COMPOSED in eslint.module-boundaries.js. Hooks, services, state and
+    // utilities still go through the index.
+    for (const spec of ['../workspace/components/FileTree', '../workspace/components/renderers/HtmlRenderer', '../change-requests/change-requests.css']) {
+      expect(await lintAs(`${FE}/modules/library/__lint_fixture__.tsx`, `import { a } from '${spec}';\nexport { a };\n`)).toEqual([]);
+    }
+    for (const spec of ['../workspace/services/workspace.api', '../workspace/state/workspace.context', '../workspace/utils/diff', '../workspace/componentsx/Thing']) {
+      expect(boundaryHits(await lintAs(`${FE}/modules/library/__lint_fixture__.tsx`, `import { a } from '${spec}';\nexport { a };\n`))).toHaveLength(1);
+    }
+    // The backend has no such allowance: a `components/` folder there is an internal like any other.
+    expect(boundaryHits(await lintAs(`${BE}/modules/mcp/__lint_fixture__.ts`, "import { a } from '../workspace/components/thing.js';\nexport { a };\n"))).toHaveLength(1);
+  });
+
+  it('finds no deep import in any module file outside the exception list', async () => {
+    const files = [...moduleSources(join(BACKEND, 'modules')), ...moduleSources(join(FRONTEND, 'modules'))];
+    expect(files.length).toBeGreaterThan(100);
+    const results = await eslint().lintFiles(files);
+    const hits = results.flatMap((r) =>
+      r.messages
+        .filter((m) => m.ruleId === RULE && m.message.includes(RULE_NAME))
+        .map((m) => `${relative(REPO_ROOT, r.filePath)}:${m.line} ${m.message}`),
+    );
+    expect(hits).toEqual([]);
+  }, 300_000);
+
+  it('lists only files that still need their exception, each with a reason', async () => {
+    const { moduleBoundaries, MODULE_BOUNDARY_EXCEPTIONS } = await boundaryModule();
+    const listed = Object.keys(MODULE_BOUNDARY_EXCEPTIONS);
+    for (const [file, reason] of Object.entries(MODULE_BOUNDARY_EXCEPTIONS)) {
+      expect(existsSync(join(REPO_ROOT, file)), `${file} is listed but does not exist`).toBe(true);
+      expect(reason.trim(), `${file} is listed without a reason`).not.toBe('');
+    }
+    // An empty list is the goal state; `lintFiles([])` would lint the whole
+    // repository instead of nothing, so it is answered here.
+    if (listed.length === 0) return;
+    // The rule as written, with nobody excused: every listed file must still trip it.
+    const tseslint = (await import('typescript-eslint')).default;
+    const overrideConfig = [
+      { files: ['**/*.{ts,tsx}'], languageOptions: { parser: tseslint.parser } },
+      ...moduleBoundaries({ root: REPO_ROOT, exceptions: {} }),
+    ] as ESLint.Options['overrideConfig'];
+    const bare = new ESLint({ cwd: REPO_ROOT, overrideConfigFile: true, overrideConfig });
+    const results = await bare.lintFiles(listed.map((f) => join(REPO_ROOT, f)));
+    const clean = results
+      .filter((r) => !r.messages.some((m) => m.message.includes(BOUNDARY)))
+      .map((r) => relative(REPO_ROOT, r.filePath));
+    expect(clean, 'these files no longer import another module\'s internals: delete their exception').toEqual([]);
+  }, 300_000);
+});

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/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/dist/modules/workspace/bounded-matcher.d.ts

@@ -1,79 +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: 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 poolMax;
-    private readonly maxWaiting;
-    private readonly maxPatternLength;
-    private readonly batchChars;
-    private readonly batchLines;
-    private readonly idle;
-    private readonly all;
-    private readonly waiting;
-    private closed;
-    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;
-    private acquire;
-    private release;
-    private spawn;
-}
-//# 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":"AAEA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,cAAc,EAGpB,MAAM,+BAA+B,CAAC;AAEvC;;;;;;;;;;;;;;;;;GAiBG;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,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,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,CAAgB;IACrC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAqB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;gBAElB,IAAI,GAAE,2BAAgC;IAiBlD,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc;IAgB/C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;YAQF,OAAO;IAcrB,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,KAAK;CAcd"}