@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/adapters/repository-import-context.d.ts

@@ -0,0 +1,47 @@
+import { Effect } from "effect";
+import { type GitTreeSnapshotV1 } from "./git-task-history.js";
+type Source = {
+    readonly path: string;
+    readonly content: string;
+};
+/**
+ * Read complete, bounded local import context from one pinned tree. This is
+ * supporting context, not permission to edit a dependency or an assertion that
+ * the complete dependency graph has been loaded.
+ */
+export declare const readRepositoryLocalImportsV1: (input: {
+    readonly snapshot: GitTreeSnapshotV1;
+    readonly sources: readonly Source[];
+    readonly dependencyContextVersion?: 1 | 2;
+}) => Effect.Effect<{
+    commit: string;
+    sources: Source[];
+    omitted: {
+        path: string;
+        reason: "depth" | "file-size" | "total-size" | "file-count";
+    }[];
+    unresolved: {
+        from: string;
+        specifier: string;
+    }[];
+    dependencyContextVersion: 1 | 2;
+    dependencies: {
+        from: string;
+        specifier: string;
+        symbols: readonly string[] | null;
+        resolution: "resolved" | "external" | "unsupported" | "unresolved";
+        paths: readonly string[];
+    }[];
+} | {
+    commit: string;
+    sources: Source[];
+    omitted: {
+        path: string;
+        reason: "file-size" | "total-size" | "file-count" | "depth";
+    }[];
+    unresolved: {
+        from: string;
+        specifier: string;
+    }[];
+}, import("../errors.js").RepositoryFoundryError, never>;
+export {};

package/dist/adapters/repository-import-context.js

@@ -0,0 +1,469 @@
+import { posix } from "node:path";
+import { Effect } from "effect";
+import ts from "typescript";
+import { readGitTreeFileV1 } from "./git-task-history.js";
+import { selectTypeScriptWorkspaceManifestPathsV1 } from "./typescript-repository-index.js";
+const MAXIMUM_BYTES = 64_000;
+const MAXIMUM_FILE_BYTES = 48_000;
+const MAXIMUM_FILES = 16;
+const MAXIMUM_DEPTH = 2;
+const relativeImports = (content) => {
+    const reexports = [
+        ...content.matchAll(/\bexport\s+(?:type\s+)?(?:\*(?:\s+as\s+\w+)?|\{[^}]*\})\s+from\s*["'](\.{1,2}\/[^"'\\\0]+)["']/gu)
+    ];
+    return [
+        ...content.matchAll(/\b(?:from\s*|import\s*\(\s*|require\s*\(\s*|import\s*)["'](\.{1,2}\/[^"'\\\0]+)["']/gu)
+    ].map((match) => ({
+        specifier: match[1],
+        reexport: reexports.some((entry) => match.index >= entry.index && match.index < entry.index + entry[0].length)
+    }));
+};
+const candidates = (from, specifier) => {
+    const path = posix.normalize(posix.join(posix.dirname(from), specifier));
+    if (path.startsWith("../") || posix.isAbsolute(path) || path.includes("\0"))
+        return [];
+    const extension = posix.extname(path);
+    const base = path.slice(0, -extension.length);
+    if (extension === ".js")
+        return [`${base}.ts`, `${base}.tsx`, `${base}.d.ts`, path];
+    if (extension === ".jsx")
+        return [`${base}.tsx`, path];
+    if (extension === ".mjs")
+        return [`${base}.mts`, `${base}.d.mts`, path];
+    if (extension === ".cjs")
+        return [`${base}.cts`, `${base}.d.cts`, path];
+    if (extension.length > 0)
+        return /\.(?:[cm]?[jt]sx?|json)$/u.test(path) ? [path] : [];
+    return [
+        ...[".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".json"].map((suffix) => `${path}${suffix}`),
+        ...[".ts", ".tsx", ".js", ".mjs", ".cjs"].map((suffix) => `${path}/index${suffix}`)
+    ];
+};
+const fixturePriority = (path) => /(?:^|\/)(?:test|tests|__tests__|fixtures)(?:\/|$)|(?:fixture|test-helper)/u.test(path) ? 0 : 1;
+// Parse syntax only. A TypeScript program/module resolver would read the current
+// filesystem and installed packages, which must never contaminate pinned context.
+const importReferences = (source, requested) => {
+    const file = ts.createSourceFile(source.path, source.content, ts.ScriptTarget.Latest, true);
+    const references = [];
+    const wanted = requested === undefined ? undefined : new Set(requested);
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            const clause = node.importClause;
+            const names = clause?.namedBindings;
+            const elements = names !== undefined && ts.isNamedImports(names) ? names.elements : [];
+            const symbols = clause === undefined || (names !== undefined && ts.isNamespaceImport(names))
+                ? undefined
+                : [
+                    ...(clause.name === undefined ? [] : ["default"]),
+                    ...elements.map((element) => (element.propertyName ?? element.name).text)
+                ];
+            references.push({
+                specifier: node.moduleSpecifier.text,
+                reexport: false,
+                typeOnly: clause?.isTypeOnly === true ||
+                    (clause?.name === undefined &&
+                        elements.length > 0 &&
+                        elements.every((element) => element.isTypeOnly)),
+                symbols
+            });
+            return;
+        }
+        if (ts.isExportDeclaration(node) &&
+            node.moduleSpecifier !== undefined &&
+            ts.isStringLiteral(node.moduleSpecifier)) {
+            const clause = node.exportClause;
+            if (clause !== undefined && ts.isNamedExports(clause)) {
+                const elements = clause.elements.filter((element) => wanted === undefined || wanted.has(element.name.text));
+                if (elements.length === 0)
+                    return;
+                references.push({
+                    specifier: node.moduleSpecifier.text,
+                    reexport: true,
+                    typeOnly: node.isTypeOnly || elements.every((element) => element.isTypeOnly),
+                    symbols: elements.map((element) => (element.propertyName ?? element.name).text)
+                });
+            }
+            else if (clause === undefined || wanted === undefined || wanted.has(clause.name.text)) {
+                references.push({
+                    specifier: node.moduleSpecifier.text,
+                    reexport: true,
+                    typeOnly: node.isTypeOnly,
+                    symbols: clause === undefined ? requested : undefined
+                });
+            }
+            return;
+        }
+        if (ts.isImportEqualsDeclaration(node) &&
+            ts.isExternalModuleReference(node.moduleReference) &&
+            node.moduleReference.expression !== undefined &&
+            ts.isStringLiteral(node.moduleReference.expression)) {
+            references.push({
+                specifier: node.moduleReference.expression.text,
+                reexport: false,
+                typeOnly: node.isTypeOnly,
+                symbols: undefined
+            });
+            return;
+        }
+        if (ts.isImportTypeNode(node) &&
+            ts.isLiteralTypeNode(node.argument) &&
+            ts.isStringLiteral(node.argument.literal)) {
+            let qualifier = node.qualifier;
+            while (qualifier !== undefined && ts.isQualifiedName(qualifier))
+                qualifier = qualifier.left;
+            references.push({
+                specifier: node.argument.literal.text,
+                reexport: false,
+                typeOnly: true,
+                symbols: qualifier === undefined ? undefined : [qualifier.text]
+            });
+            return;
+        }
+        if (ts.isCallExpression(node) &&
+            (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
+                (ts.isIdentifier(node.expression) && node.expression.text === "require")) &&
+            node.arguments[0] !== undefined &&
+            ts.isStringLiteral(node.arguments[0])) {
+            references.push({
+                specifier: node.arguments[0].text,
+                reexport: false,
+                typeOnly: false,
+                symbols: undefined
+            });
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    // Imported bindings re-exported locally are still imports, so their defining
+    // module is followed even when an alias changes the public name.
+    ts.forEachChild(file, visit);
+    return references;
+};
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+const packageSpecifier = (specifier) => {
+    if (specifier.startsWith(".") ||
+        specifier.startsWith("/") ||
+        specifier.includes(":") ||
+        specifier.includes("\\") ||
+        specifier.includes("\0") ||
+        specifier.split("/").some((part) => part === "" || part === "." || part === ".."))
+        return undefined;
+    const parts = specifier.split("/");
+    const width = specifier.startsWith("@") ? 2 : 1;
+    if (parts.length < width)
+        return undefined;
+    return {
+        name: parts.slice(0, width).join("/"),
+        subpath: parts.length === width ? "." : `./${parts.slice(width).join("/")}`
+    };
+};
+const exportTargetStrings = (value) => {
+    if (typeof value === "string")
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap(exportTargetStrings);
+    const conditions = object(value);
+    if (conditions === undefined)
+        return [];
+    // Source and type entries can identify their corresponding implementation.
+    // Runtime conditions retain manifest order; unsupported conditions are not guessed.
+    return Object.entries(conditions)
+        .filter(([condition]) => ["source", "types", "node", "import", "default"].includes(condition))
+        .flatMap(([, target]) => exportTargetStrings(target));
+};
+const packageExportTargets = (manifest, subpath) => {
+    if (manifest.exports === undefined) {
+        return subpath === "."
+            ? [manifest.source, manifest.module, manifest.main, "./index.js"]
+                .filter((entry) => typeof entry === "string")
+                .map((entry) => (entry.startsWith(".") || entry.startsWith("/") ? entry : `./${entry}`))
+            : [subpath];
+    }
+    const exports = object(manifest.exports);
+    if (exports === undefined || !Object.keys(exports).some((key) => key.startsWith("."))) {
+        return subpath === "." ? exportTargetStrings(manifest.exports) : [];
+    }
+    if (Object.hasOwn(exports, subpath))
+        return exportTargetStrings(exports[subpath]);
+    const patterns = Object.keys(exports)
+        .filter((key) => key.startsWith("./") && key.split("*").length === 2)
+        .sort((left, right) => right.indexOf("*") - left.indexOf("*") || right.length - left.length);
+    for (const pattern of patterns) {
+        const [prefix, suffix] = pattern.split("*");
+        if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+            continue;
+        const replacement = subpath.slice(prefix.length, subpath.length - suffix.length);
+        if (replacement.length === 0)
+            continue;
+        return exportTargetStrings(exports[pattern]).map((target) => target.replaceAll("*", replacement));
+    }
+    return [];
+};
+const readWorkspaceImports = Effect.fn("CaseGeneration.readWorkspaceImports")(function* (input) {
+    const version = input.dependencyContextVersion ?? 1;
+    const maximumBytes = version === 2 ? 96_000 : MAXIMUM_BYTES;
+    const maximumFiles = version === 2 ? 24 : MAXIMUM_FILES;
+    const files = new Set(input.snapshot.files);
+    const contentCache = new Map(input.sources.map((source) => [source.path, source.content]));
+    const read = Effect.fnUntraced(function* (path) {
+        const cached = contentCache.get(path);
+        if (cached !== undefined)
+            return cached;
+        const content = yield* readGitTreeFileV1({ snapshot: input.snapshot, path });
+        contentCache.set(path, content);
+        return content;
+    });
+    const parseObject = (content) => Effect.try({
+        try: () => object(JSON.parse(content)),
+        catch: () => undefined
+    }).pipe(Effect.orElseSucceed(() => undefined));
+    const inventory = yield* selectTypeScriptWorkspaceManifestPathsV1(input.snapshot);
+    const packages = new Map();
+    for (const path of inventory.selectedManifestPaths) {
+        const manifest = yield* parseObject(yield* read(path));
+        if (manifest === undefined || typeof manifest.name !== "string")
+            continue;
+        const entry = { root: posix.dirname(path), manifest };
+        packages.set(manifest.name, [...(packages.get(manifest.name) ?? []), entry]);
+    }
+    const roots = new Map();
+    const resolveWorkspace = Effect.fnUntraced(function* (specifier) {
+        const parsed = packageSpecifier(specifier);
+        if (parsed === undefined)
+            return [];
+        const matches = packages.get(parsed.name);
+        // Duplicate package names are ambiguous, not permission to choose one.
+        if (matches?.length !== 1)
+            return [];
+        const pkg = matches[0];
+        if (!roots.has(pkg.root)) {
+            const path = posix.join(pkg.root, "tsconfig.json");
+            const config = files.has(path)
+                ? object(ts.parseConfigFileTextToJson(path, yield* read(path)).config)
+                : undefined;
+            const compiler = object(config?.compilerOptions);
+            roots.set(pkg.root, typeof compiler?.rootDir === "string" && typeof compiler.outDir === "string"
+                ? { rootDir: compiler.rootDir, outDir: compiler.outDir }
+                : undefined);
+        }
+        const layout = roots.get(pkg.root);
+        const resolved = [];
+        for (const target of packageExportTargets(pkg.manifest, parsed.subpath)) {
+            if (!target.startsWith("./") || target.includes("\\") || target.includes("\0"))
+                continue;
+            const path = posix.normalize(posix.join(pkg.root, target));
+            const within = (candidate, root) => !posix.isAbsolute(candidate) &&
+                !candidate.startsWith("../") &&
+                (root === "." || candidate === root || candidate.startsWith(`${root}/`));
+            if (!within(path, pkg.root))
+                continue;
+            const possible = [];
+            if (layout !== undefined) {
+                const outputRoot = posix.normalize(posix.join(pkg.root, layout.outDir));
+                const sourceRoot = posix.normalize(posix.join(pkg.root, layout.rootDir));
+                if (within(outputRoot, pkg.root) &&
+                    within(sourceRoot, pkg.root) &&
+                    within(path, outputRoot)) {
+                    const sourcePath = posix
+                        .join(sourceRoot, posix.relative(outputRoot, path))
+                        .replace(/\.d\.(ts|mts|cts)$/u, ".$1");
+                    possible.push(...candidates(posix.join(pkg.root, "package.json"), `./${posix.relative(pkg.root, sourcePath)}`));
+                }
+            }
+            possible.push(...candidates(posix.join(pkg.root, "package.json"), target));
+            const found = possible.find((candidate) => files.has(candidate));
+            if (found !== undefined && !resolved.includes(found))
+                resolved.push(found);
+        }
+        return resolved;
+    });
+    const seen = new Set(input.sources.map((source) => source.path));
+    const sources = [];
+    const omitted = new Map();
+    const unresolved = new Map();
+    const dependencies = new Map();
+    const pending = new Map();
+    const expanded = new Map();
+    let totalBytes = 0;
+    const enqueue = Effect.fnUntraced(function* (source, depth, inheritedPriority, requested) {
+        for (const { specifier, reexport, typeOnly, symbols } of importReferences(source, requested)) {
+            const dependencyKey = `${source.path}\0${specifier}\0${JSON.stringify(symbols ?? null)}`;
+            const dependency = { from: source.path, specifier, symbols: symbols ?? null };
+            const pkg = packageSpecifier(specifier);
+            if (specifier.startsWith("node:") || (pkg !== undefined && !packages.has(pkg.name))) {
+                dependencies.set(dependencyKey, { ...dependency, resolution: "external", paths: [] });
+                continue;
+            }
+            const paths = specifier.startsWith(".")
+                ? candidates(source.path, specifier)
+                    .filter((candidate) => files.has(candidate))
+                    .slice(0, 1)
+                : yield* resolveWorkspace(specifier);
+            if (paths.length === 0) {
+                unresolved.set(`${source.path}\0${specifier}`, { from: source.path, specifier });
+                dependencies.set(dependencyKey, {
+                    ...dependency,
+                    resolution: specifier.startsWith(".") ? "unresolved" : "unsupported",
+                    paths: []
+                });
+                continue;
+            }
+            dependencies.set(dependencyKey, { ...dependency, resolution: "resolved", paths });
+            for (const path of paths) {
+                const priority = inheritedPriority === undefined
+                    ? reexport
+                        ? 3
+                        : typeOnly && version === 1
+                            ? 2
+                            : 0
+                    : Math.max(inheritedPriority, typeOnly && version === 1 ? 2 : 0);
+                // A named re-export is a facade hop, not a new behavioral dependency.
+                // Keep broad unrequested root exports bounded by the original depth rule.
+                const dependencyDepth = version === 2 && reexport && requested !== undefined ? depth - 1 : depth;
+                if (expanded
+                    .get(path)
+                    ?.some((prior) => prior.depth <= dependencyDepth &&
+                    prior.priority <= priority &&
+                    (prior.symbols === undefined ||
+                        (symbols !== undefined &&
+                            symbols.every((symbol) => prior.symbols.includes(symbol))))))
+                    continue;
+                const prior = pending.get(path);
+                pending.set(path, {
+                    depth: Math.min(prior?.depth ?? dependencyDepth, dependencyDepth),
+                    priority: Math.min(prior?.priority ?? priority, priority),
+                    symbols: prior === undefined
+                        ? symbols
+                        : prior.symbols === undefined || symbols === undefined
+                            ? undefined
+                            : [...new Set([...prior.symbols, ...symbols])].sort()
+                });
+            }
+        }
+    });
+    for (const source of input.sources)
+        yield* enqueue(source, 1);
+    while (pending.size > 0) {
+        const ordered = [...pending.entries()].sort(([left, a], [right, b]) => a.priority - b.priority ||
+            fixturePriority(left) - fixturePriority(right) ||
+            a.depth - b.depth ||
+            left.localeCompare(right));
+        let [path, entry] = ordered[0];
+        if (version === 2 &&
+            entry.depth <= MAXIMUM_DEPTH &&
+            sources.length < maximumFiles &&
+            totalBytes < maximumBytes) {
+            // Whole large modules must not consume the packet before small type,
+            // constructor and error definitions at the same dependency distance.
+            const tier = ordered.filter(([candidate, request]) => request.priority === entry.priority &&
+                request.depth === entry.depth &&
+                fixturePriority(candidate) === fixturePriority(path));
+            const sized = yield* Effect.forEach(tier, ([candidate, request]) => Effect.map(read(candidate), (content) => ({
+                path: candidate,
+                entry: request,
+                bytes: seen.has(candidate) ? 0 : Buffer.byteLength(content)
+            })), { concurrency: 4 });
+            const selected = sized.sort((left, right) => left.bytes - right.bytes || left.path.localeCompare(right.path))[0];
+            path = selected.path;
+            entry = selected.entry;
+        }
+        pending.delete(path);
+        if (entry.depth > MAXIMUM_DEPTH) {
+            if (!seen.has(path))
+                omitted.set(path, "depth");
+            continue;
+        }
+        if (!seen.has(path) && sources.length >= maximumFiles) {
+            omitted.set(path, "file-count");
+            continue;
+        }
+        const content = yield* read(path);
+        const bytes = Buffer.byteLength(content);
+        if (!seen.has(path) && bytes > MAXIMUM_FILE_BYTES) {
+            omitted.set(path, "file-size");
+            continue;
+        }
+        if (!seen.has(path) && totalBytes + bytes > maximumBytes) {
+            omitted.set(path, "total-size");
+            continue;
+        }
+        omitted.delete(path);
+        const source = { path, content };
+        if (!seen.has(path)) {
+            seen.add(path);
+            totalBytes += bytes;
+            sources.push(source);
+        }
+        expanded.set(path, [...(expanded.get(path) ?? []), entry]);
+        yield* enqueue(source, entry.depth + 1, entry.priority, entry.symbols);
+    }
+    return {
+        commit: input.snapshot.commit,
+        sources,
+        omitted: [...omitted].map(([path, reason]) => ({ path, reason })),
+        unresolved: [...unresolved.values()],
+        dependencyContextVersion: version,
+        dependencies: [...dependencies.values()]
+    };
+});
+/**
+ * Read complete, bounded local import context from one pinned tree. This is
+ * supporting context, not permission to edit a dependency or an assertion that
+ * the complete dependency graph has been loaded.
+ */
+export const readRepositoryLocalImportsV1 = Effect.fn("CaseGeneration.readLocalImports")(function* (input) {
+    if (input.dependencyContextVersion !== undefined)
+        return yield* readWorkspaceImports(input);
+    const files = new Set(input.snapshot.files);
+    const seen = new Set(input.sources.map((source) => source.path));
+    const sources = [];
+    const omitted = [];
+    const unresolved = [];
+    let totalBytes = 0;
+    let frontier = [...input.sources];
+    for (let depth = 1; frontier.length > 0; depth += 1) {
+        const next = new Map();
+        for (const source of frontier) {
+            for (const { specifier, reexport } of relativeImports(source.content)) {
+                const path = candidates(source.path, specifier).find((candidate) => files.has(candidate));
+                if (path === undefined) {
+                    unresolved.push({ from: source.path, specifier });
+                }
+                else if (!seen.has(path) || next.has(path)) {
+                    seen.add(path);
+                    next.set(path, Math.min(next.get(path) ?? 1, reexport ? 1 : 0));
+                }
+            }
+        }
+        frontier = [];
+        for (const path of [...next.keys()].sort((left, right) => fixturePriority(left) - fixturePriority(right) ||
+            next.get(left) - next.get(right) ||
+            left.localeCompare(right))) {
+            if (depth > MAXIMUM_DEPTH) {
+                omitted.push({ path, reason: "depth" });
+                continue;
+            }
+            if (sources.length >= MAXIMUM_FILES) {
+                omitted.push({ path, reason: "file-count" });
+                continue;
+            }
+            const content = yield* readGitTreeFileV1({ snapshot: input.snapshot, path });
+            const bytes = Buffer.byteLength(content);
+            if (bytes > MAXIMUM_FILE_BYTES) {
+                omitted.push({ path, reason: "file-size" });
+                continue;
+            }
+            if (totalBytes + bytes > MAXIMUM_BYTES) {
+                omitted.push({ path, reason: "total-size" });
+                continue;
+            }
+            totalBytes += bytes;
+            const source = { path, content };
+            sources.push(source);
+            frontier.push(source);
+        }
+    }
+    return { commit: input.snapshot.commit, sources, omitted, unresolved };
+});

package/dist/adapters/repository-node-test-reporter.d.ts

@@ -0,0 +1,3 @@
+import type { RepositoryCommandRecipeV1 } from "../repository-behavior-protocol.js";
+/** Node and tsx share the Node test runner; TAP exposes hook versus test-body failures. */
+export declare const repositoryNodeTestArgumentsV1: (recipe: RepositoryCommandRecipeV1) => readonly string[];

package/dist/adapters/repository-node-test-reporter.js

@@ -0,0 +1,27 @@
+/** Node and tsx share the Node test runner; TAP exposes hook versus test-body failures. */
+export const repositoryNodeTestArgumentsV1 = (recipe) => {
+    const offset = (recipe.executable === "node" || recipe.executable === "tsx")
+        ? 0
+        : recipe.executable === "corepack" && recipe.args[1] === "exec" &&
+            (recipe.args[2] === "node" || recipe.args[2] === "tsx")
+            ? 3
+            : recipe.executable === "pnpm" && recipe.args[0] === "exec" &&
+                (recipe.args[1] === "node" || recipe.args[1] === "tsx")
+                ? 2
+                : undefined;
+    if (offset === undefined || !recipe.args.slice(offset).includes("--test"))
+        return recipe.args;
+    const args = recipe.args.slice(0, offset);
+    args.push("--test-reporter=tap");
+    for (let index = offset; index < recipe.args.length; index += 1) {
+        const value = recipe.args[index];
+        if (value === "--test-reporter" || value === "--test-reporter-destination") {
+            index += 1;
+        }
+        else if (!value.startsWith("--test-reporter=") &&
+            !value.startsWith("--test-reporter-destination=")) {
+            args.push(value);
+        }
+    }
+    return args;
+};

package/dist/adapters/repository-review-evidence.d.ts

@@ -0,0 +1,39 @@
+type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+type Node = null | boolean | number | string | readonly ["object", readonly (readonly [string, Node])[]] | readonly ["array", readonly Node[]] | readonly ["text", string];
+type SpliceContext = {
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly immediatelyBefore: string;
+    readonly immediatelyAfter: string;
+};
+type Text = readonly ["literal", string] | readonly ["splice", string, number, number, string, SpliceContext];
+export type RepositoryReviewEvidenceV1 = {
+    readonly encoding: "routekit-lossless-review-json-v1";
+    readonly texts: Readonly<Record<string, Text>>;
+    readonly evidence: Node;
+};
+export declare const REPOSITORY_REVIEW_EVIDENCE_INSTRUCTIONS = "The input uses routekit-lossless-review-json-v1.\nDecode evidence before reviewing it. Null, booleans, numbers, and strings represent themselves.\nEvery original object is [\"object\", [[key, encodedValue], ...]], and every original array is\n[\"array\", [encodedValue, ...]]. [\"text\", digest] resolves a string from texts. A text entry is\n[\"literal\", exactString] or [\"splice\", baseDigest, prefixChars, suffixChars, replacement, context].\nFor a splice, retain the first prefixChars and last suffixChars of the literal base string and\ninsert replacement between them. Character counts use JavaScript UTF-16 code units, not UTF-8 bytes.\nThe verified context gives one-based start/end lines in the base and up to 120 characters immediately\nbefore and after the replaced range, so you can locate the changed code without counting characters.\nDigests are SHA-256 of UTF-8 JSON.stringify(exactString). The host verified exact reconstruction.\nAll original fields, source, controls, and evidence are retained. Evidence-inventory paths address\nthe decoded original object; the encoding does not change those paths or their meaning.";
+/** Factor full-file variants without weakening or truncating the review evidence. */
+export declare function encodeRepositoryReviewEvidenceV1(input: unknown, sourceBases: readonly string[]): RepositoryReviewEvidenceV1;
+/** Host-side integrity check; the reviewer receives the same reconstruction rules. */
+export declare function decodeRepositoryReviewEvidenceV1(packet: RepositoryReviewEvidenceV1): Json;
+type CompactNode = null | boolean | number | string | readonly ["r", number, ...CompactNode[]] | readonly ["a", ...CompactNode[]] | readonly ["t", number] | readonly ["s", number] | readonly ["n", number] | readonly ["j", ...CompactNode[]];
+type TextHunk = readonly [number, number, string, SpliceContext];
+type CompactText = Text | readonly ["patch", string, readonly TextHunk[]];
+export type RepositoryReviewEvidenceV2 = {
+    readonly encoding: "routekit-lossless-review-json-v2";
+    readonly originalDigest: string;
+    readonly texts: readonly (readonly [string, CompactText])[];
+    readonly shapes: readonly (readonly string[])[];
+    readonly strings: readonly string[];
+    readonly nodes: readonly CompactNode[];
+    readonly evidence: CompactNode;
+};
+export declare const REPOSITORY_REVIEW_EVIDENCE_V2_INSTRUCTIONS = "The input uses routekit-lossless-review-json-v2.\nDecode evidence before reviewing it. Null, booleans, numbers, and strings represent themselves.\n[\"a\", ...items] represents an original array of decoded items. [\"r\", shapeIndex, ...values]\nrepresents an original object: zip shapes[shapeIndex] with the decoded values, in the given order.\nFor example, shapes[0]=[\"solutionId\",\"outcome\"] and [\"r\",0,\"candidate-a\",\"fail\"] represents\n{\"solutionId\":\"candidate-a\",\"outcome\":\"fail\"}. Every original array or object has an explicit tag.\n[\"s\", index] resolves exactly strings[index]. [\"j\", ...parts] concatenates decoded string\nparts without adding or removing spaces or delimiters. These joins factor repetitive diagnostics and evidence paths;\nthe individual outcome, duration, error, and other evidence fields remain available.\n[\"n\", index] resolves exactly nodes[index]. These shared arrays and objects avoid repeating\nidentical fixtures and control overlays across the proposal and executed evidence. A node may\nrefer only to earlier node entries. Every occurrence reconstructs the complete original subtree.\n[\"t\", index] resolves texts[index], a [digest, entry] pair. An entry is [\"literal\", exactString]\nor [\"splice\", baseDigest, prefixChars, suffixChars, replacement, context]. Locate the literal base\nby its digest in texts. Retain its first prefixChars and last suffixChars, inserting replacement\nbetween them. Counts use JavaScript UTF-16 code units. The verified context gives one-based start/end\nlines and up to 120 characters immediately before and after the replacement.\nA [\"patch\", baseDigest, hunks] entry applies separated edits to the exact resolved base string.\nEach hunk is [startChars, endChars, exactReplacement, context]. Offsets are zero-based UTF-16,\nend-exclusive, ordered, nonoverlapping ranges in the ORIGINAL base. Preserve all text between\nranges; insert each replacement once. Context verifies the original source lines and neighboring\ntext. A base may itself be encoded; text dependencies are acyclic and the host validates every digest.\nText digests are SHA-256\nof UTF-8 JSON.stringify(exactString). originalDigest binds the complete decoded original JSON.\nThe host verified exact reconstruction. No source, control, observation, or evidence-inventory entry\nwas omitted. Evidence-inventory paths address the decoded original object, with unchanged meaning.";
+/** Lossless row and string dictionaries keep full observed populations reviewable. */
+export declare function encodeRepositoryReviewEvidenceV2(input: unknown, sourceBases: readonly string[]): RepositoryReviewEvidenceV2;
+/** Reject malformed tables and any change to the complete reconstructed evidence. */
+export declare function decodeRepositoryReviewEvidenceV2(packet: RepositoryReviewEvidenceV2): Json;
+export {};