rea-agents 6.0.0 → 6.2.0

package/dist/javascript/sourceMaps/SourceMapFormat.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { WEB_SOURCE_MAP_LIMITS } from "../../domain/webSourceLocation.js";
+import { hasValidSourceMapContents } from "../../domain/sourceMapContents.js";
 const leafSchema = z.object({
     version: z.literal(3),
     file: z.string().nullable().optional(),
@@ -48,9 +49,21 @@ const addOffset = (base, offset) => {
         throw new SourceMapFormatFailure("limit", "Indexed offset exceeds the 262144 generated-row decoder budget.");
     return result;
 };
-const addSections = (node, pending) => {
+const consumeRecords = (budget, count) => {
+    if (count > WEB_SOURCE_MAP_LIMITS.decodedRecords - budget.records)
+        throw new SourceMapFormatFailure("limit", `Source-map structure exceeds the ${WEB_SOURCE_MAP_LIMITS.decodedRecords}-record decoder budget.`);
+    budget.records += count;
+};
+const addSections = (node, pending, budget, options) => {
+    options.check?.();
+    const header = mapHeaderSchema.parse(node.value);
+    if (!Array.isArray(header.sections))
+        throw new SourceMapFormatFailure("format", "Indexed source-map sections must be an array.");
+    consumeRecords(budget, header.sections.length);
     const sections = indexedSchema.parse(node.value).sections;
     for (const [index, section] of sections.entries()) {
+        if ((index & 255) === 0)
+            options.check?.();
         const previous = sections[index - 1];
         if (previous !== undefined && compare(section.offset, previous.offset) <= 0)
             throw new SourceMapFormatFailure("format", "Indexed section offsets must be strictly increasing.");
@@ -81,7 +94,7 @@ const addSections = (node, pending) => {
         });
     }
 };
-const inspectMappingLayout = (mappings) => {
+const inspectMappingLayout = (mappings, check) => {
     let lines = 1;
     let segments = 0;
     let components = 0;
@@ -94,7 +107,10 @@ const inspectMappingLayout = (mappings) => {
         if (inSegment && ![1, 4, 5].includes(components))
             throw new SourceMapFormatFailure("format", "Source-map segment requires one, four or five VLQ components.");
     };
+    let index = 0;
     for (const character of mappings) {
+        if ((index++ & 0x3fff) === 0)
+            check?.();
         if (character === "," || character === ";") {
             finish();
             inSegment = false;
@@ -123,6 +139,35 @@ const inspectMappingLayout = (mappings) => {
     finish();
     return { lines, segments };
 };
+const inspectLeaf = (node, budget, options) => {
+    options.check?.();
+    consumeRecords(budget, 1);
+    if (typeof node.value !== "object" ||
+        node.value === null ||
+        Array.isArray(node.value))
+        return leafSchema.parse(node.value);
+    const rawMap = node.value;
+    const rawSources = rawMap.sources;
+    const rawNames = rawMap.names;
+    const rawContents = rawMap.sourcesContent;
+    consumeRecords(budget, Array.isArray(rawSources) ? rawSources.length : 0);
+    consumeRecords(budget, Array.isArray(rawNames) ? rawNames.length : 0);
+    consumeRecords(budget, Array.isArray(rawContents) ? rawContents.length : 0);
+    options.check?.();
+    if (options.profile === "browser-collection" && !Array.isArray(rawNames))
+        throw new SourceMapFormatFailure("format", "Source-map leaf requires a names array.");
+    if (options.profile === "browser-collection" &&
+        !hasValidSourceMapContents(Array.isArray(rawSources) ? rawSources.length : 0, rawContents))
+        throw new SourceMapFormatFailure("format", "Source-map sourcesContent must align with its source declarations.");
+    options.check?.();
+    const leaf = leafSchema.parse(node.value);
+    const layout = inspectMappingLayout(leaf.mappings, options.check);
+    consumeRecords(budget, layout.segments + layout.lines);
+    if (layout.segments > WEB_SOURCE_MAP_LIMITS.decodedSegments ||
+        node.offset.line + layout.lines > WEB_SOURCE_MAP_LIMITS.decodedRows)
+        throw new SourceMapFormatFailure("limit", "Source-map layout exceeds the 262144 segment/generated-row decoder budget.");
+    return leaf;
+};
 /** Validate structure before allocation, retaining raw declarations and section boundaries. */
 export const inspectSourceMap = (text) => {
     const withoutBom = text.replace(/^\uFEFF/u, "");
@@ -130,53 +175,56 @@ export const inspectSourceMap = (text) => {
         ? withoutBom.slice(withoutBom.indexOf("\n") + 1)
         : withoutBom;
     const value = JSON.parse(jsonText);
+    const inspected = inspectSourceMapValue(value);
+    const normalized = inspected.format === "regular"
+        ? inspected.leaves[0]?.map
+        : {
+            version: 3,
+            sections: inspected.leaves.map((leaf) => ({
+                offset: leaf.offset,
+                map: leaf.map,
+            })),
+        };
+    return {
+        jsonText: JSON.stringify(normalized),
+        ...inspected,
+    };
+};
+/** Return validated leaves when a consumer needs decoded rows after preflight. */
+export const inspectSourceMapValue = (value, options = {}) => {
+    options.check?.();
     const root = mapHeaderSchema.parse(value);
     const declarations = [];
     const leaves = [];
     const pending = [
         { value, path: [], offset: { line: 0, column: 0 }, stop: null },
     ];
-    let segmentCount = 0;
+    const budget = options.budget ?? { records: 0 };
     while (pending.length > 0) {
+        options.check?.();
         const node = pending.pop();
         if (node === undefined)
             break;
         if (node.path.length > WEB_SOURCE_MAP_LIMITS.sectionDepth)
             throw new SourceMapFormatFailure("limit", "Indexed source-map nesting exceeds the 64-level decoder stack budget.");
         if (mapHeaderSchema.parse(node.value).sections !== undefined) {
-            addSections(node, pending);
+            addSections(node, pending, budget, options);
             continue;
         }
-        const leaf = leafSchema.parse(node.value);
-        const layout = inspectMappingLayout(leaf.mappings);
-        segmentCount += layout.segments;
-        if (segmentCount > WEB_SOURCE_MAP_LIMITS.decodedSegments ||
-            node.offset.line + layout.lines > WEB_SOURCE_MAP_LIMITS.decodedRows)
-            throw new SourceMapFormatFailure("limit", "Source-map layout exceeds the 262144 segment/generated-row decoder budget.");
+        const leaf = inspectLeaf(node, budget, options);
         leaves.push({ map: leaf, offset: node.offset, stop: node.stop });
-        for (const [sourceIndex, source] of leaf.sources.entries())
-            declarations.push({
-                sectionPath: node.path,
-                sourceIndex,
-                source,
-                root: leaf.sourceRoot ?? null,
-                content: leaf.sourcesContent?.[sourceIndex] ?? null,
-                ignored: (leaf.ignoreList ?? leaf.x_google_ignoreList ?? []).includes(sourceIndex),
-            });
+        if (options.profile !== "browser-collection")
+            for (const [sourceIndex, source] of leaf.sources.entries())
+                declarations.push({
+                    sectionPath: node.path,
+                    sourceIndex,
+                    source,
+                    root: leaf.sourceRoot ?? null,
+                    content: leaf.sourcesContent?.[sourceIndex] ?? null,
+                    ignored: (leaf.ignoreList ?? leaf.x_google_ignoreList ?? []).includes(sourceIndex),
+                });
     }
-    // Absolute leaves adapt nested first-line column offsets before upstream AnyMap.
-    // Raw map bytes and the original section/source identities are retained separately.
-    const normalized = root.sections === undefined
-        ? leaves[0]?.map
-        : {
-            version: 3,
-            sections: leaves.map((leaf) => ({
-                offset: leaf.offset,
-                map: leaf.map,
-            })),
-        };
     return {
-        jsonText: JSON.stringify(normalized),
         format: root.sections === undefined ? "regular" : "indexed",
         reportedFile: root.file ?? null,
         declarations,

package/dist/javascript/sourceMaps/TraceSourceMap.js

@@ -6,10 +6,21 @@ import { z } from "zod";
 import { webSourceOffset } from "../../domain/webSourcePosition.js";
 import { webSourceMapReportSchema, WEB_SOURCE_MAP_LIMITS, } from "../../domain/webSourceLocation.js";
 import { inspectSourceMap, SourceMapFormatFailure, } from "./SourceMapFormat.js";
+import { decodeValidatedSourceMapLeaves, isBeforeSourceMapLeafStop, } from "./DecodedSourceMap.js";
 /** Decode with the pinned upstream codec; preserve every equal-position candidate. */
 export const traceSourceMap = (text, url, position) => {
     const inspected = inspectSourceMap(text);
-    const { map, rows } = decodeValidatedMap(inspected, url);
+    const map = new AnyMap(inspected.jsonText, url);
+    const decodedLeaves = decodeValidatedSourceMapLeaves(inspected.leaves, url);
+    for (const { leaf, rows } of decodedLeaves)
+        for (const [line, row] of rows.entries())
+            for (const segment of row)
+                if (!isBeforeSourceMapLeafStop(leaf, line, segment[0]))
+                    throw new SourceMapFormatFailure("format", "Embedded source-map mappings overlap the following section boundary.");
+    const rows = inspected.format === "regular"
+        ? (decodedLeaves[0]?.rows ?? [])
+        : decodedMappings(map);
+    validateFlattenedRows(inspected, rows, map);
     const matched = greatestPosition(rows, position);
     const segments = matched === null
         ? []
@@ -48,38 +59,13 @@ export const traceSourceMap = (text, url, position) => {
         diagnostics: [],
     });
 };
-const decodeValidatedMap = (inspected, url) => {
-    let regularRows;
-    for (const leaf of inspected.leaves) {
-        const decoded = decodedMappings(new TraceMap(JSON.stringify(leaf.map), url));
-        if (inspected.format === "regular")
-            regularRows = decoded;
-        for (const [line, row] of decoded.entries())
-            for (const segment of row) {
-                if (segment.some((value) => !Number.isSafeInteger(value) || value < 0) ||
-                    (segment.length !== 1 && segment[1] >= leaf.map.sources.length) ||
-                    (segment.length === 5 && segment[4] >= leaf.map.names.length))
-                    throw new SourceMapFormatFailure("format", "Decoded section-local position, source index or name index is invalid.");
-                const generatedLine = leaf.offset.line + line;
-                const generatedColumn = segment[0] + (line === 0 ? leaf.offset.column : 0);
-                if (leaf.stop !== null &&
-                    (generatedLine > leaf.stop.line ||
-                        (generatedLine === leaf.stop.line &&
-                            generatedColumn >= leaf.stop.column)))
-                    throw new SourceMapFormatFailure("format", "Embedded source-map mappings overlap the following section boundary.");
-            }
-    }
-    const map = new AnyMap(inspected.jsonText, url);
-    const rows = regularRows ?? decodedMappings(map);
+const validateFlattenedRows = (inspected, rows, map) => {
     for (const row of rows)
         for (const segment of row) {
-            if (![1, 4, 5].includes(segment.length) ||
-                segment.some((v) => !Number.isSafeInteger(v) || v < 0) ||
-                (segment.length !== 1 && segment[1] >= inspected.declarations.length) ||
+            if ((segment.length !== 1 && segment[1] >= inspected.declarations.length) ||
                 (segment.length === 5 && segment[4] >= map.names.length))
                 throw new SourceMapFormatFailure("format", "Decoded mapping has invalid component count, position, source index or name index.");
         }
-    return { map, rows };
 };
 const greatestPosition = (rows, position) => {
     for (let line = Math.min(position.line - 1, rows.length - 1); line >= 0; line -= 1) {

package/dist/main/shutdown.js

@@ -1,16 +1,20 @@
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { MCP_SHUTDOWN_FAILED } from "./messages.js";
 export const createShutdown = (input) => {
-    const { handle, session, unregisterReload, dependencies, serverLogger } = input;
+    const { handle, session, dependencies, serverLogger } = input;
     let shutdownPromise;
     let unregisterShutdown = () => undefined;
     const shutdown = async () => {
         shutdownPromise ??= (async () => {
-            unregisterReload();
             unregisterShutdown();
             const results = await Promise.allSettled([
                 handle.close(),
                 input.closeAndroid?.(),
-                session.close({ retainProviderDocuments: true }),
+                session.close({ retainProviderDocuments: true }).then((closed) => {
+                    if (!closed.ok)
+                        throw closed.error;
+                }),
             ]);
             for (const result of results)
                 if (result.status === "rejected")
@@ -24,12 +28,16 @@ export const createShutdown = (input) => {
             dependencies.setExitCode(1);
             serverLogger.error(MCP_SHUTDOWN_FAILED);
             dependencies.writeStderr(`${MCP_SHUTDOWN_FAILED}\n`);
+            if (cause instanceof AnalysisError)
+                dependencies.writeStderr(`${projectAnalysisError(cause).message}\n`);
         });
     };
     unregisterShutdown = dependencies.registerShutdown(requestShutdown);
     return { shutdown, request: requestShutdown };
 };
 const describeShutdownFailure = (cause) => {
+    if (cause instanceof AnalysisError)
+        return { analysis_error: projectAnalysisError(cause) };
     if (cause instanceof Error) {
         const code = "code" in cause ? cause.code : undefined;
         return {

package/dist/main/startup.js

@@ -7,8 +7,15 @@ export const openInitialTarget = async (session, config, serverLogger, writeStde
     });
     if (opened.ok)
         return { ok: true };
-    await session.close();
-    serverLogger.error({ errorTag: opened.error._tag }, "Initial target failed to open");
+    const closed = await session.close();
+    serverLogger.error({
+        error: projectAnalysisError(opened.error),
+        ...(closed.ok
+            ? {}
+            : { cleanup_error: projectAnalysisError(closed.error) }),
+    }, "Initial target failed to open");
     writeStderr(`${projectAnalysisError(opened.error).message}\n`);
+    if (!closed.ok)
+        writeStderr(`${projectAnalysisError(closed.error).message}\n`);
     return { ok: false, exitCode: 1 };
 };

package/dist/main/transport.js

@@ -1,5 +1,6 @@
 import { createAndroidAnalysisProvider } from "../composition/android.js";
 import { createServer } from "../server/createServer.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { MCP_CONNECTION_LOST, MCP_CONNECTION_START_FAILED, } from "./messages.js";
 export const startMcpTransport = async (dependencies, session, serverContext) => {
     const { serverLogger } = serverContext;
@@ -26,10 +27,12 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
     try {
         handle = dependencies.serve(() => {
             // The SDK can discard a discovery probe and construct a replacement server.
-            const android = createAndroidAnalysisProvider(dependencies.env);
+            const android = createAndroidAnalysisProvider(serverContext.environment);
             androidProviders.push(android);
             return (dependencies.createServer ?? createServer)(session, session, {
                 logger: serverContext.logger,
+                environment: serverContext.environment,
+                delivery: serverContext.delivery,
                 ...optionalProviders,
                 androidAnalysis: android,
             });
@@ -41,11 +44,28 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
         });
     }
     catch (cause) {
-        await Promise.allSettled([session.close(), closeAndroid()]);
+        const [binaryCleanup, androidCleanup] = await Promise.allSettled([
+            session.close(),
+            closeAndroid(),
+        ]);
         serverLogger.error({
             error: cause instanceof Error ? cause.message : String(cause),
         }, MCP_CONNECTION_START_FAILED);
         dependencies.writeStderr(`${MCP_CONNECTION_START_FAILED}\n`);
+        if (binaryCleanup.status === "fulfilled" && !binaryCleanup.value.ok) {
+            const cleanupError = projectAnalysisError(binaryCleanup.value.error);
+            serverLogger.error({ cleanup_error: cleanupError }, "Binary provider cleanup failed after MCP startup");
+            dependencies.writeStderr(`${cleanupError.message}\n`);
+        }
+        for (const cleanup of [binaryCleanup, androidCleanup]) {
+            if (cleanup.status === "rejected") {
+                const reason = cleanup.reason instanceof Error
+                    ? cleanup.reason.message
+                    : String(cleanup.reason);
+                serverLogger.error({ cleanup_error: reason }, "Provider cleanup rejected after MCP startup");
+                dependencies.writeStderr(`Provider cleanup failed: ${reason}\n`);
+            }
+        }
         return { ok: false };
     }
     return { ok: true, handle, closeAndroid };

package/dist/main.js

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
+import { snapshotEnvironment } from "./process/snapshotEnvironment.js";
 import { pathToFileURL } from "node:url";
 import { realpathSync } from "node:fs";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
-import { parseConfig } from "./config.js";
+import { parseConfig } from "./config/parseConfig.js";
 import { createBinarySession } from "./composition/binary.js";
 import { createLogger } from "./logger.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 import { SERVER_START_FAILED } from "./main/messages.js";
-import { createRuntimeState } from "./main/state.js";
 import { openInitialTarget } from "./main/startup.js";
 import { startMcpTransport } from "./main/transport.js";
-import { loadOptionalObservationProviders } from "./composition/optionalObservationProviders.js";
-import { registerConfigReload } from "./main/reload.js";
+import { createOptionalObservationFactories, loadOptionalObservationProviders, } from "./composition/optionalObservationProviders.js";
+import { createToolResultDelivery } from "./server/toolResult.js";
 import { createShutdown } from "./main/shutdown.js";
 const runtimeDependencies = () => ({
     env: process.env,
@@ -32,10 +32,6 @@ const runtimeDependencies = () => ({
             process.stdin.off("close", handler);
         };
     },
-    registerReload: (handler) => {
-        process.on("SIGHUP", handler);
-        return () => process.off("SIGHUP", handler);
-    },
 });
 /**
  * Start the long-lived MCP adapter and install idempotent shutdown handlers.
@@ -43,35 +39,32 @@ const runtimeDependencies = () => ({
  * signals close bridge resources without assuming ownership of the Hopper app.
  */
 export const run = async (dependencies = runtimeDependencies()) => {
-    const config = parseConfig(dependencies.env);
+    const environment = snapshotEnvironment(dependencies.env);
+    const config = parseConfig(environment);
     if (!config.ok) {
         dependencies.writeStderr(`${projectAnalysisError(config.error).message}\n`);
         return 1;
     }
     const logger = createLogger("mcp", config.value.logLevel);
     const serverLogger = logger.child({ layer: "server" });
-    const session = createBinarySession(config.value, logger);
+    const session = createBinarySession(config.value, logger, environment);
     const opened = await openInitialTarget(session, config.value, serverLogger, dependencies.writeStderr);
     if (!opened.ok)
         return opened.exitCode;
-    const runtimeState = createRuntimeState(config.value);
     const transport = await startMcpTransport(dependencies, session, {
         logger,
         serverLogger,
-        loadOptionalProviders: dependencies.loadOptionalProviders ?? loadOptionalObservationProviders,
+        environment,
+        delivery: createToolResultDelivery(config.value.mcpMaxResponseBytes),
+        loadOptionalProviders: dependencies.loadOptionalProviders ??
+            (() => loadOptionalObservationProviders(createOptionalObservationFactories(environment))),
     });
     if (!transport.ok)
         return 1;
-    const unregisterReload = registerConfigReload({
-        dependencies,
-        runtimeState,
-        serverLogger,
-    });
     createShutdown({
         handle: transport.handle,
         closeAndroid: transport.closeAndroid,
         session,
-        unregisterReload,
         dependencies,
         serverLogger,
     });

package/dist/mcpDoctor.js

@@ -1,6 +1,6 @@
 import { Client } from "@modelcontextprotocol/client";
 import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
-import { Formatter } from "incur";
+import { Formatter, Help, z } from "incur";
 import { resolve } from "node:path";
 import { CATALOG_IDENTITY } from "./catalogIdentity.js";
 import { PROMPT_CONTRACTS } from "./contracts/promptContracts.js";
@@ -8,6 +8,36 @@ import { TOOL_CONTRACTS } from "./contracts/toolContracts.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
 import { MCP_STARTUP_POLICY } from "./mcpStartupPolicy.js";
 const OUTPUT_FORMATS = ["toon", "json", "yaml", "md", "jsonl"];
+/**
+ * Canonical `rea mcp doctor` options. This schema is the single source of
+ * truth: the argument parser accepts exactly these options (plus the `-h`
+ * alias below) and the help renderer lists them. Keep them in sync by
+ * changing this schema, not either consumer.
+ */
+const MCP_DOCTOR_OPTIONS = z.object({
+    format: z.enum(OUTPUT_FORMATS).optional().describe("Output format"),
+    json: z.boolean().optional().describe("Emit the report as JSON"),
+    fullOutput: z.boolean().optional().describe("Show the full output envelope"),
+    help: z.boolean().optional().describe("Show help"),
+});
+const MCP_DOCTOR_ALIAS = { help: "h" };
+const MCP_DOCTOR_COMMAND = "rea mcp doctor";
+const MCP_DOCTOR_DESCRIPTION = "Validate MCP server startup and tool listing";
+/** Help flags derived from `MCP_DOCTOR_OPTIONS` plus its alias. */
+const HELP_FLAGS = new Set(["--help", "-h"]);
+/**
+ * Answer an advertised help request without starting a diagnostic session.
+ * Global options are hidden because this dispatcher entry accepts only the
+ * options above; the hint says so explicitly instead of implying full
+ * Incur parity.
+ */
+const renderMcpDoctorHelp = () => Help.formatCommand(MCP_DOCTOR_COMMAND, {
+    description: MCP_DOCTOR_DESCRIPTION,
+    hideGlobalOptions: true,
+    options: MCP_DOCTOR_OPTIONS,
+    alias: MCP_DOCTOR_ALIAS,
+    hint: "This entry accepts only the options above.",
+});
 /** Diagnose the actual production stdio adapter with one startup-bounded SDK session. */
 export const runProductionMcpDoctor = async (options) => {
     const deadline = Date.now() + (options.deadlineMs ?? MCP_STARTUP_POLICY.doctorDeadlineMs);
@@ -117,11 +147,14 @@ const inspectProductionMcpSession = async (client, deadline, signal) => {
  */
 export const runProductionMcpDoctorCli = async (arguments_, input) => {
     const parsed = parseOutputArguments(arguments_);
-    if (!parsed.ok)
+    if (!parsed.ok) {
+        if (parsed.help)
+            return { output: `${renderMcpDoctorHelp()}\n`, exitCode: 0 };
         return {
             output: `${Formatter.format({ code: "VALIDATION_ERROR", message: parsed.message }, parsed.format)}\n`,
             exitCode: 1,
         };
+    }
     const result = await runProductionMcpDoctor({
         command: process.execPath,
         args: [resolve(input.dispatcherPath), "mcp"],
@@ -174,6 +207,12 @@ const parseIdentityToolResult = (input) => {
     };
 };
 const parseOutputArguments = (arguments_) => {
+    // Help wins over output selection and validation errors, but only when it
+    // appears in option position. A token consumed as `--format`'s value is
+    // not a flag, so `--format --help` reports an invalid format instead of
+    // masking the typo with usage.
+    if (hasHelpInOptionPosition(arguments_))
+        return { ok: false, help: true };
     let format = "toon";
     for (let index = 0; index < arguments_.length; index += 1) {
         const argument = arguments_[index];
@@ -191,6 +230,7 @@ const parseOutputArguments = (arguments_) => {
             if (!isOutputFormat(candidate))
                 return {
                     ok: false,
+                    help: false,
                     format,
                     message: `Invalid output format: ${candidate ?? "missing"}`,
                 };
@@ -199,14 +239,34 @@ const parseOutputArguments = (arguments_) => {
         }
         if (argument === "--full-output")
             continue;
+        if (HELP_FLAGS.has(argument ?? ""))
+            return { ok: false, help: true };
         return {
             ok: false,
+            help: false,
             format,
             message: `Unknown mcp doctor option: ${argument ?? "missing"}`,
         };
     }
     return { ok: true, format };
 };
+/**
+ * Report whether `--help`/`-h` appears in option position. Tokens consumed
+ * as `--format`'s value are skipped so `--format --help` stays an invalid
+ * format error instead of silently becoming a help request.
+ */
+const hasHelpInOptionPosition = (arguments_) => {
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (argument === "--format") {
+            index += 1;
+            continue;
+        }
+        if (HELP_FLAGS.has(argument ?? ""))
+            return true;
+    }
+    return false;
+};
 const isOutputFormat = (value) => OUTPUT_FORMATS.some((candidate) => candidate === value);
 const requestOptions = (deadline, signal) => ({
     signal,

package/dist/native/AppleDispatchCoverage.js

@@ -7,7 +7,7 @@ const describeFixups = (fixups) => {
 };
 /** Append the per-facet coverage of one Apple dispatch metadata decode. */
 export const pushDispatchCoverage = (input) => {
-    const { result, failures, examined, categoriesExamined, truncated, fixups } = input;
+    const { result, failures, categoryIssues, examined, categoriesExamined, truncated, fixups, vtables, swift, } = input;
     result.coverage.push({
         facet: "objc_class_method_ivar_metadata",
         status: failures.length > 0 || truncated ? "partial" : "complete",
@@ -30,21 +30,25 @@ export const pushDispatchCoverage = (input) => {
         examined: result.relative_pointers.length,
         decoded: result.relative_pointers.filter((item) => item.decode.status === "decoded").length,
     });
-    const categoryFailures = failures.filter((failure) => /^(?:Properties of|Category at)/u.test(failure));
+    const categoryFailures = categoryIssues.map(({ code, location, message }) => `${code}${location === undefined ? "" : ` at ${location}`}: ${message}`);
     result.coverage.push({
         facet: "objc_properties_categories",
-        status: categoryFailures.length > 0 ||
+        status: truncated ||
+            categoryFailures.length > 0 ||
             result.objc_categories.some(({ decode }) => decode.status !== "decoded")
             ? "partial"
             : "complete",
-        reason: categoryFailures.join("; ") || null,
+        reason: [...categoryFailures, ...(truncated ? ["max_records_reached"] : [])].join("; ") || null,
         examined: categoriesExamined,
         decoded: result.objc_categories.filter(({ decode }) => decode.status === "decoded").length,
     });
     result.coverage.push({
         facet: "pointer_fixups",
-        status: fixups.failures.length > 0 ? "partial" : "complete",
-        reason: [describeFixups(fixups), ...fixups.failures].join("; "),
+        status: fixups.issues.length > 0 ? "partial" : "complete",
+        reason: [
+            describeFixups(fixups),
+            ...fixups.issues.map(({ code, location, message }) => `${code}${location === undefined ? "" : ` at ${location}`}: ${message}`),
+        ].join("; "),
         examined: 0,
         decoded: 0,
     });
@@ -55,4 +59,41 @@ export const pushDispatchCoverage = (input) => {
         examined: 0,
         decoded: 0,
     });
+    result.coverage.push({
+        facet: "swift_conformances_static_witness_slots",
+        status: swift.exhaustive &&
+            !truncated &&
+            !result.swift_conformances.some(({ decode }) => decode.status !== "decoded") &&
+            !result.swift_dispatch_slots.some(({ table_kind, decode }) => table_kind === "witness_table" && decode.status !== "decoded")
+            ? "complete"
+            : "partial",
+        reason: [
+            ...swift.issues.map(formatIssue),
+            ...(truncated ? ["max_records_reached"] : []),
+            ...(result.swift_conformances.some(({ decode }) => decode.status !== "decoded") ||
+                result.swift_dispatch_slots.some(({ table_kind, decode }) => table_kind === "witness_table" && decode.status !== "decoded")
+                ? ["swift_records_unresolved"]
+                : []),
+        ].join("; ") || null,
+        examined: swift.examined,
+        decoded: swift.decoded,
+    });
+    result.coverage.push({
+        facet: "swift_class_vtable_descriptors",
+        status: vtables.exhaustive &&
+            !truncated &&
+            !result.swift_dispatch_slots.some(({ table_kind, decode }) => table_kind === "class_vtable" && decode.status !== "decoded")
+            ? "complete"
+            : "partial",
+        reason: [
+            ...vtables.issues.map(formatIssue),
+            ...(truncated ? ["max_records_reached"] : []),
+            ...(result.swift_dispatch_slots.some(({ table_kind, decode }) => table_kind === "class_vtable" && decode.status !== "decoded")
+                ? ["vtable_implementations_unresolved"]
+                : []),
+        ].join("; ") || null,
+        examined: vtables.examined,
+        decoded: vtables.decoded,
+    });
 };
+const formatIssue = ({ code, location, message }) => `${code}${location === undefined ? "" : ` at ${location}`}: ${message}`;

package/dist/native/AppleDispatchDecodeFacts.js

@@ -0,0 +1,6 @@
+export const issue = (facet, code, message, location) => ({
+    facet,
+    code,
+    message,
+    ...(location === undefined ? {} : { location }),
+});