@velum-labs/routekit-harness-core 0.9.0

package/dist/errors.js

@@ -0,0 +1,88 @@
+/**
+ * The one harness failure taxonomy. Every driver classifies failures into
+ * these codes at the boundary where they occur; retryability and failover
+ * category are derived from the code, never hand-picked per call site.
+ */
+export const HARNESS_ERROR_CODES = [
+    /** The CLI binary is not installed / not on PATH. */
+    "not_installed",
+    /** The CLI is installed but not logged in / no usable credential. */
+    "not_authenticated",
+    /** The CLI version fails the driver's floor or handshake. */
+    "version_unsupported",
+    /** The driver rejected its configuration at decode time. */
+    "invalid_config",
+    /** The session existed but its process/connection has gone away. */
+    "session_closed",
+    /** A wire payload failed schema/shape validation. */
+    "protocol_parse",
+    /** The run exceeded its deadline. */
+    "timeout",
+    /** The run was cancelled via its abort signal. */
+    "aborted",
+    /** The provider/CLI reported a failure the driver could not classify further. */
+    "provider_error"
+];
+export class HarnessError extends Error {
+    code;
+    /** Optional finer-grained failover category when the driver knows better. */
+    category;
+    constructor(code, message, options = {}) {
+        super(message, options.cause !== undefined ? { cause: options.cause } : undefined);
+        this.name = "HarnessError";
+        this.code = code;
+        this.category = options.category ?? defaultCategoryFor(code);
+    }
+    get retryable() {
+        return isRetryable(this);
+    }
+}
+function defaultCategoryFor(code) {
+    switch (code) {
+        case "timeout":
+        case "session_closed":
+            return "transient";
+        case "not_authenticated":
+            return "auth_permanent";
+        case "not_installed":
+        case "version_unsupported":
+        case "invalid_config":
+        case "protocol_parse":
+        case "aborted":
+        case "provider_error":
+            return "unknown";
+        default: {
+            const exhausted = code;
+            throw new Error(`unsupported harness error code: ${String(exhausted)}`);
+        }
+    }
+}
+/** Retryability is derived from the taxonomy, never hardcoded per call site. */
+export function isRetryable(error) {
+    if (error.code === "aborted")
+        return false;
+    switch (error.category) {
+        case "transient":
+        case "quota_exhausted":
+            return true;
+        case "auth_permanent":
+        case "context_overflow":
+        case "unknown":
+            return false;
+        default: {
+            const exhausted = error.category;
+            throw new Error(`unsupported harness error category: ${String(exhausted)}`);
+        }
+    }
+}
+/** Wrap an arbitrary thrown value as a classified HarnessError. */
+export function asHarnessError(value, fallbackCode = "provider_error") {
+    if (value instanceof HarnessError)
+        return value;
+    const errno = value;
+    if (errno?.code === "ENOENT") {
+        return new HarnessError("not_installed", errno.message, { cause: value });
+    }
+    const message = value instanceof Error ? value.message : String(value);
+    return new HarnessError(fallbackCode, message, { cause: value });
+}

package/dist/events.d.ts

@@ -0,0 +1,4 @@
+import type { HarnessContentStream, HarnessEvent as RouteHarnessEvent, HarnessEventRaw, HarnessEventType, HarnessItemType, HarnessRequestType, HarnessTokenUsage, HarnessTurnEndReason } from "@velum-labs/routekit-contracts";
+import type { HarnessKind } from "./kinds.js";
+export type HarnessEvent = RouteHarnessEvent<HarnessKind>;
+export type { HarnessContentStream, HarnessEventRaw, HarnessEventType, HarnessItemType, HarnessRequestType, HarnessTokenUsage, HarnessTurnEndReason };

package/dist/events.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @velum-labs/routekit-harness-core is the single coding-agent harness contract:
+ * driver -> instance -> session interfaces, the canonical harness event
+ * union (with raw provider envelopes), one tagged error taxonomy with
+ * derived retryability, deferred-based approvals with explicit policies,
+ * status probes with an identity-checked disk cache, and an explicit driver
+ * registry. Drivers (tool-codex, tool-claude, tool-cursor, tool-opencode)
+ * implement this contract; orchestrators and launchers consume it.
+ */
+export { HARNESS_KINDS, isHarnessKind } from "./kinds.js";
+export type { HarnessKind } from "./kinds.js";
+export { HARNESS_ERROR_CODES, HarnessError, asHarnessError, isRetryable } from "./errors.js";
+export type { HarnessErrorCategory, HarnessErrorCode } from "./errors.js";
+export type { HarnessContentStream, HarnessEvent, HarnessEventRaw, HarnessEventType, HarnessItemType, HarnessRequestType, HarnessTokenUsage, HarnessTurnEndReason } from "./events.js";
+export { DEFAULT_AUTOMATION_APPROVAL_POLICY, PendingRequests, createDeferred, decideApproval } from "./approvals.js";
+export type { ApprovalDecision, ApprovalPolicy, Deferred, PendingRequest } from "./approvals.js";
+export { DEFAULT_STATUS_CACHE_DIR, readCachedStatus, statusSkipReason, writeCachedStatus } from "./status.js";
+export type { HarnessAuthStatus, HarnessModelDescriptor, HarnessStatus } from "./status.js";
+export type { AnyHarnessDriver, DriverContext, HarnessDriver, HarnessInstance, ResumeCursor, SessionHandle, SessionTurnInput, StartSessionOptions } from "./contract.js";
+export { DriverRegistry } from "./registry.js";
+export { createCachedHarnessDriver, probeCliVersion, resolveDriverEnv } from "./driver-factory.js";
+export type { CachedHarnessDriverInput, CliVersionProbeInput } from "./driver-factory.js";
+export { AsyncChannel } from "./channel.js";
+export { EventLog } from "./logging.js";
+export type { EventLogOptions } from "./logging.js";
+export { asArray, asObject, asString, createStreamJsonStepEmitter, parseStreamJsonLine, parseStreamJsonTrajectory, streamJsonResultContentText, stringifyStreamJsonValue, STREAM_JSON_MAX_TEXT, STREAM_JSON_MAX_TOOL_INPUT, truncateStreamJsonText } from "./stream-json.js";
+export type { ParsedStreamJson, ParseStreamJsonOptions, StreamJsonEmitterOptions, StreamJsonStepText } from "./stream-json.js";
+export { DEFAULT_TMP_MANIFEST, createTrackedTmpDir, releaseTrackedTmpDir, sweepTrackedTmpDirs } from "./tmp-sweep.js";
+export { buildChildEnv, freePort, runCliCapture, spawnLogged, terminate, waitForHttp, waitForOutput, withDeadline, withTimeout } from "./process.js";
+export type { BuildChildEnvInput, CliCaptureOptions, CliCaptureResult, LoggedChild, LoggedSpawnOptions } from "./process.js";

package/dist/index.js

@@ -0,0 +1,20 @@
+/**
+ * @velum-labs/routekit-harness-core is the single coding-agent harness contract:
+ * driver -> instance -> session interfaces, the canonical harness event
+ * union (with raw provider envelopes), one tagged error taxonomy with
+ * derived retryability, deferred-based approvals with explicit policies,
+ * status probes with an identity-checked disk cache, and an explicit driver
+ * registry. Drivers (tool-codex, tool-claude, tool-cursor, tool-opencode)
+ * implement this contract; orchestrators and launchers consume it.
+ */
+export { HARNESS_KINDS, isHarnessKind } from "./kinds.js";
+export { HARNESS_ERROR_CODES, HarnessError, asHarnessError, isRetryable } from "./errors.js";
+export { DEFAULT_AUTOMATION_APPROVAL_POLICY, PendingRequests, createDeferred, decideApproval } from "./approvals.js";
+export { DEFAULT_STATUS_CACHE_DIR, readCachedStatus, statusSkipReason, writeCachedStatus } from "./status.js";
+export { DriverRegistry } from "./registry.js";
+export { createCachedHarnessDriver, probeCliVersion, resolveDriverEnv } from "./driver-factory.js";
+export { AsyncChannel } from "./channel.js";
+export { EventLog } from "./logging.js";
+export { asArray, asObject, asString, createStreamJsonStepEmitter, parseStreamJsonLine, parseStreamJsonTrajectory, streamJsonResultContentText, stringifyStreamJsonValue, STREAM_JSON_MAX_TEXT, STREAM_JSON_MAX_TOOL_INPUT, truncateStreamJsonText } from "./stream-json.js";
+export { DEFAULT_TMP_MANIFEST, createTrackedTmpDir, releaseTrackedTmpDir, sweepTrackedTmpDirs } from "./tmp-sweep.js";
+export { buildChildEnv, freePort, runCliCapture, spawnLogged, terminate, waitForHttp, waitForOutput, withDeadline, withTimeout } from "./process.js";

package/dist/kinds.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The single harness-kind vocabulary. Every layer (drivers, orchestrators,
+ * launchers, and status probes uses these exact identifiers.
+ */
+export declare const HARNESS_KINDS: readonly ["codex", "claude_code", "cursor", "opencode", "generic"];
+export type HarnessKind = (typeof HARNESS_KINDS)[number];
+export declare function isHarnessKind(value: string): value is HarnessKind;

package/dist/kinds.js

@@ -0,0 +1,14 @@
+/**
+ * The single harness-kind vocabulary. Every layer (drivers, orchestrators,
+ * launchers, and status probes uses these exact identifiers.
+ */
+export const HARNESS_KINDS = [
+    "codex",
+    "claude_code",
+    "cursor",
+    "opencode",
+    "generic"
+];
+export function isHarnessKind(value) {
+    return HARNESS_KINDS.includes(value);
+}

package/dist/logging.d.ts

@@ -0,0 +1,17 @@
+import type { HarnessEvent } from "./events.js";
+/**
+ * Best-effort NDJSON event log, one file per session. Diagnostics must never
+ * break the run: every write failure is swallowed. Large `raw` payloads are
+ * summarized to a shape (byte length, field count) rather than written whole,
+ * matching t3code's payload-privacy discipline.
+ */
+export type EventLogOptions = {
+    dir: string;
+    /** Rotate the file once it exceeds this many bytes (default 10 MiB). */
+    maxBytes?: number;
+};
+export declare class EventLog {
+    #private;
+    constructor(options: EventLogOptions);
+    write(event: HarnessEvent): void;
+}

package/dist/logging.js

@@ -0,0 +1,62 @@
+import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { join } from "node:path";
+const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+function safeSegment(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 128) || "_session";
+}
+function summarizeRaw(raw) {
+    if (raw === undefined)
+        return undefined;
+    const payload = raw.payload;
+    let payloadSummary;
+    if (payload !== undefined) {
+        const json = JSON.stringify(payload);
+        payloadSummary = {
+            bytes: json.length,
+            fields: typeof payload === "object" && payload !== null ? Object.keys(payload).length : 0
+        };
+    }
+    return {
+        source: raw.source,
+        ...(raw.method !== undefined ? { method: raw.method } : {}),
+        ...(payloadSummary !== undefined ? { payload: payloadSummary } : {})
+    };
+}
+export class EventLog {
+    #dir;
+    #maxBytes;
+    #ready = false;
+    #broken = false;
+    constructor(options) {
+        this.#dir = options.dir;
+        this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    }
+    write(event) {
+        if (this.#broken)
+            return;
+        try {
+            if (!this.#ready) {
+                mkdirSync(this.#dir, { recursive: true });
+                this.#ready = true;
+            }
+            const file = join(this.#dir, `${safeSegment(event.sessionId)}.ndjson`);
+            this.#rotateIfNeeded(file);
+            const line = JSON.stringify({ ...event, raw: summarizeRaw(event.raw) });
+            appendFileSync(file, `${line}\n`);
+        }
+        catch {
+            // A bad path must not retry hot for every event.
+            this.#broken = true;
+        }
+    }
+    #rotateIfNeeded(file) {
+        try {
+            const size = statSync(file).size;
+            if (size >= this.#maxBytes)
+                renameSync(file, `${file}.1`);
+        }
+        catch {
+            // No existing file (or stat failed): nothing to rotate.
+        }
+    }
+}

package/dist/process.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The process runtime drivers build on, re-exported so a driver package
+ * depends only on `@velum-labs/routekit-harness-core`: allowlisted child envs, capture
+ * runs with group-kill + SIGTERM->SIGKILL escalation, logged long-lived
+ * children, readiness helpers, and port allocation.
+ */
+export { buildChildEnv, freePort, runCliCapture, spawnLogged, terminate, waitForHttp, waitForOutput, withDeadline, withTimeout } from "@velum-labs/routekit-runtime";
+export type { BuildChildEnvInput, CliCaptureOptions, CliCaptureResult, LoggedChild, LoggedSpawnOptions } from "@velum-labs/routekit-runtime";

package/dist/process.js

@@ -0,0 +1,7 @@
+/**
+ * The process runtime drivers build on, re-exported so a driver package
+ * depends only on `@velum-labs/routekit-harness-core`: allowlisted child envs, capture
+ * runs with group-kill + SIGTERM->SIGKILL escalation, logged long-lived
+ * children, readiness helpers, and port allocation.
+ */
+export { buildChildEnv, freePort, runCliCapture, spawnLogged, terminate, waitForHttp, waitForOutput, withDeadline, withTimeout } from "@velum-labs/routekit-runtime";

package/dist/registry.d.ts

@@ -0,0 +1,19 @@
+import type { AnyHarnessDriver, DriverContext, HarnessInstance } from "./contract.js";
+import type { HarnessKind } from "./kinds.js";
+/**
+ * Explicit driver registry: drivers are registered by the composition root
+ * (CLI entrypoint, test setup), never via module-import side effects or
+ * mutable module-level globals.
+ */
+export declare class DriverRegistry {
+    #private;
+    register(driver: AnyHarnessDriver): this;
+    get(kind: HarnessKind): AnyHarnessDriver | undefined;
+    list(): readonly AnyHarnessDriver[];
+    /**
+     * Decode the raw config through the driver's own schema (exactly once,
+     * here) and create an instance. Unknown kinds and config decode failures
+     * are classified `HarnessError`s, not bare throws.
+     */
+    createInstance(kind: HarnessKind, rawConfig: unknown, context?: DriverContext): Promise<HarnessInstance>;
+}

package/dist/registry.js

@@ -0,0 +1,38 @@
+import { HarnessError } from "./errors.js";
+/**
+ * Explicit driver registry: drivers are registered by the composition root
+ * (CLI entrypoint, test setup), never via module-import side effects or
+ * mutable module-level globals.
+ */
+export class DriverRegistry {
+    #drivers = new Map();
+    register(driver) {
+        if (this.#drivers.has(driver.kind)) {
+            throw new Error(`harness driver already registered for kind "${driver.kind}"`);
+        }
+        this.#drivers.set(driver.kind, driver);
+        return this;
+    }
+    get(kind) {
+        return this.#drivers.get(kind);
+    }
+    list() {
+        return [...this.#drivers.values()];
+    }
+    /**
+     * Decode the raw config through the driver's own schema (exactly once,
+     * here) and create an instance. Unknown kinds and config decode failures
+     * are classified `HarnessError`s, not bare throws.
+     */
+    async createInstance(kind, rawConfig, context) {
+        const driver = this.#drivers.get(kind);
+        if (driver === undefined) {
+            throw new HarnessError("invalid_config", `no harness driver registered for kind "${kind}"`);
+        }
+        const decoded = driver.configSchema.safeParse(rawConfig);
+        if (!decoded.success) {
+            throw new HarnessError("invalid_config", `invalid ${kind} driver config: ${decoded.error.message}`, { cause: decoded.error });
+        }
+        return driver.createInstance(decoded.data, context);
+    }
+}

package/dist/status.d.ts

@@ -0,0 +1,36 @@
+import type { HarnessKind } from "./kinds.js";
+export type HarnessAuthStatus = "authenticated" | "unauthenticated" | "unknown";
+export type HarnessModelDescriptor = {
+    id: string;
+    displayName?: string;
+};
+/**
+ * The probed state of one harness CLI: installed / version / auth / models.
+ * Consumed by diagnostics and readiness checks (skip with an actionable reason
+ * before any spend), and the front-door launchers.
+ */
+export type HarnessStatus = {
+    kind: HarnessKind;
+    installed: boolean;
+    /** The resolved command the probe ran (when installed). */
+    command?: string;
+    version?: string;
+    auth: {
+        status: HarnessAuthStatus;
+        detail?: string;
+    };
+    models?: HarnessModelDescriptor[];
+    checkedAt: string;
+    /** Why the probe itself failed, when it did (distinct from "not installed"). */
+    probeError?: string;
+};
+export declare const DEFAULT_STATUS_CACHE_DIR: string;
+/**
+ * Read a cached status snapshot. The payload's own `kind` must match the
+ * requested kind — the filename alone is never trusted as a routing key.
+ */
+export declare function readCachedStatus(kind: HarnessKind, cacheDir?: string): HarnessStatus | undefined;
+/** Persist a status snapshot atomically (write temp + rename). */
+export declare function writeCachedStatus(status: HarnessStatus, cacheDir?: string): void;
+/** An actionable skip reason when the status is not runnable, else undefined. */
+export declare function statusSkipReason(status: HarnessStatus): string | undefined;

package/dist/status.js

@@ -0,0 +1,49 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { isHarnessKind } from "./kinds.js";
+export const DEFAULT_STATUS_CACHE_DIR = join(homedir(), ".routekit", "harness-status");
+/**
+ * Read a cached status snapshot. The payload's own `kind` must match the
+ * requested kind — the filename alone is never trusted as a routing key.
+ */
+export function readCachedStatus(kind, cacheDir = DEFAULT_STATUS_CACHE_DIR) {
+    try {
+        const raw = readFileSync(join(cacheDir, `${kind}.json`), "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null)
+            return undefined;
+        if (!isHarnessKind(parsed.kind) || parsed.kind !== kind)
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Persist a status snapshot atomically (write temp + rename). */
+export function writeCachedStatus(status, cacheDir = DEFAULT_STATUS_CACHE_DIR) {
+    mkdirSync(cacheDir, { recursive: true });
+    const target = join(cacheDir, `${status.kind}.json`);
+    const temp = join(tmpdir(), `harness-status-${randomUUID()}.json`);
+    writeFileSync(temp, `${JSON.stringify(status, null, 2)}\n`);
+    try {
+        renameSync(temp, target);
+    }
+    catch {
+        // Cross-device rename fallback: write directly (still a single syscall
+        // for the small payload).
+        writeFileSync(target, `${JSON.stringify(status, null, 2)}\n`);
+    }
+}
+/** An actionable skip reason when the status is not runnable, else undefined. */
+export function statusSkipReason(status) {
+    if (!status.installed) {
+        return status.probeError ?? `${status.kind} CLI is not installed or not on PATH.`;
+    }
+    if (status.auth.status === "unauthenticated") {
+        return status.auth.detail ?? `${status.kind} CLI is installed but not logged in.`;
+    }
+    return undefined;
+}

package/dist/stream-json.d.ts

@@ -0,0 +1,38 @@
+export declare const STREAM_JSON_MAX_TEXT = 4000;
+export declare const STREAM_JSON_MAX_TOOL_INPUT = 600;
+export type StreamJsonStepText = {
+    text?: string;
+};
+export type StreamJsonEmitterOptions<Step extends StreamJsonStepText> = {
+    stepsForEvent: (event: Record<string, unknown>) => Step[];
+    resultStep: (result: string) => Step;
+    onStep: (step: Step & {
+        index: number;
+    }) => void;
+};
+export type ParseStreamJsonOptions<Step extends StreamJsonStepText> = {
+    stdout: string;
+    stepsForEvent: (event: Record<string, unknown>) => Step[];
+    resultStep: (result: string) => Step;
+    fallbackText?: (step: Step & {
+        index: number;
+    }) => string | undefined;
+};
+export type ParsedStreamJson<Step extends StreamJsonStepText> = {
+    steps: Array<Step & {
+        index: number;
+    }>;
+    finalOutput: string;
+    sawResult: boolean;
+    isError: boolean;
+};
+export declare function truncateStreamJsonText(text: string, limit: number): string;
+export declare function asObject(value: unknown): Record<string, unknown> | undefined;
+export declare function asArray(value: unknown): unknown[];
+export declare function asString(value: unknown): string | undefined;
+export declare function stringifyStreamJsonValue(value: unknown): string;
+/** A tool_result `content` is either a string or an array of text/parts. */
+export declare function streamJsonResultContentText(content: unknown): string;
+export declare function parseStreamJsonLine(line: string): Record<string, unknown> | undefined;
+export declare function createStreamJsonStepEmitter<Step extends StreamJsonStepText>(options: StreamJsonEmitterOptions<Step>): (line: string) => void;
+export declare function parseStreamJsonTrajectory<Step extends StreamJsonStepText>(options: ParseStreamJsonOptions<Step>): ParsedStreamJson<Step>;

package/dist/stream-json.js

@@ -0,0 +1,120 @@
+export const STREAM_JSON_MAX_TEXT = 4000;
+export const STREAM_JSON_MAX_TOOL_INPUT = 600;
+export function truncateStreamJsonText(text, limit) {
+    return text.length <= limit ? text : `${text.slice(0, limit)}...[truncated]`;
+}
+export function asObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+export function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function stringifyStreamJsonValue(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+/** A tool_result `content` is either a string or an array of text/parts. */
+export function streamJsonResultContentText(content) {
+    const direct = asString(content);
+    if (direct !== undefined)
+        return direct;
+    return asArray(content)
+        .map((part) => {
+        const obj = asObject(part);
+        if (obj === undefined)
+            return "";
+        if (obj.type === "text")
+            return asString(obj.text) ?? "";
+        return "";
+    })
+        .filter((text) => text.length > 0)
+        .join("");
+}
+export function parseStreamJsonLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed[0] !== "{")
+        return undefined;
+    let event;
+    try {
+        event = JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+    return asObject(event);
+}
+export function createStreamJsonStepEmitter(options) {
+    let index = 0;
+    let lastText = "";
+    const push = (step) => {
+        const indexed = { index, ...step };
+        index += 1;
+        if (indexed.text !== undefined)
+            lastText = indexed.text;
+        options.onStep(indexed);
+    };
+    return (line) => {
+        const obj = parseStreamJsonLine(line);
+        if (obj === undefined)
+            return;
+        if (asString(obj.type) === "result") {
+            const result = asString(obj.result);
+            if (result !== undefined && result.length > 0 && lastText !== result) {
+                push(options.resultStep(result));
+            }
+            return;
+        }
+        for (const step of options.stepsForEvent(obj))
+            push(step);
+    };
+}
+export function parseStreamJsonTrajectory(options) {
+    const steps = [];
+    let finalOutput = "";
+    let sawResult = false;
+    let isError = false;
+    const push = (step) => {
+        steps.push({ index: steps.length, ...step });
+    };
+    for (const line of options.stdout.split("\n")) {
+        const obj = parseStreamJsonLine(line);
+        if (obj === undefined)
+            continue;
+        if (asString(obj.type) === "result") {
+            sawResult = true;
+            if (obj.is_error === true)
+                isError = true;
+            const result = asString(obj.result);
+            if (result !== undefined && result.length > 0)
+                finalOutput = result;
+            continue;
+        }
+        for (const step of options.stepsForEvent(obj))
+            push(step);
+    }
+    if (finalOutput.length === 0) {
+        for (let i = steps.length - 1; i >= 0; i -= 1) {
+            const step = steps[i];
+            const text = step !== undefined ? (options.fallbackText?.(step) ?? step.text) : undefined;
+            if (text !== undefined && text.length > 0) {
+                finalOutput = text;
+                break;
+            }
+        }
+    }
+    else if (steps.at(-1)?.text !== finalOutput) {
+        push(options.resultStep(finalOutput));
+    }
+    return { steps, finalOutput, sawResult, isError };
+}

package/dist/test/harness-core.test.d.ts

@@ -0,0 +1 @@
+export {};