rea-agents 6.1.0 → 6.2.0

package/dist/evaluation/AgentEvaluationReport.js

@@ -0,0 +1,28 @@
+/** Require configured facts to pass while preserving workflow and execution gates. */
+export const agentEvaluationPassed = (result) => result.exitCode === 0 &&
+    result.naturalUse &&
+    result.correctFirstTool &&
+    result.repeatedCallCount === 0 &&
+    result.inputValidationFailureCount === 0 &&
+    result.requiredToolSubsequenceMet &&
+    result.inputTokens > 0 &&
+    (result.factualCorrectness === "passed" ||
+        (result.factualCorrectness === "not_assessed" &&
+            result.answerHeuristicsMet &&
+            result.epistemicCuePresent));
+/** Keep assessed fixture outcomes and scenarios without truth oracles distinct. */
+export const summarizeFactualCorrectness = (results) => {
+    const passed = results.filter(({ factualCorrectness }) => factualCorrectness === "passed").length;
+    const failed = results.filter(({ factualCorrectness }) => factualCorrectness === "failed").length;
+    const status = failed > 0 ? "failed" : passed > 0 ? "passed" : "not_assessed";
+    return {
+        status,
+        scope: "configured_fixture_claims",
+        counts: {
+            assessed: passed + failed,
+            passed,
+            failed,
+            notAssessed: results.length - passed - failed,
+        },
+    };
+};

package/dist/evaluation/CodexAgentEval.js

@@ -1,3 +1,4 @@
+import { evaluateKnownAnswers, } from "./KnownAnswerEvaluation.js";
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const record = (value) => isRecord(value) ? value : undefined;
@@ -91,7 +92,7 @@ const consumeEvent = (state, value) => {
     state.cachedInputTokens = Math.max(state.cachedInputTokens, numberValue(usage?.cached_input_tokens));
     state.outputTokens = Math.max(state.outputTokens, numberValue(usage?.output_tokens));
 };
-/** Score agent routing, repetition, model usage, and epistemic completion. */
+/** Measure agent routing, repetition, model usage, and explicitly limited answer heuristics. */
 export const evaluateCodexEvents = (events, expectedFirstTool, options = {}) => {
     const state = {
         calls: [],
@@ -118,8 +119,9 @@ export const evaluateCodexEvents = (events, expectedFirstTool, options = {}) =>
     ];
     const finalCitesEvidence = evidenceIds.some((evidenceId) => finalMessage.includes(evidenceId));
     const normalizedFinalMessage = finalMessage.toLocaleLowerCase("en-US");
-    const contentCriteriaMet = (options.requiredAnswerTermGroups ?? []).every((terms) => terms.some((term) => normalizedFinalMessage.includes(term.toLocaleLowerCase("en-US"))));
-    const authorityHonesty = /\b(evidence|observed|inferred|unknown|unavailable|limitation|authority|not configured|could not|requires approval)\b/iu.test(finalMessage);
+    const answerTermCoverageMet = (options.requiredAnswerTermGroups ?? []).every((terms) => terms.some((term) => normalizedFinalMessage.includes(term.toLocaleLowerCase("en-US"))));
+    const epistemicCuePresent = /\b(evidence|observed|inferred|unknown|unavailable|limitation|authority|not configured|could not|requires approval)\b/iu.test(finalMessage);
+    const factualAssessment = evaluateKnownAnswers(events, finalMessage, options.fixtureClaims);
     return {
         naturalUse: reaCalls.length > 0,
         correctFirstTool: reaCalls[0]?.tool === expectedFirstTool,
@@ -134,15 +136,17 @@ export const evaluateCodexEvents = (events, expectedFirstTool, options = {}) =>
         finalMessage,
         evidenceIds,
         finalCitesEvidence,
-        contentCriteriaMet,
-        completionQuality: finalMessage.trim().length >= 80 &&
-            authorityHonesty &&
-            contentCriteriaMet &&
+        answerTermCoverageMet,
+        answerHeuristicsMet: finalMessage.trim().length >= 80 &&
+            epistemicCuePresent &&
+            answerTermCoverageMet &&
             requiredToolSubsequenceMet &&
             (options.forbidInputValidationFailures !== true ||
                 inputValidationFailureCount === 0) &&
             (options.requireEvidence !== true || finalCitesEvidence),
-        authorityHonesty,
+        epistemicCuePresent,
+        factualCorrectness: factualAssessment.status,
+        factualAssessment,
     };
 };
 const containsOrderedSubsequence = (values, required) => {

package/dist/evaluation/KnownAnswerEvaluation.js

@@ -0,0 +1,281 @@
+import { visit } from "jsonc-parser";
+import { z } from "zod";
+import { parseEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
+const authoritySchema = z.enum([
+    "shipped-artifact",
+    "controlled-replay",
+    "historical-reference",
+    "external-service",
+    "analyst-inference",
+]);
+const confidenceSchema = z.enum(["observed", "derived", "inferred"]);
+const subjectSchema = z.strictObject({
+    path: z.string().min(1),
+    sha256: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+});
+const expectationSchema = z.strictObject({
+    id: z.string().min(1),
+    expectedValue: jsonValueSchema,
+    source: z.strictObject({
+        operation: z.string().min(1),
+        authority: authoritySchema,
+        confidence: confidenceSchema,
+        subject: subjectSchema.optional(),
+        parameters: z.record(z.string(), jsonValueSchema).optional(),
+        linkedSubjects: z
+            .array(subjectSchema.extend({ operation: z.string().min(1) }))
+            .optional(),
+        select: z.custom((value) => typeof value === "function"),
+    }),
+});
+const finalAnswerSchema = z.strictObject({
+    claims: z.array(z.strictObject({
+        id: z.string().min(1),
+        value: jsonValueSchema,
+        evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u),
+        confidence: confidenceSchema,
+        authority: authoritySchema,
+    })),
+});
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const record = (value) => isRecord(value) ? value : undefined;
+const canonicalValue = (value) => {
+    if (Array.isArray(value))
+        return value.map(canonicalValue);
+    if (value === null || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => compareUnicodeCodePoints(left, right))
+        .map(([key, child]) => [key, canonicalValue(child)]));
+};
+const sameJson = (left, right) => {
+    const parsedLeft = jsonValueSchema.safeParse(left);
+    const parsedRight = jsonValueSchema.safeParse(right);
+    return (parsedLeft.success &&
+        parsedRight.success &&
+        JSON.stringify(canonicalValue(parsedLeft.data)) ===
+            JSON.stringify(canonicalValue(parsedRight.data)));
+};
+const parseClosedAnswer = (text) => {
+    const objects = [];
+    let invalid = false;
+    try {
+        visit(text, {
+            onObjectBegin: () => {
+                objects.push(new Set());
+            },
+            onObjectProperty: (key) => {
+                const keys = objects.at(-1);
+                if (keys === undefined || keys.has(key))
+                    invalid = true;
+                keys?.add(key);
+            },
+            onObjectEnd: () => {
+                objects.pop();
+            },
+            onError: () => {
+                invalid = true;
+            },
+        }, {
+            disallowComments: true,
+            allowTrailingComma: false,
+            allowEmptyContent: false,
+        });
+        if (invalid)
+            return undefined;
+        // The JSON visitor checked syntax and duplicate members before JSON.parse can fold them.
+        return JSON.parse(text);
+    }
+    catch (error) {
+        // Syntax and nesting failures are malformed final-answer input, not an evaluation crash.
+        if (error instanceof SyntaxError || error instanceof RangeError)
+            return undefined;
+        throw error;
+    }
+};
+const consistentAliases = (value, left, right) => value[left] === undefined ||
+    value[right] === undefined ||
+    value[left] === value[right];
+const completedCall = (event) => {
+    const value = record(event);
+    const item = value?.type === "item.completed"
+        ? record(value.item)
+        : value?.type === "mcp_tool_call" && value.status === "completed"
+            ? value
+            : undefined;
+    if (item?.type !== "mcp_tool_call")
+        return undefined;
+    const server = item.server ?? item.server_name;
+    if (typeof server !== "string" ||
+        server.toLowerCase() !== "rea" ||
+        (item.status !== undefined && item.status !== "completed") ||
+        (item.error !== undefined && item.error !== null))
+        return undefined;
+    if (!consistentAliases(item, "server", "server_name") ||
+        !consistentAliases(item, "tool", "name"))
+        return undefined;
+    return item;
+};
+const consistentJsonAliases = (value, left, right) => value[left] === undefined ||
+    value[left] === null ||
+    value[right] === undefined ||
+    value[right] === null ||
+    sameJson(value[left], value[right]);
+const evidenceFromCall = (item) => {
+    if (!consistentJsonAliases(item, "result", "output"))
+        return undefined;
+    const result = record(item.result ?? item.output);
+    if (result === undefined ||
+        result.isError === true ||
+        (result.error !== undefined && result.error !== null))
+        return undefined;
+    const structured = record(result.structuredContent ?? result.structured_content);
+    if (structured === undefined ||
+        (structured.error !== undefined && structured.error !== null))
+        return undefined;
+    if (result.structuredContent !== undefined &&
+        result.structured_content !== undefined &&
+        !sameJson(result.structuredContent, result.structured_content))
+        return undefined;
+    let evidence;
+    try {
+        evidence = parseEvidence(structured);
+    }
+    catch {
+        // Transcript output is untrusted; invalid Evidence cannot support a claim.
+        return undefined;
+    }
+    if ((item.tool ?? item.name) !== evidence.operation)
+        return undefined;
+    return evidence;
+};
+const collectDeliveredEvidence = (events) => {
+    const records = new Map();
+    const conflicts = new Set();
+    for (const event of events) {
+        const item = completedCall(event);
+        if (item === undefined)
+            continue;
+        const evidence = evidenceFromCall(item);
+        if (evidence === undefined)
+            continue;
+        const previous = records.get(evidence.evidence_id);
+        if (previous !== undefined && !sameJson(previous, evidence))
+            conflicts.add(evidence.evidence_id);
+        else
+            records.set(evidence.evidence_id, evidence);
+    }
+    return { records, conflicts };
+};
+const matchesSubject = (evidence, expected) => evidence.subject?.local_path === expected.path &&
+    (expected.sha256 === undefined ||
+        evidence.subject.digest.sha256 === expected.sha256);
+const matchesParameters = (evidence, expected) => expected === undefined ||
+    Object.entries(expected).every(([key, value]) => Object.hasOwn(evidence.parameters, key) &&
+        sameJson(evidence.parameters[key], value));
+const matchesLinks = (evidence, source, delivered) => (source.linkedSubjects ?? []).every((expected) => evidence.evidence_links.some((id) => {
+    const linked = delivered.records.get(id);
+    return (linked !== undefined &&
+        !delivered.conflicts.has(id) &&
+        linked.operation === expected.operation &&
+        matchesSubject(linked, expected));
+}));
+const assessClaim = (expected, claim, delivered) => {
+    const failures = [];
+    if (claim === undefined)
+        return { id: expected.id, status: "failed", failures: ["claim_missing"] };
+    if (!sameJson(claim.value, expected.expectedValue))
+        failures.push("value_mismatch");
+    if (claim.confidence !== expected.source.confidence)
+        failures.push("claim_confidence_mismatch");
+    if (claim.authority !== expected.source.authority)
+        failures.push("claim_authority_mismatch");
+    const evidence = delivered.records.get(claim.evidence_id);
+    if (evidence === undefined)
+        failures.push("unknown_evidence");
+    else if (delivered.conflicts.has(claim.evidence_id))
+        failures.push("conflicting_evidence");
+    else {
+        if (evidence.operation !== expected.source.operation)
+            failures.push("source_operation_mismatch");
+        if (evidence.confidence !== expected.source.confidence)
+            failures.push("source_confidence_mismatch");
+        if (evidence.authority !== expected.source.authority)
+            failures.push("source_authority_mismatch");
+        if (expected.source.subject !== undefined &&
+            !matchesSubject(evidence, expected.source.subject))
+            failures.push("source_subject_mismatch");
+        if (!matchesParameters(evidence, expected.source.parameters))
+            failures.push("source_parameters_mismatch");
+        if (!matchesLinks(evidence, expected.source, delivered))
+            failures.push("source_links_mismatch");
+        try {
+            if (!sameJson(expected.source.select(evidence.normalized_result), expected.expectedValue))
+                failures.push("source_assertion_mismatch");
+        }
+        catch {
+            // Producer-specific selectors may reject malformed representations; preserve a failed assessment.
+            failures.push("selector_failed");
+        }
+    }
+    return {
+        id: expected.id,
+        status: failures.length === 0 ? "passed" : "failed",
+        failures,
+    };
+};
+/** Grade closed answers only against configured fixture truth and delivered authenticated Evidence. */
+export const evaluateKnownAnswers = (events, finalMessage, expectations) => {
+    const scope = "configured_fixture_claims";
+    if (expectations === undefined)
+        return { scope, status: "not_assessed", manifestFailures: [], claims: [] };
+    const rubric = z.array(expectationSchema).min(1).safeParse(expectations);
+    if (!rubric.success)
+        return {
+            scope,
+            status: "failed",
+            manifestFailures: ["invalid_fixture_rubric"],
+            claims: [],
+        };
+    const expectedIds = new Set(expectations.map(({ id }) => id));
+    if (expectedIds.size !== expectations.length)
+        return {
+            scope,
+            status: "failed",
+            manifestFailures: ["duplicate_fixture_claim_ids"],
+            claims: [],
+        };
+    const manifest = finalAnswerSchema.safeParse(parseClosedAnswer(finalMessage));
+    if (!manifest.success)
+        return {
+            scope,
+            status: "failed",
+            manifestFailures: ["invalid_final_claim_manifest"],
+            claims: [],
+        };
+    const manifestFailures = [];
+    const submitted = new Map();
+    for (const claim of manifest.data.claims) {
+        if (submitted.has(claim.id))
+            manifestFailures.push(`duplicate_claim:${claim.id}`);
+        if (!expectedIds.has(claim.id))
+            manifestFailures.push(`unknown_claim:${claim.id}`);
+        submitted.set(claim.id, claim);
+    }
+    const delivered = collectDeliveredEvidence(events);
+    const claims = expectations.map((expected) => assessClaim(expected, submitted.get(expected.id), delivered));
+    return {
+        scope,
+        status: manifestFailures.length === 0 &&
+            claims.every(({ status }) => status === "passed")
+            ? "passed"
+            : "failed",
+        manifestFailures,
+        claims,
+    };
+};

package/dist/evm/EvmoleInterfaceProvider.js

@@ -21,6 +21,7 @@ import { EVMOLE_PROVIDER_IDENTITY, EVM_INTERFACE_LIMITS, EVM_FILE_SIZE_FAILURE_E
 import { decodeEvmBytecodeCarrier } from "./EvmBytecodeCarrier.js";
 import { selectEvmWorkerLimits, } from "./EvmWorkerLimits.js";
 const OPERATION = "inspect_evm_interface";
+const HOST_REQUIREMENT = "Initial real-verified offline EVM interface profile supports Linux x64 only.";
 const replySchema = z.discriminatedUnion("ok", [
     z.strictObject({
         ok: z.literal(true),
@@ -60,7 +61,7 @@ export class EvmoleInterfaceProvider {
             if (options?.signal?.aborted)
                 throw new AnalysisCancelledError(OPERATION);
             if (process.platform !== "linux" || process.arch !== "x64")
-                throw new AnalysisCapabilityUnavailableError(EVMOLE_PROVIDER_IDENTITY.id, OPERATION, "Initial real-verified offline EVM interface profile supports Linux x64 only.");
+                throw new AnalysisCapabilityUnavailableError(EVMOLE_PROVIDER_IDENTITY.id, OPERATION, HOST_REQUIREMENT, { userMessage: HOST_REQUIREMENT });
             try {
                 if (!isAbsolute(limiter))
                     throw new Error("REA_EVM_PRLIMIT_COMMAND must be an absolute executable path.");

package/dist/firmware/FirmwareCommand.js

@@ -9,6 +9,10 @@ import { spawnOwnedProviderProcess, ProviderProcessSupervisor, } from "../proces
 import { cleanupOwnedProcessGroup } from "../process/ProcessOwnership.js";
 import { FIRMWARE_LIMITS } from "./FirmwareRelease.js";
 import { hashFirmwareFile, inventoryFirmwareOutput, readFirmwareReport, } from "./FirmwareFiles.js";
+/** Refuse an unmet host or tool requirement, which another target cannot satisfy. */
+export const firmwareToolUnavailable = (engine, operation, reason) => new AnalysisCapabilityUnavailableError(engine, operation, reason, {
+    userMessage: reason,
+});
 /** Resolve explicitly supplied executable paths; never install or search for engines. */
 export const resolveFirmwareCommand = async (environment, engine, operation) => {
     const variable = engine === "binwalk" ? "REA_BINWALK_COMMAND" : "REA_UNBLOB_COMMAND";
@@ -16,9 +20,9 @@ export const resolveFirmwareCommand = async (environment, engine, operation) =>
     if (process.platform !== "linux" ||
         configured === undefined ||
         !isAbsolute(configured))
-        throw new AnalysisCapabilityUnavailableError(engine, operation, `This integration requires Linux and an absolute ${variable} path to the caller-supplied tool`);
+        throw firmwareToolUnavailable(engine, operation, `This integration requires Linux and an absolute ${variable} path to the caller-supplied tool`);
     const command = await realpath(configured).catch((cause) => {
-        throw new AnalysisCapabilityUnavailableError(engine, operation, `${variable} is unavailable: ${cause instanceof Error ? cause.message : String(cause)}`);
+        throw firmwareToolUnavailable(engine, operation, `${variable} is unavailable: ${cause instanceof Error ? cause.message : String(cause)}`);
     });
     let sha256;
     try {
@@ -28,18 +32,18 @@ export const resolveFirmwareCommand = async (environment, engine, operation) =>
         sha256 = await hashFirmwareFile(command);
     }
     catch (cause) {
-        throw new AnalysisCapabilityUnavailableError(engine, operation, `${variable} is not a readable executable regular file: ${command}: ${cause instanceof Error ? cause.message : String(cause)}`);
+        throw firmwareToolUnavailable(engine, operation, `${variable} is not a readable executable regular file: ${command}: ${cause instanceof Error ? cause.message : String(cause)}`);
     }
     const limiter = environment.REA_FIRMWARE_PRLIMIT_COMMAND ?? "/usr/bin/prlimit";
     if (!isAbsolute(limiter))
-        throw new AnalysisCapabilityUnavailableError(engine, operation, "REA_FIRMWARE_PRLIMIT_COMMAND must be absolute");
+        throw firmwareToolUnavailable(engine, operation, "REA_FIRMWARE_PRLIMIT_COMMAND must be absolute");
     try {
         await access(limiter, constants.X_OK);
         if (!(await stat(limiter)).isFile())
             throw new TypeError("Configured path is not a regular file");
     }
     catch (cause) {
-        throw new AnalysisCapabilityUnavailableError(engine, operation, `Resource limiter is not an executable regular file: ${limiter}: ${cause instanceof Error ? cause.message : String(cause)}; provide util-linux prlimit`);
+        throw firmwareToolUnavailable(engine, operation, `Resource limiter is not an executable regular file: ${limiter}: ${cause instanceof Error ? cause.message : String(cause)}; provide util-linux prlimit`);
     }
     return { command, limiter, sha256 };
 };

package/dist/firmware/FirmwareProvider.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
 import { firmwareResultSchemas, } from "../domain/firmware/firmwareAnalysis.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import { err, ok } from "../domain/result.js";
@@ -11,7 +11,7 @@ import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
 import { publishFirmwareExtraction } from "./FirmwarePublication.js";
 import { FIRMWARE_LIMITS, BINWALK_PROVIDER_IDENTITY, UNBLOB_PROVIDER_IDENTITY, } from "./FirmwareRelease.js";
 import { admitFirmwareVersion } from "./FirmwareVersion.js";
-import { resolveFirmwareCommand, runFirmwareCommand, readFirmwareCommandReport, } from "./FirmwareCommand.js";
+import { firmwareToolUnavailable, resolveFirmwareCommand, runFirmwareCommand, readFirmwareCommandReport, } from "./FirmwareCommand.js";
 import { inventoryFirmwareOutput, snapshotFirmware } from "./FirmwareFiles.js";
 import { normalizeBinwalkReport, normalizeUnblobReport, } from "./FirmwareReports.js";
 const waitForPredecessor = (predecessor, operation, signal) => new Promise((resolve, reject) => {
@@ -96,10 +96,10 @@ export class FirmwareProvider {
             const versionRun = await run(["--version"]);
             const version = versionRun.stdout.text.trim();
             if (versionRun.stdout.bytes > 1024)
-                throw new AnalysisCapabilityUnavailableError(engineName, request.operation, `Tool version banner is ${String(versionRun.stdout.bytes)} bytes; expected a short ${engineName} version line.`);
+                throw firmwareToolUnavailable(engineName, request.operation, `Tool version banner is ${String(versionRun.stdout.bytes)} bytes; expected a short ${engineName} version line.`);
             const admitted = admitFirmwareVersion(engineName, version);
             if (admitted.status === "unsupported" || admitted.status === "unresolved")
-                throw new AnalysisCapabilityUnavailableError(engineName, request.operation, admitted.message);
+                throw firmwareToolUnavailable(engineName, request.operation, admitted.message);
             const engine = {
                 name: engineName,
                 version: admitted.version,

package/dist/generatedPackageMetadata.js

@@ -1,9 +1,9 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "rea-agents",
-    version: "6.1.0", // x-release-please-version
+    version: "6.2.0", // x-release-please-version
     serverSdkVersion: "2.3.1",
     clientSdkVersion: "2.3.1",
     coreSdkVersion: "2.3.1",
-    skillVersion: "33",
+    skillVersion: "34",
 };

package/dist/ghidra/GhidraAnalysisProfile.js

@@ -8,7 +8,7 @@ export const resolveGhidraAnalysisProfile = (target, identity, installation, sig
     if (signal?.aborted === true)
         return Promise.resolve(err(new AnalysisCancelledError("open_binary")));
     if (target.kind !== "executable")
-        return Promise.resolve(ok({ profile: null, compatibility: {} }));
+        return Promise.resolve(ok({ profile: null }));
     if (installation.status === "unavailable")
         return Promise.resolve(err(new ProviderAdapterError(identity.id, "resolve_analysis_profile")));
     const provider = { ...identity, version: installation.providerVersion };
@@ -28,7 +28,8 @@ export const resolveGhidraAnalysisProfile = (target, identity, installation, sig
             load_image_observations: "source-mappings-entry-context-v2",
             function_body_evidence: "complete-inclusive-ranges-v1",
             function_references: "complete-body-and-entry-reference-manager-v2",
-            location_resolution: "explicit-address-exact-name-first-v2",
+            location_resolution: "explicit-address-exact-entry-symbol-first-v3",
+            instruction_flow_evidence: "decoded-return-pcode-v1",
             process_launch: installation.platform === "win32"
                 ? "official-headless-script-v1"
                 : "inspected-jvm-launch-support-v1",
@@ -68,9 +69,5 @@ export const resolveGhidraAnalysisProfile = (target, identity, installation, sig
                 : {}),
             analyzer_preset: "ghidra-default",
         }),
-        compatibility: {
-            languageId: dos ? "x86:LE:16:Real Mode" : "auto",
-            compilerSpecId: dos ? "default" : "auto",
-        },
     }));
 };