homegraph 1.6.0 → 1.6.1

package/dist/mcp/evidence-audit.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordEvidencePack = recordEvidencePack;
+const node_fs_1 = require("node:fs");
+const node_crypto_1 = require("node:crypto");
+const utils_1 = require("../utils");
+/** Opt-in local evidence only, never an answer cache. Logging cannot break retrieval. */
+function recordEvidencePack(projectRoot, input, output) {
+    if (process.env.HOMEGRAPH_ARKTS_EVIDENCE_LOG !== '1')
+        return 'disabled';
+    let fd;
+    try {
+        const target = (0, utils_1.validatePathWithinRoot)(projectRoot, '.homegraph/evidence-packs.jsonl');
+        if (!target)
+            return 'unavailable';
+        const record = Buffer.from(JSON.stringify({ id: (0, node_crypto_1.randomUUID)(), time: new Date().toISOString(),
+            stage: 'arkts_pack_before_host_wrapping', version: 1, input, output }) + '\n');
+        fd = (0, node_fs_1.openSync)(target, node_fs_1.constants.O_WRONLY | node_fs_1.constants.O_CREAT | node_fs_1.constants.O_APPEND | node_fs_1.constants.O_NONBLOCK | (node_fs_1.constants.O_NOFOLLOW ?? 0), 0o600);
+        if (!(0, node_fs_1.fstatSync)(fd).isFile())
+            return 'unavailable';
+        if ((0, node_fs_1.fstatSync)(fd).size + record.length > 16 * 1024 * 1024)
+            return 'limit';
+        let at = 0;
+        while (at < record.length) {
+            const written = (0, node_fs_1.writeSync)(fd, record, at);
+            if (!written)
+                return 'unavailable';
+            at += written;
+        }
+        return 'written';
+    }
+    catch {
+        return 'unavailable';
+    }
+    finally {
+        if (fd !== undefined)
+            (0, node_fs_1.closeSync)(fd);
+    }
+}
+//# sourceMappingURL=evidence-audit.js.map

package/dist/mcp/implementation-context.d.ts

@@ -0,0 +1,35 @@
+import type { Edge, Node } from '../types';
+export declare const implementationContextEnabled: () => boolean;
+export declare const controlEvidenceEnabled: () => boolean;
+export interface ImplementationGraph {
+    getNode(id: string): Node | null | undefined;
+    getNodesInFile(file: string): Node[];
+    getOutgoingEdges(id: string): Edge[];
+    getIncomingEdges(id: string): Edge[];
+}
+export interface ImplementationGroup {
+    id: string;
+    label: string;
+    nodes: Node[];
+    edges: Edge[];
+    notes: string[];
+    missing: string[];
+    sdk?: {
+        module: string;
+        version: string;
+        nodes: Node[];
+    };
+}
+export interface SdkModule {
+    version: string;
+    nodes: Node[];
+}
+/** No fuzzy symbol lookup: only stored edges and the target file of an actual import.
+ * Source must be hash-verified by the caller before its relationships are expanded.
+ * Limits bound work independently of repository size; gaps survive budget selection.
+ */
+export declare function collectImplementationContext(graph: ImplementationGraph, seeds: Node[], source: (node: Node) => string | undefined, sdkModule?: (module: string) => SdkModule | undefined, moduleBinding?: (importer: string, module: string) => {
+    relativePath: string;
+    witnesses: Node[];
+} | undefined): ImplementationGroup[];
+//# sourceMappingURL=implementation-context.d.ts.map

package/dist/mcp/implementation-context.js

@@ -0,0 +1,232 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controlEvidenceEnabled = exports.implementationContextEnabled = void 0;
+exports.collectImplementationContext = collectImplementationContext;
+const evidence_paths_1 = require("../graph/evidence-paths");
+const request_evidence_1 = require("./request-evidence");
+const path = __importStar(require("node:path"));
+const implementationContextEnabled = () => process.env.HOMEGRAPH_ARKTS_IMPLEMENTATION_CONTEXT !== '0';
+exports.implementationContextEnabled = implementationContextEnabled;
+const controlEvidenceEnabled = () => process.env.HOMEGRAPH_ARKTS_CONTROL_EVIDENCE !== '0';
+exports.controlEvidenceEnabled = controlEvidenceEnabled;
+const DECLARATIONS = new Set(['class', 'struct', 'component', 'interface', 'function', 'method', 'field', 'property', 'type_alias', 'enum', 'variable', 'constant']);
+const TYPES = new Set(['type_of', 'returns', 'instantiates']);
+const at = (n) => `${n.filePath}:${n.startLine}`;
+const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const uses = (code, name) => /^[\w$]+$/.test(name) && new RegExp(`(?<![\\w$])${esc(name)}(?![\\w$])`).test(code);
+/** No fuzzy symbol lookup: only stored edges and the target file of an actual import.
+ * Source must be hash-verified by the caller before its relationships are expanded.
+ * Limits bound work independently of repository size; gaps survive budget selection.
+ */
+function collectImplementationContext(graph, seeds, source, sdkModule, moduleBinding) {
+    const groups = [];
+    const files = new Map();
+    const sdkCache = new Map();
+    const inFile = (file) => {
+        if (!files.has(file))
+            files.set(file, graph.getNodesInFile(file));
+        return files.get(file);
+    };
+    // Import edges may be absent for ArkAnalyzer type-only imports. Resolve the exact
+    // relative module path, including barrel exports, without searching other modules.
+    let moduleReads = 0;
+    const relativeDefinition = (importer, module, name, depth = 0) => {
+        if (!module.startsWith('.') || depth > 2 || moduleReads >= 12)
+            return [];
+        const base = path.posix.normalize(path.posix.join(path.posix.dirname(importer), module));
+        if (base === '..' || base.startsWith('../') || path.posix.isAbsolute(base))
+            return [];
+        const paths = /\.(?:ets|ts)$/.test(base) ? [base] : [base + '.ets', base + '.ts', `${base}/Index.ets`, `${base}/index.ets`, `${base}/index.ts`];
+        const available = paths.map(file => ({ file, nodes: inFile(file) })).filter(x => x.nodes.length);
+        if (available.length !== 1)
+            return [];
+        moduleReads++;
+        const { file, nodes } = available[0];
+        const matches = [...new Map(nodes.filter(n => DECLARATIONS.has(n.kind) && n.name === name)
+                .map(n => [`${n.filePath}:${n.startLine}:${n.name}`, n])).values()];
+        if (matches.length === 1) {
+            const body = source(matches[0]);
+            if (body && new RegExp(`\\bexport\\s+(?:declare\\s+)?(?:class|struct|interface|enum|type|function|const|let|var)\\s+${esc(name)}\\b`).test((0, request_evidence_1.lexEvidenceSource)(body).code))
+                return [[matches[0]]];
+        }
+        const fileNode = { ...nodes[0], id: `context-file:${file}`, name: file, qualifiedName: file, kind: 'file', startLine: 1, endLine: 1 };
+        const body = source(fileNode);
+        if (!body)
+            return [];
+        const out = [];
+        const exportCode = (0, request_evidence_1.lexEvidenceSource)(body);
+        if (!exportCode.valid)
+            return [];
+        for (const m of body.matchAll(/\bexport\s+(\*|\{[^}]+\})\s+from\s*['"]([^'"\r\n]+)['"]/g)) {
+            if (!exportCode.code.slice(m.index).startsWith('export'))
+                continue;
+            let original = name;
+            if (m[1] !== '*') {
+                const binding = m[1].slice(1, -1).split(',').map(x => x.trim().split(/\s+as\s+/))
+                    .find(parts => (parts[1] ?? parts[0]) === name);
+                if (!binding)
+                    continue;
+                original = binding[0];
+            }
+            for (const chain of relativeDefinition(file, m[2], original, depth + 1))
+                out.push([fileNode, ...chain]);
+        }
+        return out;
+    };
+    const queue = seeds.slice(0, 6).map(n => ({ node: n, depth: 0 }));
+    const visited = new Set();
+    const seenEdges = new Set();
+    const seenImports = new Set();
+    let reads = 0;
+    while (queue.length && visited.size < 24 && reads < 48 && groups.length < 24) {
+        const { node, depth } = queue.shift();
+        if (visited.has(node.id) || node.filePath.startsWith('ohos-sdk:'))
+            continue;
+        visited.add(node.id);
+        const body = source(node);
+        if (!body)
+            continue;
+        const parsed = (0, request_evidence_1.lexEvidenceSource)(body);
+        if (!parsed.valid)
+            continue;
+        const own = inFile(node.filePath);
+        // Component → build is containment, not an invented runtime call.
+        const nested = own.filter(n => n.id !== node.id && n.startLine >= node.startLine && n.endLine <= node.endLine
+            && n.kind === 'method' && n.name === 'build').slice(0, 2);
+        if (depth < 2)
+            queue.push(...nested.map(n => ({ node: n, depth: depth + 1 })));
+        const adjacent = [...graph.getOutgoingEdges(node.id), ...graph.getIncomingEdges(node.id)];
+        reads += 2;
+        for (const edge of adjacent.slice(0, 80)) {
+            if (groups.length >= 24)
+                break;
+            const scope = (0, evidence_paths_1.isArkuiScopeEdge)(edge);
+            const outgoing = edge.source === node.id;
+            if (!scope && !(outgoing && TYPES.has(edge.kind)))
+                continue;
+            const key = JSON.stringify([edge.source, edge.target, edge.kind, edge.metadata]);
+            if (seenEdges.has(key))
+                continue;
+            seenEdges.add(key);
+            const other = graph.getNode(outgoing ? edge.target : edge.source);
+            if (!other || other.filePath.startsWith('ohos-sdk:'))
+                continue;
+            groups.push({ id: `impl-edge:${groups.length}`, label: `${scope ? 'render/navigation scope' : 'type dependency'}: ${node.name} ↔ ${other.name}`,
+                nodes: [node, other], edges: [edge], missing: [], notes: scope
+                    ? ['Static wiring only; enclosing conditions and other shared users remain relevant.'] : [] });
+            // Do not fan out from a shared caller into its unrelated siblings.
+            if (outgoing && depth < 2)
+                queue.push({ node: other, depth: depth + 1 });
+        }
+        if (adjacent.length > 80)
+            groups.push({ id: `impl-limit:${node.id}`, label: 'context expansion limit', nodes: [node], edges: [],
+                notes: [], missing: [`additional relationships at ${at(node)}`] });
+        for (const imp of own.filter(n => n.kind === 'import').slice(0, 40)) {
+            if (groups.length >= 24 || seenImports.has(imp.id) || !uses(parsed.code, imp.name))
+                continue;
+            seenImports.add(imp.id);
+            const importSource = source(imp);
+            if (!importSource)
+                continue;
+            const importCode = (0, request_evidence_1.lexEvidenceSource)(importSource);
+            const match = [...importSource.matchAll(/\bimport\s+([\s\S]*?)\s+from\s*['"]([^'"\r\n]+)['"]/g)]
+                .find(m => importCode.valid && importCode.code.slice(m.index).startsWith('import'));
+            if (!match)
+                continue;
+            const clause = match[1];
+            const module = match[2];
+            const aliases = [...clause.matchAll(/([\w$]+)\s+as\s+([\w$]+)/g)];
+            const name = aliases.find(a => a[2] === imp.name)?.[1] ?? imp.name;
+            const group = { id: `impl-import:${imp.id}`, label: `import ${imp.name} from ${module}`,
+                nodes: [node, imp], edges: [], notes: [], missing: [] };
+            const links = graph.getOutgoingEdges(imp.id).filter(e => e.kind === 'imports');
+            reads++;
+            for (const link of links.slice(0, 4)) {
+                const target = graph.getNode(link.target);
+                if (!target || target.filePath.startsWith('ohos-sdk:'))
+                    continue;
+                const pool = target.kind === 'file' ? inFile(target.filePath) : [target];
+                const matches = pool.filter(n => DECLARATIONS.has(n.kind) && n.name === name);
+                const unique = [...new Map(matches.map(n => [`${n.filePath}:${n.startLine}:${n.name}`, n])).values()];
+                if (unique.length === 1) {
+                    group.nodes.push(unique[0]);
+                    group.edges.push(link);
+                }
+                // Export declarations are evidence of the public boundary, never proof that every file-local name is exported.
+                const exports = pool.filter(n => n.kind === 'export' && (n.name === name || uses(n.signature ?? '', name))).slice(0, 3);
+                group.nodes.push(...exports);
+            }
+            if (group.nodes.length === 2) {
+                const binding = module.startsWith('.') ? undefined : moduleBinding?.(imp.filePath, module);
+                const chains = relativeDefinition(imp.filePath, binding?.relativePath ?? module, name);
+                if (chains.length === 1)
+                    group.nodes.push(...(binding?.witnesses ?? []), ...chains[0]);
+                else if (chains.length > 1)
+                    group.missing.push(`ambiguous export ${name} from ${module}`);
+            }
+            if (group.nodes.length === 2 && /^@(?:kit|ohos|hms)\./.test(module) && sdkModule) {
+                if (!sdkCache.has(module))
+                    sdkCache.set(module, sdkModule(module));
+                const sdk = sdkCache.get(module);
+                if (sdk) {
+                    const memberNames = new Set([name]);
+                    for (const m of parsed.code.matchAll(new RegExp(`\\b${esc(imp.name)}\\s*\\.\\s*([\\w$]+)`, 'g')))
+                        memberNames.add(m[1]);
+                    const sdkNodes = sdk.nodes.filter(n => n.signature && memberNames.has(n.name));
+                    // Complete parameter objects are a group: include declared fields of referenced types.
+                    const signature = sdkNodes.map(n => n.signature).join('\n');
+                    const types = sdk.nodes.filter(n => ['interface', 'class', 'type_alias', 'enum'].includes(n.kind) && uses(signature, n.name));
+                    const selected = [...new Map([...sdkNodes, ...types, ...sdk.nodes.filter(n => types.some(t => n.filePath === t.filePath && n.startLine >= t.startLine && n.endLine <= t.endLine))].map(n => [n.id, n])).values()];
+                    if (selected.length && selected.length <= 32) {
+                        group.sdk = { module, version: sdk.version, nodes: selected };
+                        group.notes.push('Bounded SDK signature bundle; inherited/indirect types, API availability and runtime requirements remain unverified.');
+                    }
+                    else
+                        group.missing.push(`SDK signature/type closure for ${module}.${name}`);
+                }
+            }
+            if (group.nodes.length === 2 && !group.sdk)
+                group.missing.push(`resolved definition/export of ${imp.name} from ${module} (${at(imp)})`);
+            group.notes.push('Import/definition evidence does not prove module installation or public export availability.');
+            groups.push(group);
+        }
+    }
+    if (queue.length)
+        groups.push({ id: 'impl-limit', label: 'context expansion limit', nodes: [], edges: [], notes: [],
+            missing: [at(queue[0].node)] });
+    return groups;
+}
+//# sourceMappingURL=implementation-context.js.map

package/dist/mcp/query-cache.d.ts

@@ -1,21 +1,7 @@
-/**
- * MCP query cache — memory key index + serialized tool responses in homegraph.db.
- *
- * A per-project in-memory Set of cache keys gives O(1) negative lookup so misses
- * skip the SQLite SELECT. Payloads stay in homegraph.db; the Set is warmed from
- * DB on first use after daemon restart when the index stamp is still valid.
- *
- * Invalidated wholesale when the index stamp or cache format version changes.
- * Per-call staleness/worktree notices are applied AFTER cache lookup so hits
- * stay fresh.
- *
- * The key Set lives on the daemon main thread only (cache read/write runs there
- * before/after worker-pool explore dispatch), so no cross-thread locking is needed.
- */
 import type { QueryBuilder } from '../db/queries';
 import type { ToolResult } from './tools';
 /** Bump when cache-key normalization or cached payload shape changes. */
-export declare const QUERY_CACHE_FORMAT_VERSION = 5;
+export declare const QUERY_CACHE_FORMAT_VERSION = 7;
 export declare function isMcpQueryCacheEnabled(): boolean;
 export declare function isCacheableMcpTool(toolName: string): boolean;
 /**

package/dist/mcp/query-cache.js

@@ -1,4 +1,14 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpQueryCacheIndex = exports.QUERY_CACHE_FORMAT_VERSION = void 0;
+exports.isMcpQueryCacheEnabled = isMcpQueryCacheEnabled;
+exports.isCacheableMcpTool = isCacheableMcpTool;
+exports.getMcpQueryCacheIndex = getMcpQueryCacheIndex;
+exports.resetMcpQueryCacheIndices = resetMcpQueryCacheIndices;
+exports.normalizeExploreQueryTerms = normalizeExploreQueryTerms;
+exports.buildMcpQueryCacheFingerprint = buildMcpQueryCacheFingerprint;
+exports.buildMcpQueryCacheKey = buildMcpQueryCacheKey;
+const request_contract_1 = require("../search/request-contract");
 /**
  * MCP query cache — memory key index + serialized tool responses in homegraph.db.
  *
@@ -13,15 +23,6 @@
  * The key Set lives on the daemon main thread only (cache read/write runs there
  * before/after worker-pool explore dispatch), so no cross-thread locking is needed.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.McpQueryCacheIndex = exports.QUERY_CACHE_FORMAT_VERSION = void 0;
-exports.isMcpQueryCacheEnabled = isMcpQueryCacheEnabled;
-exports.isCacheableMcpTool = isCacheableMcpTool;
-exports.getMcpQueryCacheIndex = getMcpQueryCacheIndex;
-exports.resetMcpQueryCacheIndices = resetMcpQueryCacheIndices;
-exports.normalizeExploreQueryTerms = normalizeExploreQueryTerms;
-exports.buildMcpQueryCacheFingerprint = buildMcpQueryCacheFingerprint;
-exports.buildMcpQueryCacheKey = buildMcpQueryCacheKey;
 const node_crypto_1 = require("node:crypto");
 const query_plan_1 = require("../search/query-plan");
 const PLAN_RELATIONS = new Set(query_plan_1.QUERY_RELATIONS);
@@ -35,7 +36,7 @@ function defaultExploreMaxFiles(fileCount) {
     return 8;
 }
 /** Bump when cache-key normalization or cached payload shape changes. */
-exports.QUERY_CACHE_FORMAT_VERSION = 5;
+exports.QUERY_CACHE_FORMAT_VERSION = 7;
 const METADATA_INDEX_STAMP = 'query_cache_index_stamp';
 const METADATA_FORMAT_VERSION = 'query_cache_format_version';
 /** Tools that must stay live — never cached. */
@@ -146,7 +147,7 @@ function exploreEnvFingerprint() {
     const fullSource = process.env.HOMEGRAPH_EXPLORE_FULL_SOURCE === '1' ? '1' : '0';
     const evidencePacks = process.env.HOMEGRAPH_ARKTS_EVIDENCE_PACKS === '0' ? '0' : '1';
     const queryPaths = process.env.HOMEGRAPH_ARKTS_QUERY_PATHS === '0' ? '0' : '1';
-    return `linums:${linums}|adaptive:${adaptive}|rankMultiterm:${rankMultiterm}|fullSource:${fullSource}|arktsEvidence:${evidencePacks}|arktsPaths:${queryPaths}`;
+    return `implementationContext:${process.env.HOMEGRAPH_ARKTS_IMPLEMENTATION_CONTEXT === '0' ? '0' : '1'}|controlEvidence:${process.env.HOMEGRAPH_ARKTS_CONTROL_EVIDENCE === '0' ? '0' : '1'}|linums:${linums}|adaptive:${adaptive}|rankMultiterm:${rankMultiterm}|fullSource:${fullSource}|arktsEvidence:${evidencePacks}|arktsPaths:${queryPaths}|accuracyTargets:${process.env.HOMEGRAPH_ACCURACY_TARGETS === '0' ? '0' : '1'}|accuracyCoverage:${process.env.HOMEGRAPH_ACCURACY_COVERAGE === '0' ? '0' : '1'}`;
 }
 function normalizeString(value) {
     if (typeof value !== 'string')
@@ -213,7 +214,15 @@ function queryPlanFingerprint(value) {
     if (!features || Object.keys(features).length > 64
         || !Object.values(features).every(v => typeof v === 'boolean'))
         return undefined;
+    let requestContract;
+    try {
+        requestContract = (0, request_contract_1.validateRequestContract)(plan.requestContract, originalQuery + '\n' + (query(plan.taskContext) ?? ''));
+    }
+    catch {
+        return undefined;
+    }
     return stableJson({
+        requestContract,
         version: plan.version, originalQuery, canonicalQuery, intent, route,
         taskContext: query(plan.taskContext),
         anchors, searchTerms, steps, features,

package/dist/mcp/request-evidence.d.ts

@@ -0,0 +1,69 @@
+import type { RequestContract, RequestTarget } from '../search/request-contract';
+export interface RequestSource {
+    filePath: string;
+    start: number;
+    source: string;
+}
+interface StringToken {
+    start: number;
+    end: number;
+    value: string;
+}
+interface Lexed {
+    code: string;
+    strings: StringToken[];
+    pairs: Map<number, number>;
+    valid: boolean;
+}
+export interface TargetEvidence {
+    id: string;
+    text: string;
+    presence: RequestTarget['presence'];
+    status: 'observed' | 'ambiguous' | 'not_observed' | 'requested_not_observed';
+    locations: string[];
+    note: string;
+}
+export interface BehaviorEvidence {
+    id: string;
+    text: string;
+    kind: string;
+    status: 'binding_observed' | 'binding_not_observed' | 'unknown';
+    locations: string[];
+    note: string;
+}
+export interface RequestEvidence {
+    scope: 'returned_source_only';
+    runtimeVerified: false;
+    targets: TargetEvidence[];
+    behaviors: BehaviorEvidence[];
+}
+/** Conservative lexical witness reader. It does not evaluate ArkTS or infer data flow.
+ * Mask comments, strings, templates and regular expressions before reading structure.
+ * Escaped/interpolated strings are deliberately not used as exact literal witnesses.
+ */
+export declare function lexEvidenceSource(source: string): Lexed;
+/** Reuse one analysis per verified source unit; no disk reads or model calls. */
+export declare function createRequestEvidenceInspector(contract: RequestContract): {
+    score: (units: RequestSource[]) => number;
+    inspect: (units: RequestSource[]) => RequestEvidence;
+};
+export declare function renderRequestEvidence(evidence: RequestEvidence, targets: boolean, behaviors: boolean): string[];
+export interface ControlEvidence {
+    location: string;
+    control: string;
+    labels: string[];
+    enabled: 'binding_observed' | 'binding_not_observed' | 'unknown';
+    expression?: string;
+    click?: string;
+    state: Array<{
+        expression: string;
+        writeLocations: string[];
+    }>;
+}
+/** An inventory of returned controls, not a natural-language target match or a UI test.
+ * Resource names stay literal: an icon called "undo" is not translated into a task label.
+ */
+export declare function inspectControlEvidence(units: RequestSource[]): ControlEvidence[];
+export declare function renderControlEvidence(rows: ControlEvidence[]): string[];
+export {};
+//# sourceMappingURL=request-evidence.d.ts.map