@zq-silk/yui 0.6.0 → 0.6.2

package/dist/resources/resourceRegistrar.js

@@ -0,0 +1,256 @@
+/**
+ * Immediate Resource registry instrumentation (Issue 10).
+ *
+ * Every Yui-created workspace/runtime path is registered in the same
+ * controlled step that creates it. Discovery remains the authority for
+ * historical resources, but these receipts let GC prove ownership for
+ * registry-only paths such as `/tmp/yi-*` integration runtimes.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import { createResourceRegistryStore } from "./resourceRegistryStore.js";
+import { upsertResourceRecord } from "./resourceRegistry.js";
+import { createResourceRecord, isReleaseNamespacePath, resourceId } from "./resourceTypes.js";
+export class ResourceRegistrar {
+    #home;
+    #now;
+    constructor(home, now = () => new Date()) {
+        this.#home = resolve(home);
+        this.#now = now;
+    }
+    registerManagedWorkspace(workspace) {
+        try {
+            this.#registerManagedWorkspace(workspace);
+        }
+        catch {
+            // A failed registry receipt must never block workspace creation.
+            // Discovery remains the authority for historical resources.
+        }
+    }
+    #registerManagedWorkspace(workspace) {
+        const records = [];
+        const root = resolve(workspace.root);
+        if (existsSync(root)
+            && !workspace.entries.some((entry) => resolve(entry.path) === root)
+            && !isReleaseNamespacePath(this.#home, root)) {
+            records.push(this.#record({
+                kind: "runtime-artifact",
+                path: root,
+                owner: ownerFromManagedWorkspace(this.#home, workspace.owner),
+                cleanliness: "n/a"
+            }));
+        }
+        for (const entry of workspace.entries) {
+            if (entry.access !== "write")
+                continue;
+            const path = resolve(entry.path);
+            if (!existsSync(path) || isReleaseNamespacePath(this.#home, path))
+                continue;
+            records.push(this.#record({
+                kind: "worktree",
+                path,
+                owner: ownerFromManagedWorkspace(this.#home, workspace.owner, entry.projectId),
+                git: readGitWorktreeMetadata(path),
+                cleanliness: readGitWorktreeCleanliness(path)
+            }));
+        }
+        this.#save(records);
+    }
+    registerTaskRuntimeIsolation(descriptor) {
+        try {
+            this.#registerTaskRuntimeIsolation(descriptor);
+        }
+        catch {
+            // Best-effort receipt; runtime isolation must proceed regardless.
+        }
+    }
+    #registerTaskRuntimeIsolation(descriptor) {
+        const owner = ownerFromManagedWorkspace(this.#home, descriptor.workspace.owner);
+        this.#save([
+            descriptor.roots.generation,
+            descriptor.roots.data,
+            descriptor.roots.cache,
+            descriptor.roots.temporary
+        ].filter((path, index, paths) => paths.indexOf(path) === index && existsSync(path))
+            .map((path) => this.#record({
+            kind: "runtime-artifact",
+            path: resolve(path),
+            owner,
+            cleanliness: "n/a"
+        })));
+    }
+    registerExactTaskRuntimeDescriptor(descriptor, sourcePath) {
+        try {
+            this.#registerExactTaskRuntimeDescriptor(descriptor, sourcePath);
+        }
+        catch {
+            // Best-effort receipt; descriptor writes must proceed regardless.
+        }
+    }
+    #registerExactTaskRuntimeDescriptor(descriptor, sourcePath) {
+        const path = resolve(sourcePath);
+        if (!existsSync(path) || isReleaseNamespacePath(this.#home, path))
+            return;
+        this.#save([this.#record({
+                kind: "runtime-artifact",
+                path,
+                owner: {
+                    home: this.#home,
+                    taskId: descriptor.taskId,
+                    basis: "descriptor"
+                },
+                cleanliness: "n/a"
+            })]);
+    }
+    registerSessionContext(path, owner) {
+        try {
+            this.#registerSessionContext(path, owner);
+        }
+        catch {
+            // Best-effort receipt; session launch must proceed regardless.
+        }
+    }
+    #registerSessionContext(path, owner) {
+        const resolved = resolve(path);
+        if (!existsSync(resolved) || isReleaseNamespacePath(this.#home, resolved))
+            return;
+        this.#save([this.#record({
+                kind: "runtime-artifact",
+                path: resolved,
+                owner,
+                cleanliness: "n/a"
+            })]);
+    }
+    markWorkspaceDeleted(workspace) {
+        try {
+            this.markPathsDeleted([
+                workspace.root,
+                ...workspace.entries.map((entry) => entry.path)
+            ]);
+        }
+        catch {
+            // Best-effort receipt; workspace deletion must proceed regardless.
+        }
+    }
+    markPathsDeleted(paths) {
+        try {
+            this.#markPathsDeleted(paths);
+        }
+        catch {
+            // Best-effort receipt; path deletion must proceed regardless.
+        }
+    }
+    #markPathsDeleted(paths) {
+        const targets = new Set(paths.map((path) => resolve(path)));
+        const store = createResourceRegistryStore(this.#home);
+        try {
+            const state = store.load();
+            let next = state;
+            const timestamp = this.#now().toISOString();
+            for (const record of Object.values(state.records)) {
+                if (!targets.has(record.path) || record.disposition === "deleted")
+                    continue;
+                next = upsertResourceRecord(next, {
+                    ...record,
+                    activeRefs: Object.freeze([]),
+                    disposition: "deleted",
+                    blocker: undefined,
+                    quarantine: undefined,
+                    cleanupReceipt: {
+                        removedAt: timestamp,
+                        method: record.kind === "worktree" ? "git-worktree-remove" : "runtime-cleanup"
+                    },
+                    updatedAt: timestamp
+                });
+            }
+            if (next !== state)
+                store.save(next);
+        }
+        finally {
+            store.close();
+        }
+    }
+    #record(input) {
+        const timestamp = this.#now();
+        const store = createResourceRegistryStore(this.#home);
+        let existing;
+        try {
+            existing = store.load().records[resourceId(input.kind, input.path)];
+        }
+        finally {
+            store.close();
+        }
+        return createResourceRecord({
+            kind: input.kind,
+            path: input.path,
+            owner: input.owner,
+            ...(input.git === undefined ? {} : { git: input.git }),
+            ...(existing?.createdAt === undefined ? {} : { createdAt: existing.createdAt }),
+            lastReferencedAt: timestamp.toISOString(),
+            cleanliness: input.cleanliness,
+            activeRefs: [],
+            disposition: "active"
+        }, timestamp);
+    }
+    #save(records) {
+        if (records.length === 0)
+            return;
+        const store = createResourceRegistryStore(this.#home);
+        try {
+            let state = store.load();
+            for (const record of records)
+                state = upsertResourceRecord(state, record);
+            store.save(state);
+        }
+        finally {
+            store.close();
+        }
+    }
+}
+function ownerFromManagedWorkspace(home, owner, projectId) {
+    return {
+        home,
+        ...(projectId === undefined ? {} : { projectId }),
+        taskId: owner.taskId,
+        ...(owner.type === "work-item" ? { workItemId: owner.workItemId } : {}),
+        ...(owner.type === "review-round" ? { reviewRoundId: owner.reviewRoundId } : {}),
+        ...(owner.type === "integration-attempt"
+            ? { integrationAttemptId: owner.integrationAttemptId }
+            : {}),
+        ...(owner.type === "execution-lane" && owner.workItemId !== undefined
+            ? { workItemId: owner.workItemId }
+            : {}),
+        ...(owner.type === "execution-lane" && owner.reviewRoundId !== undefined
+            ? { reviewRoundId: owner.reviewRoundId }
+            : {}),
+        basis: "durable-record"
+    };
+}
+function readGitWorktreeMetadata(path) {
+    const commonDir = execFileSync("git", ["-C", path, "rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const repositoryPath = basename(commonDir) === ".git" ? dirname(commonDir) : commonDir;
+    let branch;
+    try {
+        branch = execFileSync("git", ["-C", path, "symbolic-ref", "--quiet", "--short", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        branch = undefined;
+    }
+    const head = execFileSync("git", ["-C", path, "rev-parse", "HEAD^{commit}"], { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return {
+        repositoryPath,
+        commonDir,
+        ...(branch === undefined || branch === "" ? {} : { branch }),
+        head
+    };
+}
+function readGitWorktreeCleanliness(path) {
+    try {
+        const status = execFileSync("git", ["-C", path, "status", "--porcelain=v1", "--untracked-files=all"], { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+        return status.length > 0 ? "dirty" : "clean";
+    }
+    catch {
+        return "unknown";
+    }
+}

package/dist/resources/resourceRegistry.js

@@ -0,0 +1,150 @@
+/**
+ * Persistent Resource registry (Issue 10).
+ *
+ * The registry is GC's own state.  When the Home is SQLite-backed it lives in
+ * the `resource_registry` table inside `yui.db`; otherwise it falls back to a
+ * JSON file at `$YUI_HOME/runtime/resource-registry/registry.json`.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { RESOURCE_REGISTRY_SCHEMA_VERSION } from "./resourceTypes.js";
+export const RESOURCE_REGISTRY_DIRECTORY = "resource-registry";
+export const RESOURCE_REGISTRY_FILE = "registry.json";
+export const RESOURCE_QUARANTINE_DIRECTORY = "quarantine";
+export function resourceRegistryPath(home) {
+    return join(resolve(home), "runtime", RESOURCE_REGISTRY_DIRECTORY, RESOURCE_REGISTRY_FILE);
+}
+export function resourceQuarantineRoot(home) {
+    return join(resolve(home), "runtime", RESOURCE_REGISTRY_DIRECTORY, RESOURCE_QUARANTINE_DIRECTORY);
+}
+/** True when `path` lives in this Home's Resource GC quarantine namespace. */
+export function isResourceQuarantinePath(home, path) {
+    const root = resolve(resourceQuarantineRoot(home));
+    const resolved = resolve(path);
+    return resolved === root || resolved.startsWith(`${root}/`);
+}
+export function emptyResourceRegistry() {
+    return Object.freeze({
+        schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
+        records: Object.freeze({})
+    });
+}
+/**
+ * Load the registry. A missing registry is an empty Home. A corrupt or
+ * unreadable registry fails closed: GC must never invent ownership from a
+ * corrupt registry, and silently dropping quarantine receipts could let a
+ * resource be released twice.
+ */
+export function loadResourceRegistry(home) {
+    const path = resourceRegistryPath(home);
+    if (!existsSync(path))
+        return emptyResourceRegistry();
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Resource registry is corrupt or unreadable at ${path}: `
+            + `${error instanceof Error ? error.message : "unknown error"}. `
+            + "Fix or remove the registry file before running GC.", { cause: error });
+    }
+    return parseResourceRegistryState(parsed);
+}
+export function saveResourceRegistry(home, state) {
+    const path = resourceRegistryPath(home);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.tmp-${process.pid}`;
+    writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temporary, path);
+}
+export function upsertResourceRecord(state, record) {
+    return Object.freeze({
+        schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
+        records: Object.freeze({ ...state.records, [record.id]: Object.freeze(record) })
+    });
+}
+export function removeResourceRecord(state, id) {
+    if (!(id in state.records))
+        return state;
+    const records = { ...state.records };
+    delete records[id];
+    return Object.freeze({
+        schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
+        records: Object.freeze(records)
+    });
+}
+export function listResourceRecords(state) {
+    return Object.values(state.records);
+}
+export function parseResourceRegistryState(value) {
+    if (typeof value !== "object" || value === null) {
+        throw new Error("Resource registry root is not an object.");
+    }
+    const record = value;
+    if (record.schemaVersion !== RESOURCE_REGISTRY_SCHEMA_VERSION) {
+        throw new Error(`Resource registry schemaVersion is ${String(record.schemaVersion)}; `
+            + `expected ${RESOURCE_REGISTRY_SCHEMA_VERSION}.`);
+    }
+    if (typeof record.records !== "object" || record.records === null) {
+        throw new Error("Resource registry records is not an object.");
+    }
+    const records = {};
+    for (const [key, entry] of Object.entries(record.records)) {
+        const parsed = parseResourceRecord(entry);
+        if (parsed === undefined) {
+            throw new Error(`Resource registry record ${key} is malformed.`);
+        }
+        if (parsed.id !== key) {
+            throw new Error(`Resource registry record key ${key} does not match id ${parsed.id}.`);
+        }
+        records[key] = parsed;
+    }
+    return Object.freeze({
+        schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
+        records: Object.freeze(records)
+    });
+}
+function parseResourceRecord(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const record = value;
+    if (record.schemaVersion !== RESOURCE_REGISTRY_SCHEMA_VERSION)
+        return undefined;
+    if (typeof record.id !== "string" || typeof record.kind !== "string"
+        || typeof record.path !== "string" || typeof record.disposition !== "string"
+        || typeof record.updatedAt !== "string") {
+        return undefined;
+    }
+    if (!Number.isFinite(Date.parse(record.updatedAt)))
+        return undefined;
+    if (typeof record.owner !== "object" || record.owner === null)
+        return undefined;
+    const owner = record.owner;
+    if (typeof owner.home !== "string" || typeof owner.basis !== "string") {
+        return undefined;
+    }
+    return Object.freeze({
+        schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
+        id: record.id,
+        kind: record.kind,
+        path: record.path,
+        owner: Object.freeze({ ...owner }),
+        ...(record.git === undefined ? {} : { git: record.git }),
+        ...(typeof record.createdAt === "string" ? { createdAt: record.createdAt } : {}),
+        ...(typeof record.lastReferencedAt === "string"
+            ? { lastReferencedAt: record.lastReferencedAt }
+            : {}),
+        ...(typeof record.sizeBytes === "number" ? { sizeBytes: record.sizeBytes } : {}),
+        cleanliness: (record.cleanliness ?? "unknown"),
+        activeRefs: Array.isArray(record.activeRefs)
+            ? Object.freeze(record.activeRefs.filter((ref) => typeof ref === "string"))
+            : Object.freeze([]),
+        disposition: record.disposition,
+        ...(typeof record.blocker === "string" ? { blocker: record.blocker } : {}),
+        ...(record.quarantine === undefined ? {} : { quarantine: record.quarantine }),
+        ...(record.cleanupReceipt === undefined
+            ? {}
+            : { cleanupReceipt: record.cleanupReceipt }),
+        updatedAt: record.updatedAt
+    });
+}

package/dist/resources/resourceRegistryStore.js

@@ -0,0 +1,41 @@
+/**
+ * Resource registry store abstraction (Issue 10, DB-only optimal).
+ *
+ * The GC engine depends on this interface, not on a specific storage backend.
+ * When the Home is SQLite-backed the registry lives in the `resource_registry`
+ * table inside `yui.db`; otherwise it falls back to a JSON file.
+ */
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { loadResourceRegistry, saveResourceRegistry } from "./resourceRegistry.js";
+import { SqliteResourceRegistry } from "./sqliteResourceRegistry.js";
+/**
+ * JSON-file-backed registry store (File-store Homes).
+ */
+export class FileResourceRegistryStore {
+    #home;
+    constructor(home) {
+        this.#home = home;
+    }
+    load() {
+        return loadResourceRegistry(this.#home);
+    }
+    save(state) {
+        saveResourceRegistry(this.#home, state);
+    }
+    close() {
+        // No persistent connection to close.
+    }
+}
+/**
+ * Create the appropriate registry store for a Home.
+ *
+ * SQLite-backed Homes use the `resource_registry` table in `yui.db`;
+ * File-store Homes fall back to the JSON file.
+ */
+export function createResourceRegistryStore(home) {
+    if (existsSync(join(home, "yui.db"))) {
+        return new SqliteResourceRegistry(home);
+    }
+    return new FileResourceRegistryStore(home);
+}

package/dist/resources/resourceTypes.js

@@ -0,0 +1,42 @@
+/**
+ * Resource GC data model (Issue 10).
+ *
+ * A Resource record describes one disk object Yui created — a managed Git
+ * worktree, a deployment, or a runtime artifact — together with everything GC
+ * needs to decide whether it may be released. The registry is GC's own state;
+ * it never owns the resource lifecycle of another Issue.
+ */
+import { createHash } from "node:crypto";
+import { relative, resolve } from "node:path";
+export const RESOURCE_REGISTRY_SCHEMA_VERSION = 1;
+/** Stable record identity: the same kind+path always maps to the same id. */
+export function resourceId(kind, path) {
+    return createHash("sha256").update(`${kind}\u0000${path}`).digest("hex").slice(0, 16);
+}
+export function createResourceRecord(input, now) {
+    return Object.freeze({
+        schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
+        id: resourceId(input.kind, input.path),
+        ...input,
+        updatedAt: now.toISOString()
+    });
+}
+/** A resource may be quarantined only when every live reference is gone. */
+export function isReleasable(record) {
+    return record.disposition === "releasable"
+        && record.activeRefs.length === 0
+        && record.cleanliness !== "dirty"
+        && record.cleanliness !== "unknown";
+}
+/** Terminal Task statuses: a terminal owner keeps no active runtime claim. */
+export function isTerminalTaskStatus(status) {
+    return status === "completed" || status === "retired" || status === "archived";
+}
+/**
+ * The immutable release namespace owned by the package installer (Issue 02).
+ * GC never registers, quarantines, or deletes anything below it.
+ */
+export function isReleaseNamespacePath(home, path) {
+    const rel = relative(resolve(home), resolve(path));
+    return rel === "runtime/releases" || rel.startsWith("runtime/releases/");
+}

package/dist/resources/sqliteResourceRegistry.js

@@ -0,0 +1,111 @@
+/**
+ * SQLite-backed Resource registry (Issue 10, DB-only optimal).
+ *
+ * When the Home is SQLite-backed (`yui.db` exists), the resource registry
+ * lives in the `resource_registry` table inside the same database.  This
+ * keeps GC state transactional, crash-safe, and queryable alongside the
+ * aggregate — no separate JSON file to corrupt or lose.
+ *
+ * The registry is GC's own state: it is not part of the aggregate and never
+ * participates in aggregate versioning.  The `resource_registry` table is
+ * created by schema migration 8.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import { RESOURCE_REGISTRY_SCHEMA_VERSION } from "./resourceTypes.js";
+import { emptyResourceRegistry, parseResourceRegistryState } from "./resourceRegistry.js";
+import { migrateSqliteSchema } from "../storage/sqliteSchema.js";
+export const SQLITE_RESOURCE_REGISTRY_TABLE = "resource_registry";
+/**
+ * A SQLite-backed resource registry store.  Each `save` is a single
+ * transaction that upserts every record and removes rows that disappeared
+ * from the in-memory state, so the on-disk table always matches the state
+ * the GC engine computed.
+ */
+export class SqliteResourceRegistry {
+    #db;
+    constructor(home) {
+        const dbPath = join(home, "yui.db");
+        if (!existsSync(dbPath)) {
+            throw new Error(`SQLite database not found at ${dbPath}`);
+        }
+        this.#db = new Database(dbPath);
+        this.#db.pragma("journal_mode = WAL");
+        this.#db.pragma("foreign_keys = ON");
+        this.#db.pragma("busy_timeout = 5000");
+        migrateSqliteSchema(this.#db);
+    }
+    load() {
+        const rows = this.#db.prepare(`SELECT payload FROM ${SQLITE_RESOURCE_REGISTRY_TABLE}`).all();
+        if (rows.length === 0)
+            return emptyResourceRegistry();
+        const records = {};
+        for (const row of rows) {
+            let parsed;
+            try {
+                parsed = JSON.parse(row.payload);
+            }
+            catch (error) {
+                throw new Error(`SQLite resource registry has a corrupt payload: `
+                    + `${error instanceof Error ? error.message : "unknown error"}.`, { cause: error });
+            }
+            const state = parseResourceRegistryState({
+                schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
+                records: { [typeof parsed === "object" && parsed !== null && "id" in parsed
+                        ? String(parsed.id)
+                        : ""]: parsed }
+            });
+            Object.assign(records, state.records);
+        }
+        return Object.freeze({
+            schemaVersion: RESOURCE_REGISTRY_SCHEMA_VERSION,
+            records: Object.freeze(records)
+        });
+    }
+    save(state) {
+        const upsert = this.#db.prepare(`INSERT INTO ${SQLITE_RESOURCE_REGISTRY_TABLE}
+         (id, kind, path, disposition, task_id, payload, created_at, updated_at)
+       VALUES
+         (@id, @kind, @path, @disposition, @task_id, @payload, @created_at, @updated_at)
+       ON CONFLICT(id) DO UPDATE SET
+         kind = excluded.kind,
+         path = excluded.path,
+         disposition = excluded.disposition,
+         task_id = excluded.task_id,
+         payload = excluded.payload,
+         updated_at = excluded.updated_at`);
+        const remove = this.#db.prepare(`DELETE FROM ${SQLITE_RESOURCE_REGISTRY_TABLE} WHERE id = ?`);
+        const existingRows = this.#db.prepare(`SELECT id FROM ${SQLITE_RESOURCE_REGISTRY_TABLE}`).all();
+        const existingIds = new Set(existingRows.map((row) => row.id));
+        const currentIds = new Set(Object.keys(state.records));
+        const tx = this.#db.transaction(() => {
+            for (const record of Object.values(state.records)) {
+                upsert.run({
+                    id: record.id,
+                    kind: record.kind,
+                    path: record.path,
+                    disposition: record.disposition,
+                    task_id: record.owner.taskId ?? null,
+                    payload: JSON.stringify(record),
+                    created_at: record.createdAt ?? record.updatedAt,
+                    updated_at: record.updatedAt
+                });
+            }
+            for (const id of existingIds) {
+                if (!currentIds.has(id))
+                    remove.run(id);
+            }
+        });
+        tx();
+    }
+    close() {
+        this.#db.close();
+    }
+}
+/**
+ * Detect whether a Home uses SQLite storage (yui.db exists).
+ */
+export function isSqliteHome(home) {
+    return existsSync(join(home, "yui.db"));
+}

package/dist/review/reviewConfig.js

@@ -1,5 +1,11 @@
 import { requireIdentity } from "../domain/validation.js";
 export const REVIEW_TRIGGERS = ["always", "leader", "final"];
+/**
+ * Issue 06 feature flag. `shadow` records the finding ledger and serves Leader
+ * commands without changing completion behavior; `enforce` additionally fails
+ * Task completion closed on undispositioned open P1/P2 findings.
+ */
+export const REVIEW_FINDING_LEDGER_MODES = ["shadow", "enforce"];
 /** The Reviewer Role seeded in a new Home by `yui setup`. */
 export const DEFAULT_REVIEWER_ROLE = "reviewer";
 export function validateReviewConfig(config) {
@@ -7,5 +13,9 @@ export function validateReviewConfig(config) {
     if (!REVIEW_TRIGGERS.includes(config.trigger)) {
         throw new Error(`Review trigger is invalid: ${String(config.trigger)}.`);
     }
+    if (config.findingLedger !== undefined
+        && !REVIEW_FINDING_LEDGER_MODES.includes(config.findingLedger)) {
+        throw new Error(`Review finding ledger mode is invalid: ${String(config.findingLedger)}.`);
+    }
     return config;
 }