reverseport 0.0.0-stage → 1.2.0

package/dist/domain/bundleComparison.js

@@ -0,0 +1,243 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { parseEvidenceBundle, serializeEvidenceBundle, } from "./evidenceBundle.js";
+import { digestSchema } from "./../domain/digests.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
+import { comparisonStatusSchema } from "./comparisonStatus.js";
+import { localPathStringSchema } from "./localPath.js";
+const evidenceIdSchema = prefixedDigestSchema("ev");
+const classificationSchema = z.enum([
+    "added",
+    "removed",
+    "changed",
+    "unknown",
+    "history_advanced",
+    "history_diverged",
+]);
+/** Strict input for canonical Evidence bundle comparison. */
+export const bundleComparisonInputSchema = z.strictObject({
+    left_bundle_path: localPathStringSchema,
+    right_bundle_path: localPathStringSchema,
+    record_pairs: z
+        .array(z.object({
+        left_evidence_id: evidenceIdSchema,
+        right_evidence_id: evidenceIdSchema,
+    }))
+        .default([]),
+});
+const bundleChangeSchema = z.object({
+    entity: z.enum(["evidence", "residual_unknown"]),
+    key: z.string().min(1),
+    classification: classificationSchema,
+    conclusion_kind: z.enum([
+        "observed_change",
+        "contradiction",
+        "unresolved_branch",
+    ]),
+    left_evidence_ids: z.array(evidenceIdSchema),
+    right_evidence_ids: z.array(evidenceIdSchema),
+    left_digest: digestSchema.nullable(),
+    right_digest: digestSchema.nullable(),
+    limitations: z.array(z.string()),
+});
+/** Deterministic classified delta between two canonical Evidence bundles. */
+export const bundleComparisonResultSchema = z.object({
+    status: comparisonStatusSchema,
+    left_bundle_sha256: digestSchema,
+    right_bundle_sha256: digestSchema,
+    summary: z.object({
+        records_unchanged: z.number().int().min(0),
+        records_added: z.number().int().min(0),
+        records_removed: z.number().int().min(0),
+        records_changed: z.number().int().min(0),
+        unknowns_unchanged: z.number().int().min(0),
+        unknowns_added: z.number().int().min(0),
+        unknowns_removed: z.number().int().min(0),
+        unknowns_advanced: z.number().int().min(0),
+        unknowns_diverged: z.number().int().min(0),
+        unresolved: z.number().int().min(0),
+    }),
+    changes: z.array(bundleChangeSchema),
+    limitations: z.array(z.string()),
+});
+/** Compare canonical bundle membership and only explicitly paired observations. */
+export const compareBundles = (leftInput, rightInput, recordPairs = []) => {
+    const left = parseEvidenceBundle(leftInput);
+    const right = parseEvidenceBundle(rightInput);
+    const leftDigest = bundleDigest(left);
+    const rightDigest = bundleDigest(right);
+    const recordResult = compareRecords(left, right, recordPairs);
+    const unknownResult = compareUnknowns(left, right);
+    const changes = [...recordResult.changes, ...unknownResult.changes].sort(compareChanges);
+    const unresolved = changes.filter(({ conclusion_kind: kind }) => kind !== "observed_change").length;
+    return bundleComparisonResultSchema.parse({
+        status: leftDigest === rightDigest && changes.length === 0
+            ? "unchanged"
+            : unresolved > 0
+                ? "unknown"
+                : "changed",
+        left_bundle_sha256: leftDigest,
+        right_bundle_sha256: rightDigest,
+        summary: {
+            ...recordResult.summary,
+            ...unknownResult.summary,
+            unresolved,
+        },
+        changes,
+        limitations: changes.some(({ limitations }) => limitations.length > 0)
+            ? [
+                "EvidenceBundle has no inventory completeness marker; one-sided membership remains unknown.",
+            ]
+            : [],
+    });
+};
+const compareRecords = (left, right, pairs) => {
+    const leftIds = new Set(left.records.map(({ evidence_id: id }) => id));
+    const rightIds = new Set(right.records.map(({ evidence_id: id }) => id));
+    const pairedLeft = new Set();
+    const pairedRight = new Set();
+    const changes = [];
+    let changed = 0;
+    for (const pair of pairs) {
+        if (!leftIds.has(pair.left_evidence_id))
+            throw new TypeError(`Explicit pair references missing left evidence ${pair.left_evidence_id}`);
+        if (!rightIds.has(pair.right_evidence_id))
+            throw new TypeError(`Explicit pair references missing right evidence ${pair.right_evidence_id}`);
+        if (pairedLeft.has(pair.left_evidence_id) ||
+            pairedRight.has(pair.right_evidence_id))
+            throw new TypeError("Explicit evidence pairs must be one-to-one");
+        pairedLeft.add(pair.left_evidence_id);
+        pairedRight.add(pair.right_evidence_id);
+        if (pair.left_evidence_id === pair.right_evidence_id)
+            continue;
+        changed += 1;
+        changes.push({
+            entity: "evidence",
+            key: `pair:${pair.left_evidence_id}:${pair.right_evidence_id}`,
+            classification: "changed",
+            conclusion_kind: "observed_change",
+            left_evidence_ids: [pair.left_evidence_id],
+            right_evidence_ids: [pair.right_evidence_id],
+            left_digest: pair.left_evidence_id.slice(3),
+            right_digest: pair.right_evidence_id.slice(3),
+            limitations: [],
+        });
+    }
+    const common = [...leftIds].filter((id) => rightIds.has(id) && !pairedLeft.has(id) && !pairedRight.has(id));
+    const removed = [...leftIds].filter((id) => !pairedLeft.has(id) && (!rightIds.has(id) || pairedRight.has(id)));
+    const added = [...rightIds].filter((id) => !pairedRight.has(id) && (!leftIds.has(id) || pairedLeft.has(id)));
+    for (const [ids, side] of [
+        [removed, "left"],
+        [added, "right"],
+    ])
+        for (const id of ids)
+            changes.push({
+                entity: "evidence",
+                key: id,
+                classification: "unknown",
+                conclusion_kind: "unresolved_branch",
+                left_evidence_ids: side === "left" ? [id] : [],
+                right_evidence_ids: side === "right" ? [id] : [],
+                left_digest: side === "left" ? id.slice(3) : null,
+                right_digest: side === "right" ? id.slice(3) : null,
+                limitations: [
+                    "EvidenceBundle has no inventory completeness marker; one-sided membership may reflect incomplete capture.",
+                ],
+            });
+    return {
+        changes,
+        summary: {
+            records_unchanged: common.length + pairs.length - changed,
+            records_added: 0,
+            records_removed: 0,
+            records_changed: changed,
+        },
+    };
+};
+const compareUnknowns = (left, right) => {
+    const leftHistories = histories(left.unknowns);
+    const rightHistories = histories(right.unknowns);
+    const ids = [...new Set([...leftHistories.keys(), ...rightHistories.keys()])];
+    const changes = [];
+    const summary = {
+        unknowns_unchanged: 0,
+        unknowns_added: 0,
+        unknowns_removed: 0,
+        unknowns_advanced: 0,
+        unknowns_diverged: 0,
+    };
+    for (const id of ids) {
+        const leftHistory = leftHistories.get(id);
+        const rightHistory = rightHistories.get(id);
+        if (leftHistory === undefined || rightHistory === undefined) {
+            changes.push(unknownChange(id, "unknown", leftHistory, rightHistory));
+            continue;
+        }
+        const leftDigests = leftHistory.map(({ revision_digest: digest }) => digest);
+        const rightDigests = rightHistory.map(({ revision_digest: digest }) => digest);
+        if (same(leftDigests, rightDigests)) {
+            summary.unknowns_unchanged += 1;
+            continue;
+        }
+        const advanced = isPrefix(leftDigests, rightDigests) ||
+            isPrefix(rightDigests, leftDigests);
+        summary[advanced ? "unknowns_advanced" : "unknowns_diverged"] += 1;
+        changes.push(unknownChange(id, advanced ? "history_advanced" : "history_diverged", leftHistory, rightHistory));
+    }
+    return { changes, summary };
+};
+const unknownChange = (id, classification, left, right) => ({
+    entity: "residual_unknown",
+    key: id,
+    classification,
+    conclusion_kind: classification === "history_diverged"
+        ? "contradiction"
+        : classification === "history_advanced"
+            ? "observed_change"
+            : "unresolved_branch",
+    left_evidence_ids: historyEvidenceIds(left ?? []),
+    right_evidence_ids: historyEvidenceIds(right ?? []),
+    left_digest: left?.at(-1)?.revision_digest ?? null,
+    right_digest: right?.at(-1)?.revision_digest ?? null,
+    limitations: left === undefined || right === undefined
+        ? [
+            "EvidenceBundle has no inventory completeness marker; one-sided history membership remains unknown.",
+        ]
+        : [],
+});
+const histories = (unknowns) => {
+    const output = new Map();
+    for (const unknown of unknowns) {
+        const history = output.get(unknown.unknown_id) ?? [];
+        history.push(unknown);
+        output.set(unknown.unknown_id, history);
+    }
+    return output;
+};
+const historyEvidenceIds = (history) => [
+    ...new Set(history.flatMap((item) => [
+        ...item.supporting_evidence_ids,
+        ...item.contradicting_evidence_ids,
+        ...item.mutation_evidence_ids,
+        ...(item.resolution?.evidence_ids ?? []),
+    ])),
+].sort(ascii);
+const bundleDigest = (bundle) => createHash("sha256").update(serializeEvidenceBundle(bundle)).digest("hex");
+const same = (left, right) => left.length === right.length &&
+    left.every((value, index) => value === right[index]);
+const isPrefix = (shorter, longer) => shorter.length < longer.length &&
+    shorter.every((value, index) => value === longer[index]);
+const ascii = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const compareChanges = (left, right) => ascii([
+    left.entity,
+    left.key,
+    left.classification,
+    left.left_digest ?? "",
+    left.right_digest ?? "",
+].join("\u0000"), [
+    right.entity,
+    right.key,
+    right.classification,
+    right.left_digest ?? "",
+    right.right_digest ?? "",
+].join("\u0000"));

package/dist/domain/callPath.js

@@ -0,0 +1,301 @@
+import { callPathInputSchema, callPathResultSchema, parseCallPathAddress, } from "./callPathSchemas.js";
+import { parseFunctionEvidence, } from "./functionDossierEvidence.js";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
+/** Minimal directed caller-to-callee adjacency for call-path search. */
+class CallGraph {
+    successors = new Map();
+    predecessors = new Map();
+    mergeNode(node) {
+        if (!this.successors.has(node))
+            this.successors.set(node, new Set());
+        if (!this.predecessors.has(node))
+            this.predecessors.set(node, new Set());
+    }
+    mergeDirectedEdge(source, target) {
+        this.mergeNode(source);
+        this.mergeNode(target);
+        this.successors.get(source)?.add(target);
+        this.predecessors.get(target)?.add(source);
+    }
+    hasNode(node) {
+        return this.successors.has(node);
+    }
+    outDegree(node) {
+        return this.successors.get(node)?.size ?? 0;
+    }
+    outNeighbors(node) {
+        return [...(this.successors.get(node) ?? [])];
+    }
+    inNeighbors(node) {
+        return [...(this.predecessors.get(node) ?? [])];
+    }
+}
+/** Shortest remaining distance for every node that can reach the goal. */
+const distancesToGoal = (graph, goal) => {
+    if (!graph.hasNode(goal))
+        return new Map();
+    const depth = new Map([[goal, 0]]);
+    const queue = [goal];
+    for (let index = 0; index < queue.length; index += 1) {
+        const node = queue[index] ?? "";
+        const next = (depth.get(node) ?? 0) + 1;
+        for (const neighbor of graph.inNeighbors(node)) {
+            if (!depth.has(neighbor)) {
+                depth.set(neighbor, next);
+                queue.push(neighbor);
+            }
+        }
+    }
+    return depth;
+};
+/** Reconstruct direct-callee paths from explicit analyze_function Evidence. */
+export const buildCallPath = (input) => {
+    const parsed = callPathInputSchema.parse(input);
+    const { snapshots, graph } = prepareCallGraph(parsed);
+    const search = inspectSearch({
+        graph,
+        snapshots,
+        start: parsed.start.address,
+        goal: parsed.goal.address,
+    });
+    const goalDistances = distancesToGoal(graph, parsed.goal.address);
+    const shortestDepth = goalDistances.get(parsed.start.address) ?? null;
+    const paths = shortestDepth === null
+        ? []
+        : enumeratePaths({
+            graph,
+            start: parsed.start.address,
+            goal: parsed.goal.address,
+            goalDistances,
+        }).paths.map((path) => citePath(path, snapshots));
+    const shortestHops = paths[0]?.hops;
+    const found = shortestHops !== undefined;
+    const exhaustive = search.exhaustive;
+    const limitations = search.limitations;
+    const resultContext = {
+        start: parsed.start.address,
+        goal: parsed.goal.address,
+        explored: summarizeSearch(graph, search.reached),
+        evidence_links: uniqueEvidence(snapshots.values()),
+        limitations: [...new Set(limitations)].sort(compareUnicodeCodePoints),
+    };
+    const searchScope = { exhaustive };
+    if (found)
+        return callPathResultSchema.parse({
+            ...resultContext,
+            status: "found",
+            shortest_hops: shortestHops,
+            search_scope: searchScope,
+            paths,
+        });
+    return callPathResultSchema.parse({
+        ...resultContext,
+        status: exhaustive ? "not_found" : "unknown",
+        shortest_hops: null,
+        search_scope: searchScope,
+        paths: [],
+    });
+};
+const summarizeSearch = (graph, reached) => ({
+    nodes: reached.size,
+    edges: [...reached.keys()].reduce((count, node) => count + (graph.hasNode(node) ? graph.outDegree(node) : 0), 0),
+    depth_reached: [...reached.values()].reduce((maximum, depth) => Math.max(maximum, depth), 0),
+});
+const prepareCallGraph = (input) => {
+    const snapshots = parseSnapshots(input.functions);
+    assertCompatible(snapshots);
+    if (!snapshots.has(input.start.address))
+        throw new TypeError(`No analyze_function Evidence was supplied for start ${input.start.address}`);
+    return { snapshots, graph: createGraph(snapshots) };
+};
+const parseSnapshots = (groups) => {
+    const snapshots = new Map();
+    for (const group of groups) {
+        const snapshot = parseFunctionEvidence(group);
+        const address = parseCallPathAddress(snapshot.dossier.procedure.address);
+        for (const callee of snapshot.dossier.callees)
+            parseCallPathAddress(callee.address);
+        if (snapshots.has(address))
+            throw new TypeError(`Duplicate function Evidence for ${address}`);
+        snapshots.set(address, snapshot);
+    }
+    return snapshots;
+};
+const assertCompatible = (snapshots) => {
+    const firstEntry = snapshots.values().next();
+    if (firstEntry.done)
+        return;
+    const first = firstEntry.value;
+    for (const snapshot of snapshots.values()) {
+        if (snapshot.subject.digest.sha256 !== first.subject.digest.sha256 ||
+            snapshot.subject.format !== first.subject.format ||
+            snapshot.subject.architecture !== first.subject.architecture)
+            throw new TypeError("Call-path Evidence mixes artifact subjects");
+        if (snapshot.evidence.provider.id !== first.evidence.provider.id ||
+            snapshot.evidence.provider.name !== first.evidence.provider.name ||
+            snapshot.evidence.provider.version !== first.evidence.provider.version)
+            throw new TypeError("Call-path Evidence mixes providers");
+    }
+};
+const createGraph = (snapshots) => {
+    const graph = new CallGraph();
+    for (const [address, snapshot] of snapshots) {
+        graph.mergeNode(address);
+        for (const callee of snapshot.dossier.callees) {
+            const calleeAddress = parseCallPathAddress(callee.address);
+            graph.mergeNode(calleeAddress);
+            graph.mergeDirectedEdge(address, calleeAddress);
+        }
+    }
+    return graph;
+};
+const inspectSearch = ({ graph, snapshots, start, goal, }) => {
+    if (!graph.hasNode(start))
+        return {
+            graph,
+            snapshots,
+            reached: new Map(),
+            exhaustive: false,
+            limitations: [
+                `No analyze_function Evidence was supplied for start ${start}`,
+            ],
+        };
+    const reached = new Map([[start, 0]]);
+    const queue = [start];
+    const limitations = [];
+    let incompleteExpandedCoverage = false;
+    for (let index = 0; index < queue.length; index += 1) {
+        const node = queue[index];
+        if (node === undefined)
+            continue;
+        const depth = reached.get(node) ?? 0;
+        const snapshot = snapshots.get(node);
+        if (snapshot !== undefined) {
+            const coverage = snapshot.evidence.relationship_coverage;
+            for (const limitation of snapshot.limitations)
+                limitations.push(limitation);
+            if (coverage?.status === "partial")
+                for (const limitation of coverage.limitations)
+                    limitations.push(limitation);
+            else if (coverage?.status === "unknown")
+                limitations.push(coverage.reason);
+            for (const diagnostic of coverage !== null && "diagnostics" in coverage
+                ? coverage.diagnostics
+                : [])
+                limitations.push(diagnostic);
+            // The requested goal is a terminal for this search. Its outgoing edges
+            // cannot add a path to the goal, so its dossier limits are contextual
+            // but do not make the searched start-to-goal closure incomplete.
+            if (node === goal)
+                continue;
+            // Explicit, Evidence-bound relationship coverage owns completeness;
+            // generic provider/dossier limitations remain contextual. Legacy Evidence
+            // without that metadata retains its conservative limitation-based rule.
+            if (coverage === null
+                ? snapshot.limitations.length > 0
+                : coverage.status !== "complete")
+                incompleteExpandedCoverage = true;
+        }
+        else if (node === goal) {
+            continue;
+        }
+        if (snapshot === undefined) {
+            limitations.push(`No analyze_function Evidence covers reachable function ${node}`);
+            incompleteExpandedCoverage = true;
+            continue;
+        }
+        const neighbors = graph.outNeighbors(node).sort(compareUnicodeCodePoints);
+        for (const neighbor of neighbors)
+            if (!reached.has(neighbor)) {
+                reached.set(neighbor, depth + 1);
+                queue.push(neighbor);
+            }
+    }
+    return {
+        graph,
+        snapshots,
+        reached,
+        exhaustive: !incompleteExpandedCoverage,
+        limitations,
+    };
+};
+const enumeratePaths = ({ graph, start, goal, goalDistances, }) => {
+    const output = [];
+    const path = [start];
+    const neighbors = new Map();
+    const frame = (node) => {
+        let candidates = neighbors.get(node);
+        if (candidates === undefined) {
+            const distance = goalDistances.get(node);
+            candidates = graph
+                .outNeighbors(node)
+                .filter((neighbor) => distance !== undefined &&
+                goalDistances.get(neighbor) === distance - 1)
+                .sort(compareUnicodeCodePoints);
+            neighbors.set(node, candidates);
+        }
+        return { neighbors: candidates, nextIndex: 0 };
+    };
+    const pending = [frame(start)];
+    while (pending.length > 0) {
+        const current = pending.at(-1);
+        if (current === undefined)
+            break;
+        if (path.at(-1) === goal) {
+            output.push([...path]);
+            pending.pop();
+            path.pop();
+            continue;
+        }
+        const neighbor = current.neighbors[current.nextIndex];
+        if (neighbor === undefined) {
+            pending.pop();
+            path.pop();
+            continue;
+        }
+        current.nextIndex += 1;
+        path.push(neighbor);
+        pending.push(frame(neighbor));
+    }
+    return { paths: output };
+};
+const citePath = (addresses, snapshots) => {
+    const edges = addresses.slice(0, -1).map((source, index) => {
+        const target = addresses[index + 1];
+        if (target === undefined)
+            throw new TypeError("Call path has an invalid edge");
+        return {
+            source,
+            target,
+            evidence_links: snapshotLinks(snapshots.get(source)),
+        };
+    });
+    const nodes = addresses.map((address, index) => {
+        const snapshot = snapshots.get(address);
+        const supporting = snapshot ??
+            (index > 0 ? snapshots.get(addresses[index - 1] ?? "") : undefined);
+        return {
+            address,
+            name: snapshot?.dossier.procedure.name ?? null,
+            evidence_links: snapshotLinks(supporting),
+        };
+    });
+    return {
+        hops: edges.length,
+        nodes,
+        edges,
+        evidence_links: [
+            ...new Set(edges
+                .flatMap(({ evidence_links: links }) => links)
+                .concat(nodes.flatMap(({ evidence_links: links }) => links))),
+        ],
+    };
+};
+const snapshotLinks = (snapshot) => {
+    if (snapshot === undefined)
+        throw new TypeError("Every call-path claim requires supporting Evidence");
+    return [snapshot.evidence.evidence_id];
+};
+const uniqueEvidence = (snapshots) => [
+    ...new Set([...snapshots].flatMap((snapshot) => snapshotLinks(snapshot))),
+].sort(compareUnicodeCodePoints);

package/dist/domain/callPathSchemas.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { emptyArraySchema } from "./emptyArraySchema.js";
+import { evidenceSchema } from "./evidence.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
+const addressSchema = z
+    .string()
+    .regex(/^(?:(?:[A-Za-z0-9._~\x2d]|%[0-9A-F]{2})+:)?0x(?:0|[1-9a-f][0-9a-f]*)$/u);
+const inputAddressSchema = z
+    .string()
+    .regex(/^(?:(?:[A-Za-z0-9._~\x2d]|%[0-9a-fA-F]{2})+:)?0[xX][0-9a-fA-F]+$/u)
+    .transform((address) => {
+    const separator = address.lastIndexOf(":") + 1;
+    const space = address
+        .slice(0, separator)
+        .replace(/%[0-9a-fA-F]{2}/gu, (escape) => escape.toUpperCase());
+    return `${space}0x${BigInt(address.slice(separator)).toString(16)}`;
+});
+const evidenceIdSchema = prefixedDigestSchema("ev");
+/** Normalize a hexadecimal offset while preserving its optional address space. */
+export const parseCallPathAddress = (input) => inputAddressSchema.parse(input);
+/** Strict input for explicit call-path reconstruction from complete dossiers. */
+export const callPathInputSchema = z.strictObject({
+    functions: z.array(evidenceSchema).min(1),
+    start: z.object({ address: inputAddressSchema }).strict(),
+    goal: z.object({ address: inputAddressSchema }).strict(),
+});
+const citedNodeSchema = z.object({
+    address: addressSchema,
+    name: z.string().nullable(),
+    evidence_links: z.array(evidenceIdSchema).min(1),
+});
+const citedEdgeSchema = z.object({
+    source: addressSchema,
+    target: addressSchema,
+    evidence_links: z.array(evidenceIdSchema).min(1),
+});
+const pathSchema = z
+    .object({
+    hops: z.number().int().min(0),
+    nodes: z.array(citedNodeSchema).min(1),
+    edges: z.array(citedEdgeSchema),
+    evidence_links: z.array(evidenceIdSchema).min(1),
+})
+    .superRefine((path, context) => {
+    const edgesConnectNodes = path.edges.every((edge, index) => edge.source === path.nodes[index]?.address &&
+        edge.target === path.nodes[index + 1]?.address);
+    if (path.hops !== path.edges.length ||
+        path.nodes.length !== path.edges.length + 1 ||
+        !edgesConnectNodes)
+        context.addIssue({
+            code: "custom",
+            message: "Path hops and edges must connect the ordered nodes",
+        });
+});
+const resultContextShape = {
+    start: addressSchema,
+    goal: addressSchema,
+    explored: z.object({
+        nodes: z.number().int().min(0),
+        edges: z.number().int().min(0),
+        depth_reached: z.number().int().min(0),
+    }),
+    evidence_links: z.array(evidenceIdSchema).min(1),
+    limitations: z.array(z.string()),
+};
+/** Evidence-cited directed call-path result containing every shortest path. */
+export const callPathResultSchema = z.union([
+    z.object({
+        ...resultContextShape,
+        status: z.literal("found"),
+        shortest_hops: z.number().int().min(0),
+        search_scope: z.object({ exhaustive: z.boolean() }),
+        paths: z.array(pathSchema).min(1),
+    }),
+    z.object({
+        ...resultContextShape,
+        status: z.literal("not_found"),
+        shortest_hops: z.null(),
+        search_scope: z.object({ exhaustive: z.literal(true) }),
+        paths: emptyArraySchema,
+    }),
+    z.object({
+        ...resultContextShape,
+        status: z.literal("unknown"),
+        shortest_hops: z.null(),
+        search_scope: z.object({ exhaustive: z.literal(false) }),
+        paths: emptyArraySchema,
+    }),
+]);