agent-scenario-loop 0.1.0

package/dist/core/ports.d.ts

@@ -0,0 +1,198 @@
+declare const PRIMARY_RUNNER_PORT: string[];
+declare const EVIDENCE_PROVIDER_PORT: string[];
+declare const DRIVER_PORT: string[];
+declare const ARTIFACT_WRITER_PORT: string[];
+declare const INTERPRETER_PORT: string[];
+type ScenarioExecutionStep = import('./execution-plan').ScenarioExecutionStep;
+type MaybePromise<T> = T | Promise<T>;
+type PortMetadataValue = string | number | boolean | null | string[] | number[] | boolean[];
+type PortMetadata = Record<string, PortMetadataValue>;
+type PortStatus = 'passed' | 'failed' | 'partial' | 'skipped';
+type PortArtifactMap = Record<string, string | string[] | null>;
+type PortResult = {
+    artifacts?: PortArtifactMap;
+    message?: string;
+    metadata?: PortMetadata;
+    status: PortStatus;
+};
+type PortContext = {
+    artifactRoot?: string;
+    config?: Record<string, unknown>;
+    metadata?: PortMetadata;
+    platform: string;
+    runDir?: string;
+    runId: string;
+    runner?: Record<string, unknown>;
+    scenario?: Record<string, unknown>;
+    scenarioId: string;
+};
+type PrimaryRunnerContext = PortContext & {
+    executionPlan?: {
+        steps: ScenarioExecutionStep[];
+    };
+};
+type PrimaryRunnerStepContext = PrimaryRunnerContext & {
+    step: ScenarioExecutionStep;
+};
+type EvidenceProviderPhase = 'prepare' | 'startWindow' | 'capture' | 'stopWindow' | 'finalize';
+type EvidenceProviderContext = PortContext & {
+    phase?: EvidenceProviderPhase;
+    provider?: Record<string, unknown>;
+    providerId?: string;
+};
+type DriverActionName = 'tap' | 'scroll' | 'assertVisible' | 'inspectTree' | 'screenshot' | 'record' | 'readLogs' | 'collectPerfSignals';
+type DriverActionInput = {
+    action: string;
+    artifactPath?: string;
+    metadata?: PortMetadata;
+    platform: string;
+    selector?: Record<string, unknown>;
+    step?: ScenarioExecutionStep;
+    timeoutMs?: number;
+};
+type DriverActionResult = PortResult & {
+    outputPath?: string;
+    value?: unknown;
+};
+type ArtifactWriterJsonInput = {
+    filePath: string;
+    label?: string;
+    schema?: unknown;
+    value: unknown;
+};
+type ArtifactWriterTextInput = {
+    content: string;
+    filePath: string;
+};
+type ArtifactWriterCopyInput = {
+    destinationPath: string;
+    sourcePath: string;
+};
+type InterpreterContext = {
+    comparison?: Record<string, unknown>;
+    evidence: Record<string, unknown>;
+    metadata?: PortMetadata;
+    profile?: Record<string, unknown>;
+    scenarioHealthPassed: boolean;
+};
+type InterpreterResult = {
+    likelyCauses: string[];
+    metadata?: PortMetadata;
+    notes: string[];
+    summary: string;
+    trusted: boolean;
+};
+type PrimaryRunnerPort = {
+    captureEvidence(context: PrimaryRunnerStepContext): MaybePromise<PortResult>;
+    executeStep(context: PrimaryRunnerStepContext): MaybePromise<PortResult>;
+    finalize(context: PrimaryRunnerContext): MaybePromise<PortResult>;
+    launch(context: PrimaryRunnerContext): MaybePromise<PortResult>;
+    prepare(context: PrimaryRunnerContext): MaybePromise<PortResult>;
+    startSession(context: PrimaryRunnerContext): MaybePromise<PortResult>;
+    stopSession(context: PrimaryRunnerContext): MaybePromise<PortResult>;
+    waitForTruthEvent(context: PrimaryRunnerStepContext): MaybePromise<PortResult>;
+};
+type EvidenceProviderPort = {
+    capture(context: EvidenceProviderContext): MaybePromise<PortResult>;
+    finalize(context: EvidenceProviderContext): MaybePromise<PortResult>;
+    prepare(context: EvidenceProviderContext): MaybePromise<PortResult>;
+    startWindow(context: EvidenceProviderContext): MaybePromise<PortResult>;
+    stopWindow(context: EvidenceProviderContext): MaybePromise<PortResult>;
+};
+type DriverPort = {
+    assertVisible(input: DriverActionInput): MaybePromise<DriverActionResult>;
+    collectPerfSignals(input: DriverActionInput): MaybePromise<DriverActionResult>;
+    inspectTree(input: DriverActionInput): MaybePromise<DriverActionResult>;
+    readLogs(input: DriverActionInput): MaybePromise<DriverActionResult>;
+    record(input: DriverActionInput): MaybePromise<DriverActionResult>;
+    screenshot(input: DriverActionInput): MaybePromise<DriverActionResult>;
+    scroll(input: DriverActionInput): MaybePromise<DriverActionResult>;
+    tap(input: DriverActionInput): MaybePromise<DriverActionResult>;
+};
+type ArtifactWriterPort = {
+    copyRaw(input: ArtifactWriterCopyInput): MaybePromise<string>;
+    writeJson(input: ArtifactWriterJsonInput): MaybePromise<void>;
+    writeText(input: ArtifactWriterTextInput): MaybePromise<void>;
+};
+type InterpreterPort = {
+    interpret(context: InterpreterContext): MaybePromise<InterpreterResult>;
+};
+/**
+ * Returns true when a scenario action maps to the stable driver port surface.
+ *
+ * @param {string} action
+ * @returns {boolean}
+ */
+declare function isDriverActionName(action: string): action is DriverActionName;
+/**
+ * Dispatches one normalized scenario driver action to a swappable driver.
+ *
+ * Runners should call this after planner compatibility has passed. The runtime
+ * guard still fails explicitly so missing adapter capabilities do not degrade
+ * into silent no-ops.
+ *
+ * @param {{driver: Partial<DriverPort> & Record<string, unknown>, input: DriverActionInput}} options
+ * @returns {Promise<DriverActionResult>}
+ */
+declare function dispatchDriverAction({ driver, input, }: {
+    driver: Partial<DriverPort> & PortImplementation;
+    input: DriverActionInput;
+}): Promise<DriverActionResult>;
+/**
+ * Returns method names missing from an implementation object.
+ *
+ * @param {Record<string, unknown>} implementation
+ * @param {string[]} requiredMethods
+ * @returns {string[]}
+ */
+declare function missingPortMethods(implementation: PortImplementation, requiredMethods: string[]): string[];
+/**
+ * Returns callable method names exposed by an implementation object.
+ *
+ * @param {Record<string, unknown>} implementation
+ * @returns {string[]}
+ */
+declare function implementedPortMethods(implementation: PortImplementation): string[];
+/**
+ * Builds a stable human-readable port validation message.
+ *
+ * @param {{name: string, missingMethods: string[]}} options
+ * @returns {string}
+ */
+declare function buildPortValidationMessage({ name, missingMethods, }: {
+    name: string;
+    missingMethods: string[];
+}): string;
+/**
+ * Validates whether an implementation satisfies a named port.
+ *
+ * @param {{name: string, implementation: Record<string, unknown>, requiredMethods: string[]}} options
+ * @returns {{valid: boolean, name: string, expectedMethods: string[], implementedMethods: string[], missingMethods: string[], message: string}}
+ */
+declare function validatePortImplementation({ name, implementation, requiredMethods, }: {
+    name: string;
+    implementation: PortImplementation;
+    requiredMethods: string[];
+}): PortValidationResult;
+/**
+ * Asserts that an implementation satisfies a named port.
+ *
+ * @param {{name: string, implementation: Record<string, unknown>, requiredMethods: string[]}} options
+ * @returns {Record<string, unknown>}
+ */
+declare function assertPortImplementation({ name, implementation, requiredMethods, }: {
+    name: string;
+    implementation: PortImplementation;
+    requiredMethods: string[];
+}): PortImplementation;
+export { ARTIFACT_WRITER_PORT, DRIVER_PORT, EVIDENCE_PROVIDER_PORT, INTERPRETER_PORT, PRIMARY_RUNNER_PORT, assertPortImplementation, buildPortValidationMessage, dispatchDriverAction, implementedPortMethods, isDriverActionName, missingPortMethods, validatePortImplementation, };
+export type { ArtifactWriterCopyInput, ArtifactWriterJsonInput, ArtifactWriterPort, ArtifactWriterTextInput, DriverActionName, DriverActionInput, DriverActionResult, DriverPort, EvidenceProviderContext, EvidenceProviderPhase, EvidenceProviderPort, InterpreterContext, InterpreterPort, InterpreterResult, MaybePromise, PortArtifactMap, PortContext, PortImplementation, PortMetadata, PortMetadataValue, PortResult, PortStatus, PrimaryRunnerContext, PrimaryRunnerPort, PrimaryRunnerStepContext, PortValidationResult, };
+type PortImplementation = Record<string, unknown>;
+type PortValidationResult = {
+    expectedMethods: string[];
+    implementedMethods: string[];
+    message: string;
+    missingMethods: string[];
+    valid: boolean;
+    name: string;
+};

package/dist/core/ports.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIMARY_RUNNER_PORT = exports.INTERPRETER_PORT = exports.EVIDENCE_PROVIDER_PORT = exports.DRIVER_PORT = exports.ARTIFACT_WRITER_PORT = void 0;
+exports.assertPortImplementation = assertPortImplementation;
+exports.buildPortValidationMessage = buildPortValidationMessage;
+exports.dispatchDriverAction = dispatchDriverAction;
+exports.implementedPortMethods = implementedPortMethods;
+exports.isDriverActionName = isDriverActionName;
+exports.missingPortMethods = missingPortMethods;
+exports.validatePortImplementation = validatePortImplementation;
+const PRIMARY_RUNNER_PORT = [
+    'prepare',
+    'launch',
+    'startSession',
+    'executeStep',
+    'waitForTruthEvent',
+    'captureEvidence',
+    'stopSession',
+    'finalize',
+];
+exports.PRIMARY_RUNNER_PORT = PRIMARY_RUNNER_PORT;
+const EVIDENCE_PROVIDER_PORT = [
+    'prepare',
+    'startWindow',
+    'capture',
+    'stopWindow',
+    'finalize',
+];
+exports.EVIDENCE_PROVIDER_PORT = EVIDENCE_PROVIDER_PORT;
+const DRIVER_PORT = [
+    'tap',
+    'scroll',
+    'assertVisible',
+    'inspectTree',
+    'screenshot',
+    'record',
+    'readLogs',
+    'collectPerfSignals',
+];
+exports.DRIVER_PORT = DRIVER_PORT;
+const ARTIFACT_WRITER_PORT = [
+    'writeJson',
+    'writeText',
+    'copyRaw',
+];
+exports.ARTIFACT_WRITER_PORT = ARTIFACT_WRITER_PORT;
+const INTERPRETER_PORT = [
+    'interpret',
+];
+exports.INTERPRETER_PORT = INTERPRETER_PORT;
+/**
+ * Returns true when a scenario action maps to the stable driver port surface.
+ *
+ * @param {string} action
+ * @returns {boolean}
+ */
+function isDriverActionName(action) {
+    return DRIVER_PORT.includes(action);
+}
+/**
+ * Dispatches one normalized scenario driver action to a swappable driver.
+ *
+ * Runners should call this after planner compatibility has passed. The runtime
+ * guard still fails explicitly so missing adapter capabilities do not degrade
+ * into silent no-ops.
+ *
+ * @param {{driver: Partial<DriverPort> & Record<string, unknown>, input: DriverActionInput}} options
+ * @returns {Promise<DriverActionResult>}
+ */
+async function dispatchDriverAction({ driver, input, }) {
+    if (!isDriverActionName(input.action)) {
+        throw new Error(`Unsupported driver action \`${input.action}\`.`);
+    }
+    const method = driver[input.action];
+    if (typeof method !== 'function') {
+        throw new Error(`Driver is missing action \`${input.action}\`.`);
+    }
+    return method(input);
+}
+/**
+ * Returns method names missing from an implementation object.
+ *
+ * @param {Record<string, unknown>} implementation
+ * @param {string[]} requiredMethods
+ * @returns {string[]}
+ */
+function missingPortMethods(implementation, requiredMethods) {
+    return requiredMethods.filter((methodName) => typeof implementation?.[methodName] !== 'function');
+}
+/**
+ * Returns callable method names exposed by an implementation object.
+ *
+ * @param {Record<string, unknown>} implementation
+ * @returns {string[]}
+ */
+function implementedPortMethods(implementation) {
+    if (!implementation || typeof implementation !== 'object') {
+        return [];
+    }
+    return Object.keys(implementation)
+        .filter((methodName) => typeof implementation[methodName] === 'function')
+        .sort();
+}
+/**
+ * Builds a stable human-readable port validation message.
+ *
+ * @param {{name: string, missingMethods: string[]}} options
+ * @returns {string}
+ */
+function buildPortValidationMessage({ name, missingMethods, }) {
+    if (missingMethods.length === 0) {
+        return `${name} satisfies the required port methods.`;
+    }
+    return `${name} is missing required method(s): ${missingMethods.join(', ')}`;
+}
+/**
+ * Validates whether an implementation satisfies a named port.
+ *
+ * @param {{name: string, implementation: Record<string, unknown>, requiredMethods: string[]}} options
+ * @returns {{valid: boolean, name: string, expectedMethods: string[], implementedMethods: string[], missingMethods: string[], message: string}}
+ */
+function validatePortImplementation({ name, implementation, requiredMethods, }) {
+    const missingMethods = missingPortMethods(implementation, requiredMethods);
+    const implementedMethods = implementedPortMethods(implementation);
+    return {
+        valid: missingMethods.length === 0,
+        name,
+        expectedMethods: [...requiredMethods],
+        implementedMethods,
+        missingMethods,
+        message: buildPortValidationMessage({ name, missingMethods }),
+    };
+}
+/**
+ * Asserts that an implementation satisfies a named port.
+ *
+ * @param {{name: string, implementation: Record<string, unknown>, requiredMethods: string[]}} options
+ * @returns {Record<string, unknown>}
+ */
+function assertPortImplementation({ name, implementation, requiredMethods, }) {
+    const result = validatePortImplementation({ name, implementation, requiredMethods });
+    if (!result.valid) {
+        throw new Error(result.message);
+    }
+    return implementation;
+}

package/dist/core/run-index.d.ts

@@ -0,0 +1,62 @@
+type RunIndexEntry = {
+    runDir: string;
+    scenarioId: string;
+    scenarioHash?: string;
+    runId: string;
+    healthStatus: string;
+    trusted: boolean;
+    durationMs?: number;
+    endedAt?: string;
+    flowId?: string;
+    comparisonLane?: string;
+    interactionDriver?: string;
+    platform?: string;
+    startedAt?: string;
+    verdictStatus?: string;
+};
+type RunIndex = {
+    entries: RunIndexEntry[];
+    rootDir: string;
+    trusted: RunIndexEntry[];
+};
+/**
+ * Recursively finds run directories under one artifact root.
+ *
+ * @param {string} rootDir
+ * @returns {string[]}
+ */
+declare function findRunDirs(rootDir: string): string[];
+/**
+ * Converts one run directory into an index entry.
+ *
+ * @param {string} runDir
+ * @returns {RunIndexEntry}
+ */
+declare function readRunIndexEntry(runDir: string): RunIndexEntry;
+/**
+ * Sorts entries newest first while keeping deterministic fallback ordering.
+ *
+ * @param {RunIndexEntry[]} entries
+ * @returns {RunIndexEntry[]}
+ */
+declare function sortRunIndexEntries(entries: RunIndexEntry[]): RunIndexEntry[];
+/**
+ * Builds a read-only index of completed run artifact folders.
+ *
+ * @param {{rootDir: string, scenarioId?: string}} options
+ * @returns {RunIndex}
+ */
+declare function buildRunIndex({ rootDir, scenarioId }: {
+    rootDir: string;
+    scenarioId?: string;
+}): RunIndex;
+/**
+ * Returns the newest trusted run for a scenario, if one exists.
+ *
+ * @param {RunIndex} index
+ * @param {string} scenarioId
+ * @returns {RunIndexEntry | null}
+ */
+declare function findLatestTrustedRun(index: RunIndex, scenarioId: string): RunIndexEntry | null;
+export { buildRunIndex, findLatestTrustedRun, findRunDirs, readRunIndexEntry, sortRunIndexEntries, };
+export type { RunIndex, RunIndexEntry, };

package/dist/core/run-index.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRunIndex = buildRunIndex;
+exports.findLatestTrustedRun = findLatestTrustedRun;
+exports.findRunDirs = findRunDirs;
+exports.readRunIndexEntry = readRunIndexEntry;
+exports.sortRunIndexEntries = sortRunIndexEntries;
+const fs = require('node:fs');
+const path = require('node:path');
+const { ARTIFACT_FILENAMES, PROFILE_ARTIFACT_FILENAMES } = require('./artifact-layout');
+/**
+ * Reads a JSON object from disk.
+ *
+ * @param {string} filePath
+ * @returns {Record<string, unknown>}
+ */
+function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+/**
+ * Returns whether a directory contains the minimum run artifact pair.
+ *
+ * @param {string} dir
+ * @returns {boolean}
+ */
+function isRunDir(dir) {
+    return (fs.existsSync(path.join(dir, ARTIFACT_FILENAMES.health)) &&
+        fs.existsSync(path.join(dir, ARTIFACT_FILENAMES.verdict)));
+}
+/**
+ * Recursively finds run directories under one artifact root.
+ *
+ * @param {string} rootDir
+ * @returns {string[]}
+ */
+function findRunDirs(rootDir) {
+    if (!fs.existsSync(rootDir) || !fs.statSync(rootDir).isDirectory()) {
+        return [];
+    }
+    const results = [];
+    const pending = [path.resolve(rootDir)];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (!current) {
+            continue;
+        }
+        if (isRunDir(current)) {
+            results.push(current);
+            continue;
+        }
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                pending.push(path.join(current, entry.name));
+            }
+        }
+    }
+    return results.sort();
+}
+/**
+ * Converts one run directory into an index entry.
+ *
+ * @param {string} runDir
+ * @returns {RunIndexEntry}
+ */
+function readRunIndexEntry(runDir) {
+    const health = readJson(path.join(runDir, ARTIFACT_FILENAMES.health));
+    const verdict = readJson(path.join(runDir, ARTIFACT_FILENAMES.verdict));
+    const manifestPath = path.join(runDir, PROFILE_ARTIFACT_FILENAMES.manifest);
+    const manifest = fs.existsSync(manifestPath) ? readJson(manifestPath) : {};
+    const scenarioId = typeof health.scenarioId === 'string'
+        ? health.scenarioId
+        : typeof manifest.scenario === 'string'
+            ? manifest.scenario
+            : 'unknown-scenario';
+    const runId = typeof health.runId === 'string'
+        ? health.runId
+        : typeof manifest.runId === 'string'
+            ? manifest.runId
+            : path.basename(runDir);
+    const healthStatus = typeof health.healthStatus === 'string' ? health.healthStatus : 'unknown';
+    const verdictStatus = typeof verdict.verdictStatus === 'string' ? verdict.verdictStatus : undefined;
+    return {
+        runDir,
+        scenarioId,
+        runId,
+        ...(typeof manifest.scenarioHash === 'string' ? { scenarioHash: manifest.scenarioHash } : {}),
+        healthStatus,
+        trusted: healthStatus === 'passed' && verdictStatus === 'passed',
+        ...(typeof manifest.durationMs === 'number' ? { durationMs: manifest.durationMs } : {}),
+        ...(typeof manifest.endedAt === 'string' ? { endedAt: manifest.endedAt } : {}),
+        ...(typeof health.flowId === 'string' ? { flowId: health.flowId } : {}),
+        ...(typeof manifest.comparisonLane === 'string' ? { comparisonLane: manifest.comparisonLane } : {}),
+        ...(typeof manifest.interactionDriver === 'string' ? { interactionDriver: manifest.interactionDriver } : {}),
+        ...(typeof manifest.platform === 'string' ? { platform: manifest.platform } : {}),
+        ...(typeof manifest.startedAt === 'string' ? { startedAt: manifest.startedAt } : {}),
+        ...(verdictStatus ? { verdictStatus } : {}),
+    };
+}
+/**
+ * Sorts entries newest first while keeping deterministic fallback ordering.
+ *
+ * @param {RunIndexEntry[]} entries
+ * @returns {RunIndexEntry[]}
+ */
+function sortRunIndexEntries(entries) {
+    return [...entries].sort((left, right) => {
+        const leftTime = Date.parse(left.endedAt ?? left.startedAt ?? '');
+        const rightTime = Date.parse(right.endedAt ?? right.startedAt ?? '');
+        const leftTimestamp = Number.isFinite(leftTime) ? leftTime : 0;
+        const rightTimestamp = Number.isFinite(rightTime) ? rightTime : 0;
+        if (leftTimestamp !== rightTimestamp) {
+            return rightTimestamp - leftTimestamp;
+        }
+        return `${left.scenarioId}/${left.runId}/${left.runDir}`.localeCompare(`${right.scenarioId}/${right.runId}/${right.runDir}`);
+    });
+}
+/**
+ * Builds a read-only index of completed run artifact folders.
+ *
+ * @param {{rootDir: string, scenarioId?: string}} options
+ * @returns {RunIndex}
+ */
+function buildRunIndex({ rootDir, scenarioId }) {
+    const resolvedRoot = path.resolve(rootDir);
+    const entries = sortRunIndexEntries(findRunDirs(resolvedRoot)
+        .map((runDir) => readRunIndexEntry(runDir))
+        .filter((entry) => !scenarioId || entry.scenarioId === scenarioId));
+    return {
+        rootDir: resolvedRoot,
+        entries,
+        trusted: entries.filter((entry) => entry.trusted),
+    };
+}
+/**
+ * Returns the newest trusted run for a scenario, if one exists.
+ *
+ * @param {RunIndex} index
+ * @param {string} scenarioId
+ * @returns {RunIndexEntry | null}
+ */
+function findLatestTrustedRun(index, scenarioId) {
+    return index.trusted.find((entry) => entry.scenarioId === scenarioId) ?? null;
+}

package/dist/core/schema-validator.d.ts

@@ -0,0 +1,86 @@
+type JsonSchema = Record<string, unknown> & {
+    $ref?: string;
+    allOf?: JsonSchema[];
+    const?: unknown;
+    description?: string;
+    else?: JsonSchema;
+    if?: JsonSchema;
+    not?: JsonSchema;
+    then?: JsonSchema;
+    type?: string | string[];
+    enum?: unknown[];
+    pattern?: string;
+    minLength?: number;
+    minimum?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    items?: JsonSchema;
+    minProperties?: number;
+    required?: string[];
+    properties?: Record<string, JsonSchema>;
+    additionalProperties?: boolean | JsonSchema;
+};
+type ValidationError = {
+    code: string;
+    path: string;
+    message: string;
+};
+type ValidationResult = {
+    valid: boolean;
+    errors: ValidationError[];
+    message: string;
+};
+/**
+ * Error thrown when a manifest or generated artifact does not satisfy its schema.
+ */
+declare class SchemaValidationError extends Error {
+    label: string;
+    errors: ValidationError[];
+    /**
+     * @param {string} label
+     * @param {{code: string, path: string, message: string}[]} errors
+     */
+    constructor(label: string, errors: ValidationError[]);
+}
+declare const SCHEMAS: {
+    budgetVerdict: JsonSchema;
+    causalRun: JsonSchema;
+    comparison: JsonSchema;
+    health: JsonSchema;
+    liveProof: JsonSchema;
+    liveProofSet: JsonSchema;
+    manifest: JsonSchema;
+    metrics: JsonSchema;
+    projectValidation: JsonSchema;
+    scenario: JsonSchema;
+    runnerCapabilities: JsonSchema;
+    verdict: JsonSchema;
+};
+/**
+ * Validates a value against a schema and returns structured errors instead of throwing.
+ *
+ * @param {unknown} value
+ * @param {Record<string, unknown>} schema
+ * @param {string} [label]
+ * @returns {{valid: boolean, errors: {code: string, path: string, message: string}[], message: string}}
+ */
+declare function validateJson(value: unknown, schema: JsonSchema, label?: string): ValidationResult;
+/**
+ * Validates a value against a schema, throwing `SchemaValidationError` on failure.
+ *
+ * @param {unknown} value
+ * @param {Record<string, unknown>} schema
+ * @param {string} label
+ * @returns {unknown}
+ */
+declare function assertValidJson(value: unknown, schema: JsonSchema, label: string): unknown;
+/**
+ * Formats schema errors as a CLI-readable message.
+ *
+ * @param {string} label
+ * @param {{path: string, message: string}[]} errors
+ * @returns {string}
+ */
+declare function formatValidationErrorMessage(label: string, errors: Array<Pick<ValidationError, 'path' | 'message'>>): string;
+export { SCHEMAS, SchemaValidationError, assertValidJson, formatValidationErrorMessage, validateJson, };
+export type { JsonSchema, ValidationError, ValidationResult, };