@inflexa-ai/harness 0.45.1 → 0.46.0

package/dist/lib/rate-limit.js

@@ -1,21 +1,20 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { errorOf } from "./thrown.js";
 function abortReason(signal) {
-    return signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
+    return errorOf(signal.reason) ?? new DOMException("The operation was aborted", "AbortError");
 }
 export function sleepWithSignal(milliseconds, signal) {
+    // The node wait consults the signal before any duration elapses, and its abort
+    // rejection is a fresh AbortError instead of `signal.reason` under the Bun test
+    // runtime, so the gates and the catch carry the reasons of this contract.
     if (milliseconds <= 0)
         return Promise.resolve();
-    if (signal?.aborted)
+    if (signal === undefined)
+        return sleep(milliseconds);
+    if (signal.aborted)
         return Promise.reject(abortReason(signal));
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, milliseconds);
-        const onAbort = () => {
-            clearTimeout(timeout);
-            reject(abortReason(signal));
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
+    return sleep(milliseconds, undefined, { signal }).catch(() => {
+        throw abortReason(signal);
     });
 }
 class Semaphore {
@@ -33,7 +32,7 @@ class Semaphore {
             return;
         }
         await new Promise((resolve, reject) => {
-            const waiter = { resolve, reject, ...(signal === undefined ? {} : { signal }) };
+            const waiter = { resolve, reject, signal };
             if (signal !== undefined) {
                 waiter.onAbort = () => {
                     const index = this.waiters.indexOf(waiter);

package/dist/lib/regulatory-corpus/fetch-fda-guidance.d.ts

@@ -1,5 +1,5 @@
 export type FdaCenter = "CDER" | "CBER";
-export interface FdaDocStub {
+export type FdaDocStub = {
     doc_id: string;
     doc_title: string;
     doc_url: string;
@@ -8,8 +8,8 @@ export interface FdaDocStub {
         year?: string;
         category?: string;
     };
-}
-export interface FdaDoc {
+};
+export type FdaDoc = {
     doc_id: string;
     doc_title: string;
     doc_url: string;
@@ -19,7 +19,7 @@ export interface FdaDoc {
         year?: string;
         category?: string;
     };
-}
+};
 /**
  * Return the curated FDA guidance stubs for `center`. The catalog is
  * static; this function exists for parity with `fetchIchListing()` and as

package/dist/lib/regulatory-corpus/fetch-fda-guidance.js

@@ -1,5 +1,6 @@
 import { load } from "cheerio";
 import { PDFParse } from "pdf-parse";
+import { normalizeWhitespace } from "./normalize-whitespace.js";
 /**
  * Curated catalog of FDA guidance documents to index into the corpus.
  *
@@ -53,14 +54,14 @@ const FDA_GUIDANCES = [
  * the seam where a future contributor can swap in dynamic discovery
  * (e.g., headless-browser scraping or a vetted third-party index).
  */
-export async function fetchFdaGuidanceListing(center) {
-    return FDA_GUIDANCES.filter((g) => g.center === center).map((g) => ({
+export function fetchFdaGuidanceListing(center) {
+    return Promise.resolve(FDA_GUIDANCES.filter((g) => g.center === center).map((g) => ({
         doc_id: g.doc_id,
         doc_title: g.doc_title,
         doc_url: `https://www.fda.gov/media/${g.media_id}/download`,
         center: g.center,
         metadata: { year: g.year },
-    }));
+    })));
 }
 /**
  * Download a single FDA guidance document and extract its text. Handles
@@ -98,10 +99,3 @@ export async function fetchAndExtractFdaDoc(stub) {
         },
     };
 }
-function normalizeWhitespace(s) {
-    return s
-        .replace(/[ \t]+/g, " ")
-        .replace(/\r/g, "")
-        .replace(/\n{3,}/g, "\n\n")
-        .trim();
-}

package/dist/lib/regulatory-corpus/fetch-ich.d.ts

@@ -12,7 +12,7 @@
  * `ich-<code>` with non-word chars sanitized.
  */
 export type IchSeries = "S" | "E" | "M" | "Q";
-export interface IchStub {
+export type IchStub = {
     doc_id: string;
     doc_title: string;
     doc_url: string;
@@ -21,8 +21,8 @@ export interface IchStub {
     metadata?: {
         year?: string;
     };
-}
-export interface IchDoc {
+};
+export type IchDoc = {
     doc_id: string;
     doc_title: string;
     doc_url: string;
@@ -32,7 +32,7 @@ export interface IchDoc {
         series: IchSeries;
         year?: string;
     };
-}
+};
 /**
  * Return the curated ICH guideline stubs. The catalog is static; this
  * function exists for parity with `fetchFdaGuidanceListing()` and as the

package/dist/lib/regulatory-corpus/fetch-ich.js

@@ -12,6 +12,7 @@
  * `ich-<code>` with non-word chars sanitized.
  */
 import { PDFParse } from "pdf-parse";
+import { normalizeWhitespace } from "./normalize-whitespace.js";
 /**
  * Curated catalog of ICH guidelines to index into the corpus.
  *
@@ -124,14 +125,14 @@ const ICH_GUIDELINES = [
  * function exists for parity with `fetchFdaGuidanceListing()` and as the
  * seam where a future contributor can swap in dynamic discovery.
  */
-export async function fetchIchListing() {
-    return ICH_GUIDELINES.map((g) => ({
+export function fetchIchListing() {
+    return Promise.resolve(ICH_GUIDELINES.map((g) => ({
         doc_id: `ich-${slugify(g.code)}`,
         doc_title: g.doc_title,
         doc_url: g.url,
         code: g.code,
         series: g.series,
-    }));
+    })));
 }
 /**
  * Download a single ICH guideline PDF and extract its text. Returns
@@ -158,16 +159,19 @@ export async function fetchAndExtractIchDoc(stub) {
         },
     };
 }
-function normalizeWhitespace(s) {
-    return s
-        .replace(/[ \t]+/g, " ")
-        .replace(/\r/g, "")
-        .replace(/\n{3,}/g, "\n\n")
-        .trim();
-}
 function slugify(s) {
-    return s
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-|-$/g, "");
+    let out = "";
+    let inRun = false;
+    for (const char of s.toLowerCase()) {
+        const isSlugChar = (char >= "a" && char <= "z") || (char >= "0" && char <= "9");
+        if (!isSlugChar) {
+            inRun = true;
+            continue;
+        }
+        if (inRun && out.length > 0)
+            out += "-";
+        inRun = false;
+        out += char;
+    }
+    return out;
 }

package/dist/lib/regulatory-corpus/normalize-whitespace.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whitespace normalization for fetched regulatory document text (HTML bodies and PDF
+ * extractions): space and tab runs collapse to one space, newline runs cap at one blank
+ * line, and the edges trim.
+ */
+export declare function normalizeWhitespace(s: string): string;

package/dist/lib/regulatory-corpus/normalize-whitespace.js

@@ -0,0 +1,41 @@
+/**
+ * Whitespace normalization for fetched regulatory document text (HTML bodies and PDF
+ * extractions): space and tab runs collapse to one space, newline runs cap at one blank
+ * line, and the edges trim.
+ */
+export function normalizeWhitespace(s) {
+    let out = "";
+    let inSpaceRun = false;
+    let newlineRun = 0;
+    const flushNewlineRun = () => {
+        out += "\n".repeat(Math.min(newlineRun, 2));
+        newlineRun = 0;
+    };
+    for (const char of s) {
+        // A CR joins the newline run it sits in — a CRLF pair merges through it, it never
+        // ends the run — and with no run pending it only ends a space run.
+        if (char === "\r") {
+            inSpaceRun = false;
+            continue;
+        }
+        if (char === "\n") {
+            inSpaceRun = false;
+            newlineRun += 1;
+            continue;
+        }
+        if (char === " " || char === "\t") {
+            if (newlineRun > 0)
+                flushNewlineRun();
+            if (!inSpaceRun)
+                out += " ";
+            inSpaceRun = true;
+            continue;
+        }
+        if (newlineRun > 0)
+            flushNewlineRun();
+        inSpaceRun = false;
+        out += char;
+    }
+    flushNewlineRun();
+    return out.trim();
+}

package/dist/lib/regulatory-corpus.d.ts

@@ -16,15 +16,15 @@
 import { ResultAsync } from "neverthrow";
 import type { Pool } from "pg";
 import { type DbError } from "./db-result.js";
-export interface ChunkOptions {
+export type ChunkOptions = {
     maxTokens?: number;
     overlapTokens?: number;
-}
-export interface RawChunk {
+};
+export type RawChunk = {
     section: string | null;
     index: number;
     text: string;
-}
+};
 /**
  * Split `text` into overlapping chunks bounded by `maxTokens` (word-count
  * approximation), respecting `## Heading` section boundaries where present.
@@ -41,7 +41,7 @@ export interface RawChunk {
  * can reassemble the document order without inspecting section names.
  */
 export declare function chunkText(text: string, opts?: ChunkOptions): RawChunk[];
-export interface ChunkRow {
+export type ChunkRow = {
     source: "FDA-CDER" | "FDA-CBER" | "ICH";
     doc_id: string;
     doc_title: string;
@@ -50,7 +50,7 @@ export interface ChunkRow {
         embedding: number[];
     }>;
     metadata: Record<string, unknown>;
-}
+};
 /**
  * Replace-by-(source, doc_id): delete all existing chunks for the document
  * then insert the new set in a single transaction.
@@ -60,11 +60,11 @@ export interface ChunkRow {
  * back), not a `DbError`.
  */
 export declare function upsertChunks(pool: Pool, row: ChunkRow): ResultAsync<void, DbError>;
-export interface SearchFilters {
+export type SearchFilters = {
     source?: "FDA-CDER" | "FDA-CBER" | "ICH";
     topK?: number;
-}
-export interface SearchHit {
+};
+export type SearchHit = {
     source: string;
     doc_id: string;
     doc_title: string;
@@ -72,7 +72,7 @@ export interface SearchHit {
     section: string | null;
     excerpt: string;
     score: number;
-}
+};
 /**
  * Top-K cosine similarity search over cortex_regulatory_chunks.
  *

package/dist/lib/regulatory-corpus.js

@@ -14,6 +14,7 @@
  * insert time.
  */
 import { tryMutation, tryQuery, withTransaction } from "./db-result.js";
+import { collapseWhitespace } from "./text.js";
 /**
  * Split `text` into overlapping chunks bounded by `maxTokens` (word-count
  * approximation), respecting `## Heading` section boundaries where present.
@@ -36,6 +37,7 @@ export function chunkText(text, opts = {}) {
     // This ensures a heading at position 0 (no preceding newline) is caught
     // the same way as headings mid-document.
     const normalised = text.startsWith("##") ? `\n${text}` : text;
+    // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the split marker is a level-2 heading (newline, two hashes, whitespace); the whitespace run may cross the heading's own newline, which the string split cannot express.
     const parts = normalised.split(/\n##\s+/);
     // parts[0] is always the lead-in text before the first heading (may be
     // empty when the document opens with a heading).
@@ -52,7 +54,7 @@ export function chunkText(text, opts = {}) {
     const out = [];
     let globalIdx = 0;
     for (const sec of sections) {
-        const tokens = sec.body.split(/\s+/).filter(Boolean);
+        const tokens = collapseWhitespace(sec.body).split(" ").filter(Boolean);
         if (tokens.length === 0)
             continue;
         // Slide a window of maxTokens tokens with advance = maxTokens - overlapTokens.

package/dist/lib/result.d.ts

@@ -23,14 +23,14 @@
  *     dialect of failure:
  *       - HTTP routes `.match(...)` a `Result` into a response.
  *       - The DBOS step boundary throws on an `err` that must fail or retry
- *         the step (`unwrapOrThrow` / `resultStep` in `loop/run-step.ts`):
+ *         the step (`unwrapOrThrow`):
  *         durability records a step as failed — and retries / fails fast —
  *         ONLY on a thrown exception. A step can also return a `Result` as
  *         its value: `runtime/result-serialization.ts` keeps the `Ok` / `Err`
  *         class across the checkpoint, DBOS records the step as a success,
  *         and the body MUST use the `err`.
- *       - Tool dispatch maps `err` into an `is_error` `tool_result`
- *         (`loop/run-agent.ts`).
+ *       - The tool adapter maps `err` into an error tool result
+ *         (`loop/tool-adapter.ts`).
  *
  * Control-flow exceptions (DBOS cancellation, `AbortError`) are NOT failures
  * and live OUTSIDE the `Result` error channel — they are thrown verbatim and
@@ -47,10 +47,10 @@ import { type Result } from "neverthrow";
  * `SandboxError`), and ship a `describe*Error` formatter that turns one into
  * a user-facing line. A step body's error channel is some `DomainError`.
  */
-export interface DomainError {
+export type DomainError = {
     readonly type: string;
     readonly cause?: unknown;
-}
+};
 /**
  * A thrown wrapper for a structured error value that is not already an
  * `Error`. The original value rides on `.cause`, so the cause-walking
@@ -77,21 +77,20 @@ export declare function toThrowable(value: unknown): Error;
  *
  * Use it ONLY where a throw is the boundary's failure contract:
  *
- *  - **DBOS workflow/step bodies** (directly, or composed via `resultStep` in
- *    `loop/run-step.ts`). DBOS records a step as failed — and retries / fails
+ *  - **DBOS workflow/step bodies**. DBOS records a step as failed — and retries / fails
  *    fast — only on a thrown exception; a *returned* `err` would be durably
  *    cached as a successful step output and replayed as success forever.
  *  - **Tool `execute` bodies**, where the loop's dispatch catch maps the
- *    throw into a model-visible error tool result (`loop/run-agent.ts`).
+ *    throw into a model-visible error tool result (`loop/tool-adapter.ts`).
  *  - **Driver edges whose protocol is a throw** (e.g. throw-to-rollback).
  *
  * Anywhere else, keep the `Result` flowing: return it, chain
  * `.andThen`/`.map`/`.mapErr`, or `.match` both branches. Never reach for
  * this to dodge error handling in composable domain logic.
  *
- * The `must-use-result` lint rule recognizes `unwrapOrThrow(...)` as
- * consuming its Result (see the plugin patch in `eslint.config.js`) — do not
- * rewrite call sites into inline `.match`+throw forms to appease lint.
+ * The `must-use-result` rule of the type check command recognizes
+ * `unwrapOrThrow(...)` as consuming its Result — do not rewrite call sites
+ * into inline `.match`+throw forms to appease the rule.
  */
 export declare function unwrapOrThrow<T, E>(result: Result<T, E>): T;
 /** Runtime brand check — is this value a neverthrow `Result`? */

package/dist/lib/result.js

@@ -23,14 +23,14 @@
  *     dialect of failure:
  *       - HTTP routes `.match(...)` a `Result` into a response.
  *       - The DBOS step boundary throws on an `err` that must fail or retry
- *         the step (`unwrapOrThrow` / `resultStep` in `loop/run-step.ts`):
+ *         the step (`unwrapOrThrow`):
  *         durability records a step as failed — and retries / fails fast —
  *         ONLY on a thrown exception. A step can also return a `Result` as
  *         its value: `runtime/result-serialization.ts` keeps the `Ok` / `Err`
  *         class across the checkpoint, DBOS records the step as a success,
  *         and the body MUST use the `err`.
- *       - Tool dispatch maps `err` into an `is_error` `tool_result`
- *         (`loop/run-agent.ts`).
+ *       - The tool adapter maps `err` into an error tool result
+ *         (`loop/tool-adapter.ts`).
  *
  * Control-flow exceptions (DBOS cancellation, `AbortError`) are NOT failures
  * and live OUTSIDE the `Result` error channel — they are thrown verbatim and
@@ -39,6 +39,8 @@
  * Sites import `ok`/`err`/`Result`/`ResultAsync`/`fromPromise`/`fromThrowable`
  * directly from `neverthrow`; this module owns only the cortex-specific glue.
  */
+import { parseUnknownRecord } from "../lib/unknown-containers.js";
+import { textOf } from "../lib/unknown-text.js";
 import { Err, Ok } from "neverthrow";
 /**
  * A thrown wrapper for a structured error value that is not already an
@@ -58,16 +60,17 @@ export class ResultError extends Error {
 function describe(value) {
     if (value instanceof Error)
         return value.message;
-    if (value && typeof value === "object" && "type" in value) {
+    const record = parseUnknownRecord(value);
+    if (record !== undefined && "type" in record) {
         // Prefer a human `message` field when the structured error carries one
         // (e.g. a `ProviderError`) so the wrapped `Error.message` names the
         // failure; fall back to the `type` discriminant otherwise.
-        const message = value.message;
+        const message = record["message"];
         if (typeof message === "string" && message.length > 0)
             return message;
-        return String(value.type);
+        return textOf(record["type"]);
     }
-    return String(value);
+    return textOf(value);
 }
 /**
  * Bridge a `Result` error value into a thrown `Error` at a boundary that
@@ -86,21 +89,20 @@ export function toThrowable(value) {
  *
  * Use it ONLY where a throw is the boundary's failure contract:
  *
- *  - **DBOS workflow/step bodies** (directly, or composed via `resultStep` in
- *    `loop/run-step.ts`). DBOS records a step as failed — and retries / fails
+ *  - **DBOS workflow/step bodies**. DBOS records a step as failed — and retries / fails
  *    fast — only on a thrown exception; a *returned* `err` would be durably
  *    cached as a successful step output and replayed as success forever.
  *  - **Tool `execute` bodies**, where the loop's dispatch catch maps the
- *    throw into a model-visible error tool result (`loop/run-agent.ts`).
+ *    throw into a model-visible error tool result (`loop/tool-adapter.ts`).
  *  - **Driver edges whose protocol is a throw** (e.g. throw-to-rollback).
  *
  * Anywhere else, keep the `Result` flowing: return it, chain
  * `.andThen`/`.map`/`.mapErr`, or `.match` both branches. Never reach for
  * this to dodge error handling in composable domain logic.
  *
- * The `must-use-result` lint rule recognizes `unwrapOrThrow(...)` as
- * consuming its Result (see the plugin patch in `eslint.config.js`) — do not
- * rewrite call sites into inline `.match`+throw forms to appease lint.
+ * The `must-use-result` rule of the type check command recognizes
+ * `unwrapOrThrow(...)` as consuming its Result — do not rewrite call sites
+ * into inline `.match`+throw forms to appease the rule.
  */
 export function unwrapOrThrow(result) {
     if (result.isErr())

package/dist/lib/storage.d.ts

@@ -12,7 +12,7 @@ import { type Pool } from "pg";
  * fields plus the optional pool-size override. Composition roots map their
  * validated `Env` onto this; the harness never reaches for an env loader.
  */
-export interface PoolConfig {
+export type PoolConfig = {
     readonly host: string;
     readonly port: string;
     readonly database: string;
@@ -20,7 +20,7 @@ export interface PoolConfig {
     readonly password: string;
     readonly sslMode: "disable" | "require" | "verify-ca" | "verify-full";
     readonly poolMax?: string;
-}
+};
 /**
  * Construct the application `pg.Pool`. Called exactly once, at the process
  * composition root (`server.ts:main()`), and threaded as a constructor dep

package/dist/lib/test/async-iterable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared AsyncIterable test helper. It yields the items in order, so a test
+ * drives a stream consumer with no timer.
+ */
+/**
+ * Yields each item of the array in order. When `toThrow` is given, the
+ * iterator rejects with it after the last item instead of finishing.
+ */
+export declare function asyncIterableOf<T>(items: readonly T[], toThrow?: unknown): AsyncIterable<T>;

package/dist/lib/test/async-iterable.js

@@ -0,0 +1,28 @@
+/**
+ * Shared AsyncIterable test helper. It yields the items in order, so a test
+ * drives a stream consumer with no timer.
+ */
+/**
+ * Yields each item of the array in order. When `toThrow` is given, the
+ * iterator rejects with it after the last item instead of finishing.
+ */
+export function asyncIterableOf(items, toThrow) {
+    let i = 0;
+    return {
+        [Symbol.asyncIterator]: () => ({
+            next: () => {
+                if (i < items.length) {
+                    const value = items[i];
+                    if (value === undefined)
+                        return Promise.resolve({ done: true, value: undefined });
+                    i += 1;
+                    return Promise.resolve({ done: false, value });
+                }
+                // oxlint-disable-next-line typescript/prefer-promise-reject-errors -- a test rejects with the exact abort reason that the production stream carries (DOMException or Error), and the test matches it.
+                if (toThrow !== undefined)
+                    return Promise.reject(toThrow);
+                return Promise.resolve({ done: true, value: undefined });
+            },
+        }),
+    };
+}

package/dist/lib/test/request-url.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The URL text of a fetch target, for test doubles that record what a client
+ * asked for: each member of the `fetch` input union names its URL itself.
+ */
+export declare function requestUrlText(input: string | URL | Request): string;

package/dist/lib/test/request-url.js

@@ -0,0 +1,7 @@
+/**
+ * The URL text of a fetch target, for test doubles that record what a client
+ * asked for: each member of the `fetch` input union names its URL itself.
+ */
+export function requestUrlText(input) {
+    return typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+}

package/dist/lib/test/result-assert.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared Result assertion helper for the test files of several module families.
+ * The helper serves a guaranteed ok: a test that expects an err states it with
+ * `_unsafeUnwrapErr` directly.
+ */
+import type { Result, ResultAsync } from "neverthrow";
+/**
+ * Awaits a `Result`-bearing call and unwraps the ok, so the call states that it
+ * succeeded. An err throws an `Error` with a stack and the err value as its
+ * `cause`, where `_unsafeUnwrap` throws a plain object with no stack.
+ */
+export declare function awaitOk<T, E>(call: Result<T, E> | Promise<Result<T, E>> | ResultAsync<T, E>): Promise<T>;

package/dist/lib/test/result-assert.js

@@ -0,0 +1,17 @@
+/**
+ * Shared Result assertion helper for the test files of several module families.
+ * The helper serves a guaranteed ok: a test that expects an err states it with
+ * `_unsafeUnwrapErr` directly.
+ */
+import { textOf } from "../unknown-text.js";
+/**
+ * Awaits a `Result`-bearing call and unwraps the ok, so the call states that it
+ * succeeded. An err throws an `Error` with a stack and the err value as its
+ * `cause`, where `_unsafeUnwrap` throws a plain object with no stack.
+ */
+export async function awaitOk(call) {
+    const result = await call;
+    if (result.isErr())
+        throw new Error(`the call gave an err: ${textOf(result.error)}`, { cause: result.error });
+    return result.value;
+}

package/dist/lib/test/text-shapes.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Text shapes that the test files of several module families assert: the lowercase
+ * hex digest family, the tool-output reference, the six-digit hex color, and the
+ * paired-surrogate invariants of cut text. Each predicate reads the string with the
+ * string methods and the char codes, so no pattern lives here.
+ */
+/** Whether `text` is exactly `length` lowercase hex characters. */
+export declare function isLowerHexOfLength(text: string, length: number): boolean;
+/** Whether `text` is a `sha256:` content hash over a 64-digit lowercase hex digest. */
+export declare function isSha256Hash(text: string): boolean;
+/** Whether `text` is a tool-output reference: `to_` over 20 lowercase hex characters. */
+export declare function isToolOutputRef(text: string): boolean;
+/**
+ * The tool-output reference that a cut-result marker names, or undefined when the text
+ * names none. The marker reads `reference "to_<20 hex>"`, and the reference ends at its
+ * closing quote.
+ */
+export declare function referencedToolOutput(text: string): string | undefined;
+/** Whether `text` is an RGB color in the six-digit lowercase hex form: `#1a2b3c`. */
+export declare function isHexColor(text: string): boolean;
+/** Whether `text` holds a high surrogate that no low surrogate follows. */
+export declare function hasLoneHighSurrogate(text: string): boolean;
+/** Whether `text` holds a low surrogate that no high surrogate precedes. */
+export declare function hasLoneLowSurrogate(text: string): boolean;

package/dist/lib/test/text-shapes.js

@@ -0,0 +1,63 @@
+/**
+ * Text shapes that the test files of several module families assert: the lowercase
+ * hex digest family, the tool-output reference, the six-digit hex color, and the
+ * paired-surrogate invariants of cut text. Each predicate reads the string with the
+ * string methods and the char codes, so no pattern lives here.
+ */
+function isLowerHex(text) {
+    return Array.from(text).every((char) => (char >= "0" && char <= "9") || (char >= "a" && char <= "f"));
+}
+/** Whether `text` is exactly `length` lowercase hex characters. */
+export function isLowerHexOfLength(text, length) {
+    return text.length === length && isLowerHex(text);
+}
+/** Whether `text` is a `sha256:` content hash over a 64-digit lowercase hex digest. */
+export function isSha256Hash(text) {
+    return text.startsWith("sha256:") && isLowerHexOfLength(text.slice("sha256:".length), 64);
+}
+/** Whether `text` is a tool-output reference: `to_` over 20 lowercase hex characters. */
+export function isToolOutputRef(text) {
+    return text.startsWith("to_") && isLowerHexOfLength(text.slice("to_".length), 20);
+}
+/**
+ * The tool-output reference that a cut-result marker names, or undefined when the text
+ * names none. The marker reads `reference "to_<20 hex>"`, and the reference ends at its
+ * closing quote.
+ */
+export function referencedToolOutput(text) {
+    const opener = 'reference "';
+    const at = text.indexOf(opener);
+    if (at < 0)
+        return undefined;
+    const start = at + opener.length;
+    const ref = text.slice(start, start + "to_".length + 20);
+    if (!isToolOutputRef(ref) || text.charAt(start + ref.length) !== '"')
+        return undefined;
+    return ref;
+}
+/** Whether `text` is an RGB color in the six-digit lowercase hex form: `#1a2b3c`. */
+export function isHexColor(text) {
+    return text.startsWith("#") && isLowerHexOfLength(text.slice(1), 6);
+}
+function isHighSurrogate(unit) {
+    return unit >= 0xd800 && unit <= 0xdbff;
+}
+function isLowSurrogate(unit) {
+    return unit >= 0xdc00 && unit <= 0xdfff;
+}
+/** Whether `text` holds a high surrogate that no low surrogate follows. */
+export function hasLoneHighSurrogate(text) {
+    for (let i = 0; i < text.length; i++) {
+        if (isHighSurrogate(text.charCodeAt(i)) && !isLowSurrogate(text.charCodeAt(i + 1)))
+            return true;
+    }
+    return false;
+}
+/** Whether `text` holds a low surrogate that no high surrogate precedes. */
+export function hasLoneLowSurrogate(text) {
+    for (let i = 0; i < text.length; i++) {
+        if (isLowSurrogate(text.charCodeAt(i)) && !isHighSurrogate(text.charCodeAt(i - 1)))
+            return true;
+    }
+    return false;
+}