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

package/dist/adapters/repository-vitest-reporter.js

@@ -0,0 +1,314 @@
+const REPORT_PREFIX = "ROUTEKIT_VITEST_PHASE_EVIDENCE_V1 ";
+const LEGACY_REPORT_PREFIX = "ROUTEKIT_VITEST_EVIDENCE_V1 ";
+/** Only the explicitly recognized, one-shot Vitest execution receives this reporter. */
+export function repositoryVitestTestArgumentsV1(recipe, reporterPath) {
+    const offset = recipe.executable === "corepack" &&
+        /^pnpm(?:@[^/\s]+)?$/u.test(recipe.args[0] ?? "") &&
+        recipe.args[1] === "exec" &&
+        recipe.args[2] === "vitest"
+        ? 3
+        : recipe.executable === "pnpm" && recipe.args[0] === "exec" && recipe.args[1] === "vitest"
+            ? 2
+            : undefined;
+    if (offset === undefined || recipe.args[offset] !== "run")
+        return undefined;
+    const args = recipe.args.slice(0, offset + 1);
+    for (let index = offset + 1; index < recipe.args.length; index += 1) {
+        const value = recipe.args[index];
+        if (/^--(?:reporters?|outputFile|output-file|api\.host)$/u.test(value)) {
+            index += 1;
+        }
+        else if (!/^--(?:reporters?|outputFile|output-file)[=.]/u.test(value) &&
+            !/^--api\.(?:host|middlewareMode)(?:=|$)/u.test(value)) {
+            args.push(value);
+        }
+    }
+    // Vite resolves its default "localhost" even without starting an HTTP server.
+    // A literal host avoids that DNS operation in the offline sandbox. Setting
+    // middlewareMode explicitly preserves Vitest's normal no-listener run mode.
+    args.push("--api.host=127.0.0.1", "--api.middlewareMode", "--reporter", reporterPath);
+    return args;
+}
+/**
+ * Written outside the candidate-writable checkout. The parent reporter observes
+ * worker results; a completed process or assertion-looking console text is not
+ * sufficient evidence. The private phased frame is emitted only after installing
+ * the pinned host callback adapter at the resolved-config boundary. Historical
+ * unphased frames are preserved but cannot retain semantic credit.
+ */
+export function repositoryVitestReporterSourceV1(input) {
+    return `const phaseRunnerPath = ${JSON.stringify(input.phaseAdapterPath)};\n` +
+        `const phaseRuntimeSupported = ${JSON.stringify(input.runtimeSupported)};\n` +
+        REPOSITORY_VITEST_REPORTER_SOURCE;
+}
+const REPOSITORY_VITEST_REPORTER_SOURCE = String.raw `
+const prefix = "ROUTEKIT_VITEST_PHASE_EVIDENCE_V1 ";
+const errors = values => {
+  if (values == null) return [];
+  if (!Array.isArray(values)) throw new Error("invalid error inventory");
+  return values.map(error => ({
+    name: typeof error?.name === "string" ? error.name : "UnknownError",
+    ...(typeof error?.code === "string" ? { code: error.code } : {})
+  }));
+};
+const hooks = entity => {
+  const value = entity.task.result?.hooks;
+  if (value == null) return [];
+  if (typeof value !== "object" || Array.isArray(value)) throw new Error("invalid hooks");
+  return Object.values(value);
+};
+const testSnapshot = entity => {
+  const result = entity.result();
+  const diagnostic = entity.diagnostic();
+  return {
+    id: entity.id,
+    name: entity.name,
+    state: result.state,
+    errors: errors(result.errors),
+    hooks: hooks(entity),
+    diagnostic: diagnostic == null ? null : {
+      retryCount: diagnostic.retryCount,
+      repeatCount: diagnostic.repeatCount,
+      flaky: diagnostic.flaky,
+      duration: diagnostic.duration
+    }
+  };
+};
+export default class RepositoryEvidenceReporter {
+  starts = 0;
+  ends = 0;
+  hookBalance = new Map();
+  completedTests = new Set();
+  eventIntegrity = true;
+  phaseReady = false;
+  refused = false;
+  context;
+  phaseConfigs = new Set();
+  refuse(reason) {
+    if (!this.refused) {
+      this.refused = true;
+      process.stdout.write("\n" + prefix + JSON.stringify({ version: 1, complete: false, error: reason }) + "\n");
+    }
+    const error = new Error(reason);
+    error.name = "RouteKitVitestPhaseContractError";
+    error.code = "ROUTEKIT_VITEST_PHASE_CONTRACT_UNSUPPORTED";
+    throw error;
+  }
+  onInit(context) {
+    this.context = context;
+    if (!phaseRuntimeSupported || context?.version !== "3.2.7") {
+      this.refuse("unsupported-vitest-phase-runtime");
+    }
+    if (this.phaseReady || !Array.isArray(context.projects) || context.projects.length === 0) {
+      this.refuse("missing-vitest-resolved-config");
+    }
+    const configs = new Set([context.config, ...context.projects.map(project => project.config)]);
+    // This examines the ORIGINAL resolved values, before any host override.
+    // A configured custom runner is rejected before workers can load it.
+    if ([...configs].some(config => config?.runner !== undefined)) {
+      this.refuse("unsupported-vitest-custom-runner");
+    }
+    if ([...configs].some(config => !config || config.mode !== "test" ||
+        config.pool !== "forks" || config.isolate !== true || config.environment !== "node" ||
+        config.watch || config.mergeReports || config.browser?.enabled || config.typecheck?.enabled ||
+        config.coverage?.enabled || config.sequence?.concurrent || (config.retry ?? 0) !== 0) ||
+        Object.values(context.configOverride ?? {}).some(value => value !== undefined)) {
+      this.refuse("unsupported-vitest-phase-config");
+    }
+    for (const config of configs) {
+      if (!Reflect.set(config, "runner", phaseRunnerPath) || config.runner !== phaseRunnerPath) {
+        this.refuse("unavailable-vitest-phase-adapter");
+      }
+    }
+    this.phaseConfigs = configs;
+    this.phaseReady = true;
+  }
+  onTestRunStart(specifications) {
+    this.starts += 1;
+    if (!this.phaseReady || !Array.isArray(specifications) || specifications.length === 0 ||
+        specifications.some(specification => specification.pool !== "forks" ||
+          !this.phaseConfigs.has(specification.project?.config) ||
+          specification.project.config.runner !== phaseRunnerPath) ||
+        Object.values(this.context?.configOverride ?? {}).some(value => value !== undefined)) {
+      this.refuse("unavailable-vitest-phase-adapter");
+    }
+  }
+  onHookStart(context) {
+    const key = context.entity.id + "\0" + context.name;
+    this.hookBalance.set(key, (this.hookBalance.get(key) ?? 0) + 1);
+  }
+  onHookEnd(context) {
+    const key = context.entity.id + "\0" + context.name;
+    const count = this.hookBalance.get(key) ?? 0;
+    if (count < 1) this.eventIntegrity = false;
+    this.hookBalance.set(key, count - 1);
+  }
+  onTestCaseResult(entity) {
+    if (this.completedTests.has(entity.id)) this.eventIntegrity = false;
+    this.completedTests.add(entity.id);
+  }
+  onTestRunEnd(modules, unhandledErrors, reason) {
+    if (this.refused) return;
+    this.ends += 1;
+    let report;
+    try {
+      report = {
+        version: 1,
+        complete: true,
+        starts: this.starts,
+        ends: this.ends,
+        reason,
+        eventIntegrity: this.eventIntegrity,
+        unfinishedHooks: [...this.hookBalance.values()].some(count => count !== 0),
+        completedTestIds: [...this.completedTests],
+        unhandledErrors: errors(unhandledErrors),
+        modules: modules.map(module => ({
+          id: module.id,
+          state: module.state(),
+          errors: errors(module.errors()),
+          hooks: hooks(module),
+          suites: [...module.children.allSuites()].map(suite => ({
+            id: suite.id,
+            state: suite.state(),
+            errors: errors(suite.task.result?.errors),
+            hooks: hooks(suite)
+          })),
+          tests: [...module.children.allTests()].map(testSnapshot)
+        }))
+      };
+    } catch {
+      report = { version: 1, complete: false, error: "reporter-contract-unavailable" };
+    }
+    process.stdout.write("\n" + prefix + JSON.stringify(report) + "\n");
+  }
+}
+`;
+const object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const strings = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+const errorInventory = (value) => Array.isArray(value) &&
+    value.every((entry) => object(entry) &&
+        typeof entry.name === "string" &&
+        (entry.code === undefined || typeof entry.code === "string"));
+const terminalState = (value) => value === "passed" || value === "failed" || value === "skipped";
+const healthyHooks = (value) => Array.isArray(value) && value.every((state) => state === "pass");
+/** Undefined means that this command did not emit the host's Vitest protocol. */
+export function repositoryVitestTestEvidenceV1(result, output) {
+    const unknown = (detail) => ({ outcome: "unknown", detail });
+    const lines = output.split("\n");
+    if (lines.some((line) => line.startsWith(LEGACY_REPORT_PREFIX))) {
+        return unknown("legacy Vitest evidence has no host-owned phase attribution");
+    }
+    const frames = lines.filter((line) => line.startsWith(REPORT_PREFIX));
+    if (frames.length === 0)
+        return undefined;
+    if (frames.length !== 1)
+        return unknown("ambiguous Vitest reporter evidence");
+    let report;
+    try {
+        report = JSON.parse(frames[0].slice(REPORT_PREFIX.length));
+    }
+    catch {
+        return unknown("invalid Vitest reporter evidence");
+    }
+    if (!object(report) ||
+        report.version !== 1 ||
+        report.complete !== true ||
+        report.starts !== 1 ||
+        report.ends !== 1 ||
+        report.eventIntegrity !== true ||
+        report.unfinishedHooks !== false ||
+        !strings(report.completedTestIds) ||
+        new Set(report.completedTestIds).size !== report.completedTestIds.length ||
+        !errorInventory(report.unhandledErrors) ||
+        report.unhandledErrors.length !== 0 ||
+        !Array.isArray(report.modules) ||
+        report.modules.length === 0 ||
+        (report.reason !== "passed" && report.reason !== "failed")) {
+        return unknown("Vitest did not complete one unambiguous run without hook or unhandled errors");
+    }
+    const completedTestIds = report.completedTestIds;
+    const tests = [];
+    const moduleIds = new Set();
+    for (const module of report.modules) {
+        if (!object(module) ||
+            typeof module.id !== "string" ||
+            moduleIds.has(module.id) ||
+            !terminalState(module.state) ||
+            !errorInventory(module.errors) ||
+            module.errors.length !== 0 ||
+            !healthyHooks(module.hooks) ||
+            !Array.isArray(module.suites) ||
+            !Array.isArray(module.tests)) {
+            return unknown("Vitest module collection, setup or result evidence is incomplete");
+        }
+        moduleIds.add(module.id);
+        for (const suite of module.suites) {
+            if (!object(suite) ||
+                !terminalState(suite.state) ||
+                !errorInventory(suite.errors) ||
+                suite.errors.length !== 0 ||
+                !healthyHooks(suite.hooks)) {
+                return unknown("Vitest suite setup or result evidence is incomplete");
+            }
+        }
+        for (const test of module.tests) {
+            if (!object(test) ||
+                typeof test.id !== "string" ||
+                typeof test.name !== "string" ||
+                test.name.trim().length === 0 ||
+                !terminalState(test.state) ||
+                !errorInventory(test.errors) ||
+                !healthyHooks(test.hooks)) {
+                return unknown("Vitest test discovery, hooks or results are incomplete");
+            }
+            if (test.state !== "skipped") {
+                const diagnostic = test.diagnostic;
+                if (!object(diagnostic) ||
+                    diagnostic.retryCount !== 0 ||
+                    diagnostic.repeatCount !== 0 ||
+                    diagnostic.flaky !== false ||
+                    typeof diagnostic.duration !== "number" ||
+                    !Number.isFinite(diagnostic.duration) ||
+                    diagnostic.duration < 0) {
+                    return unknown("Vitest test retries, repeats or missing diagnostics prevent stable evidence");
+                }
+            }
+            tests.push(test);
+        }
+        const failed = module.tests.some((test) => object(test) && test.state === "failed");
+        if ((module.state === "failed" && !failed) || (module.state === "passed" && failed)) {
+            return unknown("Vitest module status disagrees with its test outcomes");
+        }
+    }
+    const ids = tests.map((test) => test.id);
+    if (new Set(ids).size !== ids.length ||
+        ids.length !== completedTestIds.length ||
+        ids.some((id) => !completedTestIds.includes(id))) {
+        return unknown("Vitest did not report completion for every discovered test");
+    }
+    const passed = tests.filter((test) => test.state === "passed");
+    const failed = tests.filter((test) => test.state === "failed");
+    if (passed.length + failed.length === 0 ||
+        passed.some((test) => test.errors.length !== 0)) {
+        return unknown("Vitest did not execute cleanly attributable tests");
+    }
+    if (result.exitCode === 0 && report.reason === "passed" && failed.length === 0) {
+        return { outcome: "pass", detail: `executed=${passed.length}; failed=0; reporter=vitest` };
+    }
+    if (result.exitCode === 1 && report.reason === "failed" && failed.length > 0) {
+        const assertionsOnly = failed.every((test) => test.errors.length > 0 &&
+            test.errors.every((error) => error.name === "AssertionError" &&
+                (error.code === undefined || error.code === "ERR_ASSERTION")));
+        if (assertionsOnly) {
+            return {
+                outcome: "fail",
+                detail: `executed=${passed.length + failed.length}; assertionFailures=${failed.length}; reporter=vitest`
+            };
+        }
+        return {
+            ...unknown("Vitest failed without attributable test-body assertions for every failed test"),
+            inconclusiveReason: "unattributed-test-failure"
+        };
+    }
+    return unknown("Vitest exit status disagrees with completed test evidence");
+}

package/dist/adapters/strict-authoring-schema.d.ts

@@ -0,0 +1,5 @@
+/** Adapt only the model wire contract; domain codecs and saved files stay unchanged. */
+export declare function strictAuthoringSchema(document: Record<string, unknown>): {
+    readonly jsonSchema: Record<string, unknown>;
+    readonly normalizeResponse: (value: unknown) => unknown;
+};

package/dist/adapters/strict-authoring-schema.js

@@ -0,0 +1,158 @@
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value
+    : undefined;
+/** Adapt only the model wire contract; domain codecs and saved files stay unchanged. */
+export function strictAuthoringSchema(document) {
+    const resolve = (schema, seen = new Set()) => {
+        if (typeof schema !== "object" || typeof schema.$ref !== "string")
+            return schema;
+        const reference = schema.$ref;
+        if (!reference.startsWith("#/") || seen.has(reference))
+            throw new Error("authoring schema requires resolvable local references");
+        let target = document;
+        for (const part of reference.slice(2).split("/"))
+            target = record(target)?.[part.replaceAll("~1", "/").replaceAll("~0", "~")];
+        if (typeof target !== "boolean" && record(target) === undefined)
+            throw new Error("authoring schema contains an unresolved reference");
+        return resolve(target, new Set([...seen, reference]));
+    };
+    const acceptsNull = (input) => {
+        const schema = resolve(input);
+        if (typeof schema === "boolean")
+            return schema;
+        if (Array.isArray(schema.anyOf))
+            return schema.anyOf.some(acceptsNull);
+        if (Array.isArray(schema.enum))
+            return schema.enum.includes(null);
+        if (Object.hasOwn(schema, "const"))
+            return schema.const === null;
+        return schema.type === "null" || (Array.isArray(schema.type) && schema.type.includes("null"));
+    };
+    const convert = (input) => {
+        if (typeof input === "boolean")
+            return input;
+        if ([
+            "oneOf",
+            "allOf",
+            "not",
+            "if",
+            "then",
+            "else",
+            "prefixItems",
+            "contains",
+            "dependentSchemas",
+            "patternProperties",
+            "unevaluatedProperties"
+        ].some((key) => Object.hasOwn(input, key)))
+            throw new Error("authoring schema uses a shape outside the supported strict conversion");
+        const output = { ...input };
+        if (typeof input.$ref === "string")
+            resolve(input);
+        if (Array.isArray(input.anyOf))
+            output.anyOf = input.anyOf.map(convert);
+        if (record(input.items) || typeof input.items === "boolean")
+            output.items = convert(input.items);
+        if (record(input.$defs))
+            output.$defs = Object.fromEntries(Object.entries(input.$defs).map(([key, value]) => [
+                key,
+                convert(value)
+            ]));
+        const properties = record(input.properties);
+        if (input.type === "object" || properties !== undefined) {
+            if (input.additionalProperties !== false || properties === undefined)
+                throw new Error("strict authoring output requires closed objects with named properties");
+            const required = new Set(Array.isArray(input.required) ? input.required : []);
+            output.properties = Object.fromEntries(Object.entries(properties).map(([key, value]) => {
+                const converted = convert(value);
+                return [
+                    key,
+                    required.has(key) || acceptsNull(value)
+                        ? converted
+                        : { anyOf: [converted, { type: "null" }] }
+                ];
+            }));
+            output.required = Object.keys(properties);
+            output.additionalProperties = false;
+        }
+        return output;
+    };
+    // Select the matching encoded union branch before restoring optional fields.
+    // This is a shape discriminator; the original Effect codec remains the final
+    // validator for refinements and the complete domain contract.
+    const matches = (input, value, wire) => {
+        const schema = resolve(input);
+        if (typeof schema === "boolean")
+            return schema;
+        if (Array.isArray(schema.anyOf))
+            return schema.anyOf.some((branch) => matches(branch, value, wire));
+        if (Array.isArray(schema.enum) &&
+            !schema.enum.some((entry) => JSON.stringify(entry) === JSON.stringify(value)))
+            return false;
+        if (Object.hasOwn(schema, "const") && schema.const !== value)
+            return false;
+        const type = schema.type;
+        if (Array.isArray(type))
+            return type.some((item) => matches({ ...schema, type: item }, value, wire));
+        if (type === "null")
+            return value === null;
+        if (type === "string")
+            return typeof value === "string";
+        if (type === "boolean")
+            return typeof value === "boolean";
+        if (type === "number" || type === "integer")
+            return (typeof value === "number" &&
+                Number.isFinite(value) &&
+                (type !== "integer" || Number.isInteger(value)));
+        if (type === "array")
+            return (Array.isArray(value) &&
+                value.every((item) => matches((schema.items ?? true), item, wire)));
+        if (type === "object") {
+            const object = record(value);
+            if (!object)
+                return false;
+            const properties = record(schema.properties) ?? {};
+            const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+            if (schema.additionalProperties === false &&
+                Object.keys(object).some((key) => !Object.hasOwn(properties, key)))
+                return false;
+            return Object.entries(properties).every(([key, property]) => {
+                if (!Object.hasOwn(object, key))
+                    return !required.has(key);
+                return ((wire && !required.has(key) && object[key] === null) ||
+                    matches(property, object[key], wire));
+            });
+        }
+        return true;
+    };
+    const normalize = (input, value) => {
+        const schema = resolve(input);
+        if (typeof schema === "boolean")
+            return value;
+        if (Array.isArray(schema.anyOf)) {
+            // Prefer already-valid original values so an explicitly nullable branch
+            // never loses a meaningful null merely because another branch is optional.
+            const branch = schema.anyOf.find((item) => matches(item, value, false)) ??
+                schema.anyOf.find((item) => matches(item, value, true));
+            return branch === undefined ? value : normalize(branch, value);
+        }
+        if (Array.isArray(value) && schema.type === "array")
+            return value.map((item) => normalize((schema.items ?? true), item));
+        const properties = record(schema.properties);
+        const object = record(value);
+        if (!properties || !object)
+            return value;
+        const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+        return Object.fromEntries(Object.entries(object).flatMap(([key, child]) => {
+            const property = properties[key];
+            if (property === undefined)
+                return [[key, child]];
+            if (child === null && !required.has(key) && !acceptsNull(property))
+                return [];
+            return [[key, normalize(property, child)]];
+        }));
+    };
+    return {
+        jsonSchema: convert(document),
+        normalizeResponse: (value) => normalize(document, value)
+    };
+}

package/dist/adapters/test-discovery.d.ts

@@ -0,0 +1,30 @@
+import { Effect } from "effect";
+import type { RepositoryCommandRecipeV1, RepositoryPackageNodeV1, RepositoryProtocolNodeV1, RepositoryPublicSurfaceV1, RepositoryTestBindingV1, RepositoryTestNodeV1 } from "../repository-behavior-protocol.js";
+import { type GitTreeSnapshotV1 } from "./git-task-history.js";
+export type RepositoryTestDiscoveryV1 = {
+    readonly tests: readonly RepositoryTestNodeV1[];
+    readonly testBindings: readonly RepositoryTestBindingV1[];
+    readonly unmappedTestPaths: readonly string[];
+};
+export declare const discoverRepositoryTestsV1: (input: {
+    readonly snapshot: GitTreeSnapshotV1;
+    readonly packages: readonly RepositoryPackageNodeV1[];
+    readonly publicSurfaces: readonly RepositoryPublicSurfaceV1[];
+    readonly protocols: readonly RepositoryProtocolNodeV1[];
+    readonly commands: readonly RepositoryCommandRecipeV1[];
+    readonly excludedPackageRoots?: readonly string[];
+}) => Effect.Effect<{
+    tests: {
+        readonly id: string;
+        readonly path: string;
+        readonly names: readonly string[];
+        readonly commandIds: readonly string[];
+    }[];
+    testBindings: {
+        readonly testId: string;
+        readonly targetIds: readonly string[];
+        readonly signals: readonly ("direct-import" | "symbol-reference" | "fixture-reference" | "package-ownership" | "git-cochange" | "coverage" | "reviewed-hypothesis")[];
+        readonly confidence: "high" | "medium" | "hypothesis";
+    }[];
+    unmappedTestPaths: string[];
+}, import("../errors.js").RepositoryFoundryError, never>;

package/dist/adapters/test-discovery.js

@@ -0,0 +1,124 @@
+import path from "node:path";
+import { Effect } from "effect";
+import { readGitTreeFileV1 } from "./git-task-history.js";
+const testPath = (value) => {
+    const lower = value.toLowerCase();
+    const base = lower.split("/").at(-1) ?? lower;
+    return (/(?:^|[._-])(?:test|spec)(?:[._-]|$)/u.test(base) ||
+        /(^|\/)(?:test|tests|__tests__)(\/|$)/u.test(lower));
+};
+const pathWithinRoot = (path, root) => path === root || path.startsWith(`${root}/`);
+const stableId = (prefix, value) => `${prefix}-${value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/gu, "-")
+    .replace(/^-|-$/gu, "")}`;
+const packageForPath = (packages, filePath) => [...packages]
+    .filter((entry) => entry.path === "." ||
+    filePath === entry.path ||
+    filePath.startsWith(`${entry.path}/`))
+    .sort((left, right) => right.path.length - left.path.length)[0];
+const testCommandIdsForPath = (commands, filePath) => {
+    const candidates = commands.filter((command) => command.kind === "test" &&
+        (command.cwd === "." || pathWithinRoot(filePath, command.cwd)));
+    if (candidates.length === 0)
+        return [];
+    const deepestRootLength = Math.max(...candidates.map((command) => (command.cwd === "." ? 0 : command.cwd.length)));
+    return candidates
+        .filter((command) => (command.cwd === "." ? 0 : command.cwd.length) === deepestRootLength)
+        .sort((left, right) => left.id.localeCompare(right.id))
+        .map((command) => command.id);
+};
+const testNames = (content) => [
+    ...new Set([
+        ...[...content.matchAll(/\b(?:test|it|describe)\s*\(\s*["'`]([^"'`]+)["'`]/gu)]
+            .map((match) => match[1])
+            .filter((value) => value !== undefined),
+        ...[...content.matchAll(/\bdef\s+(test_[A-Za-z0-9_]+)/gu)]
+            .map((match) => match[1])
+            .filter((value) => value !== undefined)
+    ])
+];
+const importedPaths = (content) => [
+    ...new Set([
+        ...content.matchAll(/\b(?:from\s+|import\s*\(\s*|require\s*\(\s*)["'`]([^"'`]+)["'`]/gu)
+    ]
+        .map((match) => match[1])
+        .filter((value) => value !== undefined))
+];
+const resolveRelativeImport = (snapshot, testFile, specifier) => {
+    if (!specifier.startsWith("."))
+        return undefined;
+    const base = path.posix.normalize(path.posix.join(path.posix.dirname(testFile), specifier));
+    const sourceBase = base.replace(/\.(?:[cm]?js|jsx)$/u, "");
+    for (const candidate of [
+        base,
+        `${sourceBase}.ts`,
+        `${sourceBase}.tsx`,
+        `${sourceBase}.mts`,
+        `${sourceBase}.cts`,
+        `${sourceBase}.js`,
+        `${sourceBase}.jsx`,
+        `${sourceBase}/index.ts`,
+        `${sourceBase}/index.js`
+    ]) {
+        if (snapshot.files.includes(candidate))
+            return candidate;
+    }
+    return undefined;
+};
+export const discoverRepositoryTestsV1 = Effect.fn("RepositoryFoundry.discoverRepositoryTests")(function* (input) {
+    const tests = [];
+    const testBindings = [];
+    const unmappedTestPaths = [];
+    for (const filePath of input.snapshot.files.filter((path) => testPath(path) &&
+        !input.excludedPackageRoots?.some((root) => pathWithinRoot(path, root)))) {
+        if (!/\.(?:[cm]?[jt]sx?|py|go|rs)$/u.test(filePath.toLowerCase())) {
+            continue;
+        }
+        const content = yield* readGitTreeFileV1({
+            snapshot: input.snapshot,
+            path: filePath
+        });
+        const owner = packageForPath(input.packages, filePath);
+        const commandIds = testCommandIdsForPath(input.commands, filePath);
+        const id = stableId("test", filePath);
+        tests.push({
+            id,
+            path: filePath,
+            names: testNames(content),
+            commandIds
+        });
+        const relativeTargets = importedPaths(content)
+            .map((specifier) => resolveRelativeImport(input.snapshot, filePath, specifier))
+            .filter((value) => value !== undefined);
+        const protocolIds = input.protocols
+            .filter((protocol) => relativeTargets.includes(protocol.path))
+            .map((protocol) => protocol.id);
+        const surfaceIds = input.publicSurfaces
+            .filter((surface) => relativeTargets.includes(surface.path))
+            .map((surface) => surface.id);
+        const targetIds = [
+            ...protocolIds,
+            ...surfaceIds,
+            ...(owner === undefined ? [] : [owner.id])
+        ].filter((value, index, values) => values.indexOf(value) === index);
+        if (targetIds.length === 0) {
+            unmappedTestPaths.push(filePath);
+            continue;
+        }
+        testBindings.push({
+            testId: id,
+            targetIds,
+            signals: [
+                ...(relativeTargets.length > 0 ? ["direct-import"] : []),
+                ...(owner === undefined ? [] : ["package-ownership"])
+            ],
+            confidence: relativeTargets.length > 0 ? "high" : "medium"
+        });
+    }
+    return {
+        tests: tests.sort((left, right) => left.path.localeCompare(right.path)),
+        testBindings: testBindings.sort((left, right) => left.testId.localeCompare(right.testId)),
+        unmappedTestPaths: unmappedTestPaths.sort()
+    };
+});