@interf/compiler 0.5.1 → 0.6.3

package/dist/lib/test-matrices.d.ts

@@ -1,90 +1 @@
-import { z } from "zod";
-import type { WorkflowExecutionProfile } from "./executors.js";
-export declare const TestMatrixAgentSchema: z.ZodEnum<{
-    "claude-code": "claude-code";
-    codex: "codex";
-}>;
-export declare const TestMatrixProfileSchema: z.ZodPipe<z.ZodObject<{
-    id: z.ZodString;
-    preset: z.ZodOptional<z.ZodEnum<{
-        "release-claude-high": "release-claude-high";
-        "release-codex-high": "release-codex-high";
-        "tier1-max-claude": "tier1-max-claude";
-        "tier1-max-codex": "tier1-max-codex";
-    }>>;
-    agent: z.ZodOptional<z.ZodEnum<{
-        "claude-code": "claude-code";
-        codex: "codex";
-    }>>;
-    model: z.ZodOptional<z.ZodString>;
-    profile: z.ZodOptional<z.ZodString>;
-    effort: z.ZodOptional<z.ZodString>;
-    timeout_ms: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodTransform<{
-    agent: "claude-code" | "codex";
-    id: string;
-    preset?: "release-claude-high" | "release-codex-high" | "tier1-max-claude" | "tier1-max-codex" | undefined;
-    model?: string | undefined;
-    profile?: string | undefined;
-    effort?: string | undefined;
-    timeout_ms?: number | undefined;
-}, {
-    id: string;
-    preset?: "release-claude-high" | "release-codex-high" | "tier1-max-claude" | "tier1-max-codex" | undefined;
-    agent?: "claude-code" | "codex" | undefined;
-    model?: string | undefined;
-    profile?: string | undefined;
-    effort?: string | undefined;
-    timeout_ms?: number | undefined;
-}>>;
-export declare const TestMatrixRetryPolicySchema: z.ZodObject<{
-    max_attempts_per_profile: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const TestMatrixDatasetSchema: z.ZodString;
-export declare const TestMatrixSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    source_path: z.ZodString;
-    compile_profiles: z.ZodArray<z.ZodPipe<z.ZodObject<{
-        id: z.ZodString;
-        preset: z.ZodOptional<z.ZodEnum<{
-            "release-claude-high": "release-claude-high";
-            "release-codex-high": "release-codex-high";
-            "tier1-max-claude": "tier1-max-claude";
-            "tier1-max-codex": "tier1-max-codex";
-        }>>;
-        agent: z.ZodOptional<z.ZodEnum<{
-            "claude-code": "claude-code";
-            codex: "codex";
-        }>>;
-        model: z.ZodOptional<z.ZodString>;
-        profile: z.ZodOptional<z.ZodString>;
-        effort: z.ZodOptional<z.ZodString>;
-        timeout_ms: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodTransform<{
-        agent: "claude-code" | "codex";
-        id: string;
-        preset?: "release-claude-high" | "release-codex-high" | "tier1-max-claude" | "tier1-max-codex" | undefined;
-        model?: string | undefined;
-        profile?: string | undefined;
-        effort?: string | undefined;
-        timeout_ms?: number | undefined;
-    }, {
-        id: string;
-        preset?: "release-claude-high" | "release-codex-high" | "tier1-max-claude" | "tier1-max-codex" | undefined;
-        agent?: "claude-code" | "codex" | undefined;
-        model?: string | undefined;
-        profile?: string | undefined;
-        effort?: string | undefined;
-        timeout_ms?: number | undefined;
-    }>>>;
-    retry_policy: z.ZodOptional<z.ZodObject<{
-        max_attempts_per_profile: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    datasets: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export type TestMatrixProfile = z.infer<typeof TestMatrixProfileSchema>;
-export type TestMatrixRetryPolicy = z.infer<typeof TestMatrixRetryPolicySchema>;
-export type TestMatrixDataset = z.infer<typeof TestMatrixDatasetSchema>;
-export type TestMatrix = z.infer<typeof TestMatrixSchema>;
-export declare function testMatrixProfileToExecutionProfile(profile: TestMatrixProfile): WorkflowExecutionProfile;
+export * from "../packages/testing/test-matrices.js";

package/dist/lib/test-matrices.js

@@ -1,96 +1,3 @@
-import { z } from "zod";
-import { WorkflowIdPattern } from "./schema.js";
-import { TestProfilePresetIdSchema, resolveTestProfilePreset, } from "./test-profile-presets.js";
-export const TestMatrixAgentSchema = z.enum(["claude-code", "codex"]);
-const TestMatrixProfileInputSchema = z.object({
-    id: z.string().regex(WorkflowIdPattern),
-    preset: TestProfilePresetIdSchema.optional(),
-    agent: TestMatrixAgentSchema.optional(),
-    model: z.string().min(1).optional(),
-    profile: z.string().min(1).optional(),
-    effort: z.string().min(1).optional(),
-    timeout_ms: z.number().int().positive().optional(),
-}).superRefine((value, ctx) => {
-    if (!value.preset && !value.agent) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["agent"],
-            message: "Test-matrix profiles need either `agent` or `preset`.",
-        });
-    }
-    if (value.preset) {
-        for (const field of ["agent", "model", "profile", "effort", "timeout_ms"]) {
-            if (value[field] !== undefined) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    path: [field],
-                    message: `Test profile presets own \`${field}\`; remove the inline override or stop using \`preset\`.`,
-                });
-            }
-        }
-    }
-});
-export const TestMatrixProfileSchema = TestMatrixProfileInputSchema.transform((value) => {
-    if (!value.preset) {
-        return {
-            ...value,
-            agent: value.agent,
-        };
-    }
-    const preset = resolveTestProfilePreset(value.preset);
-    return {
-        ...value,
-        agent: preset.agent,
-        model: preset.model,
-        profile: preset.profile,
-        effort: preset.effort,
-        timeout_ms: preset.timeout_ms,
-    };
-});
-export const TestMatrixRetryPolicySchema = z.object({
-    max_attempts_per_profile: z.number().int().min(1).max(5).optional(),
-});
-export const TestMatrixDatasetSchema = z.string().regex(WorkflowIdPattern);
-export const TestMatrixSchema = z.object({
-    id: z.string().regex(WorkflowIdPattern),
-    name: z.string().min(1),
-    source_path: z.string().min(1),
-    compile_profiles: z.array(TestMatrixProfileSchema).min(1),
-    retry_policy: TestMatrixRetryPolicySchema.optional(),
-    datasets: z.array(TestMatrixDatasetSchema).min(1),
-}).superRefine((value, ctx) => {
-    const duplicateProfileIds = findDuplicates(value.compile_profiles.map((profile) => profile.id));
-    for (const id of duplicateProfileIds) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["compile_profiles"],
-            message: `Duplicate compile profile id in test matrix: ${id}`,
-        });
-    }
-    const duplicateCompiledIds = findDuplicates(value.datasets);
-    for (const id of duplicateCompiledIds) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["datasets"],
-            message: `Duplicate dataset id in test matrix: ${id}`,
-        });
-    }
-});
-function findDuplicates(values) {
-    const seen = new Set();
-    const duplicates = new Set();
-    for (const value of values) {
-        if (seen.has(value))
-            duplicates.add(value);
-        seen.add(value);
-    }
-    return Array.from(duplicates.values()).sort();
-}
-export function testMatrixProfileToExecutionProfile(profile) {
-    return {
-        model: profile.model ?? null,
-        profile: profile.profile ?? null,
-        effort: profile.effort ?? null,
-        timeoutMs: profile.timeout_ms ?? null,
-    };
-}
+// Compatibility shim for historical `src/lib/test-matrices.ts` imports.
+// Source of truth: `src/packages/testing/test-matrices.ts`.
+export * from "../packages/testing/test-matrices.js";

package/dist/lib/test-paths.d.ts

@@ -1,12 +1 @@
-import type { TestTargetType } from "./test-types.js";
-export declare const TEST_SPEC_EXTENSIONS: Set<string>;
-export declare function testSpecRootPath(sourcePath: string): string;
-export declare function testSpecTypePath(sourcePath: string, type: TestTargetType): string;
-export declare function targetTestRunsPath(compiledPath: string, type: TestTargetType): string;
-export declare function targetTestRunGitignorePath(compiledPath: string, type: TestTargetType): string;
-export declare function targetTestSandboxesPath(compiledPath: string, type: TestTargetType): string;
-export declare function targetTestSandboxGitignorePath(compiledPath: string, type: TestTargetType): string;
-export declare function testSpecFilePath(sourcePath: string, type: TestTargetType, id: string): string;
-export declare function normalizeTestId(input: string): string;
-export declare function assertTestId(id: string): void;
-export declare function assertWritableTestSpecPath(filePath: string): void;
+export * from "../packages/testing/test-paths.js";

package/dist/lib/test-paths.js

@@ -1,59 +1,3 @@
-import { existsSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "./compiled-paths.js";
-const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
-export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
-export function testSpecRootPath(sourcePath) {
-    return join(sourcePath, "interf", "tests", "internal", "specs");
-}
-export function testSpecTypePath(sourcePath, type) {
-    return join(testSpecRootPath(sourcePath), type);
-}
-function isDatasetTestsRootPath(artifactRootPath) {
-    return basename(dirname(artifactRootPath)) === "tests";
-}
-export function targetTestRunsPath(compiledPath, type) {
-    if (existsSync(compiledInterfConfigPath(compiledPath))) {
-        return join(targetTestRunsRootForCompiled(compiledPath), type);
-    }
-    if (isDatasetTestsRootPath(compiledPath)) {
-        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "runs");
-    }
-    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled dataset or interf/tests/<dataset> root.`);
-}
-export function targetTestRunGitignorePath(compiledPath, type) {
-    return join(targetTestRunsPath(compiledPath, type), ".gitignore");
-}
-export function targetTestSandboxesPath(compiledPath, type) {
-    if (existsSync(compiledInterfConfigPath(compiledPath))) {
-        return join(targetTestSandboxesRootForCompiled(compiledPath), type);
-    }
-    if (isDatasetTestsRootPath(compiledPath)) {
-        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "sandboxes");
-    }
-    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled dataset or interf/tests/<dataset> root.`);
-}
-export function targetTestSandboxGitignorePath(compiledPath, type) {
-    return join(targetTestSandboxesPath(compiledPath, type), ".gitignore");
-}
-export function testSpecFilePath(sourcePath, type, id) {
-    return join(testSpecTypePath(sourcePath, type), `${id}.json`);
-}
-export function normalizeTestId(input) {
-    return input
-        .toLowerCase()
-        .trim()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 80);
-}
-export function assertTestId(id) {
-    if (!TEST_ID_PATTERN.test(id)) {
-        throw new Error(`Invalid test id: ${id}`);
-    }
-}
-export function assertWritableTestSpecPath(filePath) {
-    if (existsSync(filePath)) {
-        throw new Error(`Test spec already exists: ${filePath}`);
-    }
-}
+// Compatibility shim for historical `src/lib/test-paths.ts` imports.
+// Source of truth: `src/packages/testing/test-paths.ts`.
+export * from "../packages/testing/test-paths.js";

package/dist/lib/test-profile-presets.d.ts

@@ -1,57 +1 @@
-import { z } from "zod";
-declare const TestProfilePresetValueSchema: z.ZodObject<{
-    agent: z.ZodEnum<{
-        "claude-code": "claude-code";
-        codex: "codex";
-    }>;
-    model: z.ZodOptional<z.ZodString>;
-    profile: z.ZodOptional<z.ZodString>;
-    effort: z.ZodOptional<z.ZodString>;
-    timeout_ms: z.ZodOptional<z.ZodNumber>;
-    label: z.ZodString;
-}, z.core.$strip>;
-export declare const TestProfilePresetIds: readonly ["release-claude-high", "release-codex-high", "tier1-max-claude", "tier1-max-codex"];
-export declare const TestProfilePresetIdSchema: z.ZodEnum<{
-    "release-claude-high": "release-claude-high";
-    "release-codex-high": "release-codex-high";
-    "tier1-max-claude": "tier1-max-claude";
-    "tier1-max-codex": "tier1-max-codex";
-}>;
-export declare const TestProfilePresets: {
-    readonly "release-claude-high": {
-        agent: "claude-code" | "codex";
-        label: string;
-        model?: string | undefined;
-        profile?: string | undefined;
-        effort?: string | undefined;
-        timeout_ms?: number | undefined;
-    };
-    readonly "release-codex-high": {
-        agent: "claude-code" | "codex";
-        label: string;
-        model?: string | undefined;
-        profile?: string | undefined;
-        effort?: string | undefined;
-        timeout_ms?: number | undefined;
-    };
-    readonly "tier1-max-claude": {
-        agent: "claude-code" | "codex";
-        label: string;
-        model?: string | undefined;
-        profile?: string | undefined;
-        effort?: string | undefined;
-        timeout_ms?: number | undefined;
-    };
-    readonly "tier1-max-codex": {
-        agent: "claude-code" | "codex";
-        label: string;
-        model?: string | undefined;
-        profile?: string | undefined;
-        effort?: string | undefined;
-        timeout_ms?: number | undefined;
-    };
-};
-export type TestProfilePresetId = z.infer<typeof TestProfilePresetIdSchema>;
-export type TestProfilePresetValue = z.infer<typeof TestProfilePresetValueSchema>;
-export declare function resolveTestProfilePreset(id: TestProfilePresetId): TestProfilePresetValue;
-export {};
+export * from "../packages/testing/test-profile-presets.js";

package/dist/lib/test-profile-presets.js

@@ -1,50 +1,3 @@
-import { z } from "zod";
-const TestProfilePresetAgentSchema = z.enum(["claude-code", "codex"]);
-const TestProfilePresetValueSchema = z.object({
-    agent: TestProfilePresetAgentSchema,
-    model: z.string().min(1).optional(),
-    profile: z.string().min(1).optional(),
-    effort: z.string().min(1).optional(),
-    timeout_ms: z.number().int().positive().optional(),
-    label: z.string().min(1),
-});
-export const TestProfilePresetIds = [
-    "release-claude-high",
-    "release-codex-high",
-    "tier1-max-claude",
-    "tier1-max-codex",
-];
-export const TestProfilePresetIdSchema = z.enum(TestProfilePresetIds);
-export const TestProfilePresets = {
-    "release-claude-high": TestProfilePresetValueSchema.parse({
-        agent: "claude-code",
-        model: "claude-sonnet-4-6",
-        effort: "high",
-        timeout_ms: 480000,
-        label: "Claude Code (Claude Sonnet 4.6, high)",
-    }),
-    "release-codex-high": TestProfilePresetValueSchema.parse({
-        agent: "codex",
-        model: "gpt-5.4-mini",
-        effort: "high",
-        timeout_ms: 480000,
-        label: "Codex (GPT-5.4 Mini, high)",
-    }),
-    "tier1-max-claude": TestProfilePresetValueSchema.parse({
-        agent: "claude-code",
-        model: "claude-opus-4-6[1m]",
-        effort: "max",
-        timeout_ms: 480000,
-        label: "Claude Code (Claude Opus 4.6 1M, max)",
-    }),
-    "tier1-max-codex": TestProfilePresetValueSchema.parse({
-        agent: "codex",
-        model: "gpt-5.4",
-        effort: "xhigh",
-        timeout_ms: 480000,
-        label: "Codex (GPT-5.4, xhigh)",
-    }),
-};
-export function resolveTestProfilePreset(id) {
-    return TestProfilePresets[id];
-}
+// Compatibility shim for historical `src/lib/test-profile-presets.ts` imports.
+// Source of truth: `src/packages/testing/test-profile-presets.ts`.
+export * from "../packages/testing/test-profile-presets.js";

package/dist/lib/test-sandbox.d.ts

@@ -1,11 +1 @@
-import type { TestTargetCandidate } from "./test-types.js";
-export type TestSandboxRetentionMode = "on-failure" | "always";
-export interface TestSandbox {
-    rootPath: string;
-    rawPath: string;
-    targetPath: string;
-    compiledPath: string | null;
-    preserve(destinationPath: string): string;
-    cleanup(): void;
-}
-export declare function createTestSandbox(target: TestTargetCandidate): TestSandbox;
+export * from "../packages/testing/test-sandbox.js";

package/dist/lib/test-sandbox.js

@@ -1,105 +1,3 @@
-import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, relative, sep } from "node:path";
-import { refreshCompiledBootstrapGuidance } from "./interf-bootstrap.js";
-import { readInterfConfig, resolveCompiledRawPath } from "./interf.js";
-import { projectRawTestQueryShell } from "./agent-shells.js";
-import { compiledCompiledPathForDataset } from "./project-paths.js";
-import { saveCompiledInterfConfig } from "./source-config.js";
-import { refreshCompiledArtifacts } from "./state.js";
-import { projectRawSnapshot } from "./compiled-raw.js";
-import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "./compiled-paths.js";
-function toPortableRelativePath(fromPath, toPath) {
-    return relative(fromPath, toPath).split(sep).join("/");
-}
-function sanitizeCompiledArtifacts(compiledPath) {
-    for (const absolutePath of [
-        testRootForCompiled(compiledPath),
-        targetTestSandboxesRootForCompiled(compiledPath),
-        stageExecutionShellsRoot(compiledPath),
-        workflowImprovementLoopsRoot(compiledPath),
-        compiledRuntimeLogsRoot(compiledPath),
-        compiledQueryAcceptanceRoot(compiledPath),
-    ]) {
-        rmSync(absolutePath, { recursive: true, force: true });
-    }
-}
-export function createTestSandbox(target) {
-    let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
-    let preserved = false;
-    const sandboxCompiledPath = () => (target.type === "compiled"
-        ? compiledCompiledPathForDataset(sandboxRoot, target.name)
-        : null);
-    const sandboxRawPath = () => (target.type === "compiled"
-        ? join(compiledCompiledPathForDataset(sandboxRoot, target.name), "raw")
-        : join(sandboxRoot, "raw"));
-    const sandboxTargetPath = () => (target.type === "compiled"
-        ? compiledCompiledPathForDataset(sandboxRoot, target.name)
-        : sandboxRoot);
-    try {
-        if (target.type === "compiled") {
-            mkdirSync(dirname(sandboxTargetPath()), { recursive: true });
-            cpSync(target.path, sandboxTargetPath(), { recursive: true });
-            sanitizeCompiledArtifacts(sandboxTargetPath());
-            const sandboxConfig = readInterfConfig(sandboxTargetPath());
-            if (!sandboxConfig) {
-                throw new Error(`Sandbox compiled is missing interf.json: ${sandboxTargetPath()}`);
-            }
-            if (!existsSync(resolveCompiledRawPath(sandboxTargetPath(), sandboxConfig))) {
-                throw new Error(`Sandbox compiled is missing its local raw snapshot: ${sandboxTargetPath()}. Rebuild the compiled dataset before testing it.`);
-            }
-            saveCompiledInterfConfig(sandboxTargetPath(), {
-                ...sandboxConfig,
-                checks: [],
-                source: {
-                    path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
-                    dataset_path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
-                },
-            });
-            refreshCompiledBootstrapGuidance(sandboxTargetPath());
-            refreshCompiledArtifacts(sandboxTargetPath(), { ensureViewSpec: true });
-        }
-        else {
-            projectRawSnapshot({
-                sourcePath: target.path,
-                destinationPath: sandboxRawPath(),
-                compiledPath: target.path,
-                mode: "link-or-copy",
-                prune: false,
-                preserveTimestamps: false,
-            });
-            projectRawTestQueryShell(sandboxTargetPath());
-        }
-    }
-    catch (error) {
-        rmSync(sandboxRoot, { recursive: true, force: true });
-        throw error;
-    }
-    return {
-        get rootPath() {
-            return sandboxRoot;
-        },
-        get rawPath() {
-            return sandboxRawPath();
-        },
-        get targetPath() {
-            return sandboxTargetPath();
-        },
-        get compiledPath() {
-            return sandboxCompiledPath();
-        },
-        preserve(destinationPath) {
-            mkdirSync(dirname(destinationPath), { recursive: true });
-            rmSync(destinationPath, { recursive: true, force: true });
-            renameSync(sandboxRoot, destinationPath);
-            sandboxRoot = destinationPath;
-            preserved = true;
-            return sandboxRoot;
-        },
-        cleanup() {
-            if (preserved)
-                return;
-            rmSync(sandboxRoot, { recursive: true, force: true });
-        },
-    };
-}
+// Compatibility shim for historical `src/lib/test-sandbox.ts` imports.
+// Source of truth: `src/packages/testing/test-sandbox.ts`.
+export * from "../packages/testing/test-sandbox.js";

package/dist/lib/test-specs.d.ts

@@ -1,7 +1 @@
-import type { TestSpec, TestTargetType, LoadedTestSpec } from "./test-types.js";
-export declare function listTestSpecs(sourcePath: string, type: TestTargetType): LoadedTestSpec[];
-export declare function loadTestSpec(sourcePath: string, type: TestTargetType, id: string): LoadedTestSpec | null;
-export declare function loadTestSpecFromFile(filePath: string): LoadedTestSpec | null;
-export declare function writeTestSpec(sourcePath: string, spec: TestSpec & {
-    id?: string;
-}): string;
+export * from "../packages/testing/test-specs.js";

package/dist/lib/test-specs.js

@@ -1,114 +1,3 @@
-import { existsSync, mkdirSync, readdirSync, writeFileSync, } from "node:fs";
-import { basename, extname, join } from "node:path";
-import { readJsonFileWithSchema } from "./parse.js";
-import { TestSpecSchema } from "./schema.js";
-import { TEST_SPEC_EXTENSIONS, assertTestId, assertWritableTestSpecPath, testSpecFilePath, testSpecTypePath, normalizeTestId, } from "./test-paths.js";
-function readTestSpecFile(filePath) {
-    const extension = extname(filePath).toLowerCase();
-    if (!TEST_SPEC_EXTENSIONS.has(extension))
-        return null;
-    const parsed = readJsonFileWithSchema(filePath, "test spec", TestSpecSchema);
-    if (!parsed)
-        return null;
-    return {
-        ...parsed,
-        id: basename(filePath, extension),
-        filePath,
-    };
-}
-function serializeTestSpec(spec) {
-    return {
-        type: spec.type,
-        name: spec.name,
-        ...(spec.description ? { description: spec.description } : {}),
-        cases: spec.cases.map((testCase) => ({
-            id: testCase.id,
-            question: testCase.question,
-            ...(testCase.file ? { file: testCase.file } : {}),
-            ...(testCase.answer ? { answer: testCase.answer } : {}),
-            ...(testCase.strictness ? { strictness: testCase.strictness } : {}),
-            ...(testCase.expect ? { expect: testCase.expect } : {}),
-        })),
-    };
-}
-export function listTestSpecs(sourcePath, type) {
-    const dirPath = testSpecTypePath(sourcePath, type);
-    if (!existsSync(dirPath))
-        return [];
-    return readdirSync(dirPath)
-        .map((entry) => join(dirPath, entry))
-        .filter((filePath) => TEST_SPEC_EXTENSIONS.has(extname(filePath).toLowerCase()))
-        .map((filePath) => readTestSpecFile(filePath))
-        .filter((value) => value !== null)
-        .sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
-}
-export function loadTestSpec(sourcePath, type, id) {
-    const normalizedId = normalizeTestId(id);
-    const filePath = join(testSpecTypePath(sourcePath, type), `${normalizedId}.json`);
-    if (!existsSync(filePath))
-        return null;
-    return readTestSpecFile(filePath);
-}
-export function loadTestSpecFromFile(filePath) {
-    return readTestSpecFile(filePath);
-}
-export function writeTestSpec(sourcePath, spec) {
-    const id = normalizeTestId(spec.id ?? spec.name);
-    assertTestId(id);
-    const dirPath = testSpecTypePath(sourcePath, spec.type);
-    mkdirSync(dirPath, { recursive: true });
-    const existingPath = join(dirPath, `${id}.json`);
-    if (existsSync(existingPath)) {
-        throw new Error(`Test spec already exists: ${existingPath}`);
-    }
-    const filePath = testSpecFilePath(sourcePath, spec.type, id);
-    assertWritableTestSpecPath(filePath);
-    const normalizedSpec = {
-        type: spec.type,
-        name: spec.name.trim(),
-        ...(spec.description && spec.description.trim().length > 0
-            ? { description: spec.description.trim() }
-            : {}),
-        cases: spec.cases.map((testCase) => ({
-            id: normalizeTestId(testCase.id),
-            question: testCase.question.trim(),
-            ...(testCase.file && testCase.file.trim().length > 0
-                ? { file: testCase.file.trim() }
-                : {}),
-            ...(testCase.answer && testCase.answer.trim().length > 0
-                ? { answer: testCase.answer.trim() }
-                : {}),
-            ...(testCase.strictness && testCase.strictness.trim().length > 0
-                ? { strictness: testCase.strictness.trim() }
-                : {}),
-            ...(testCase.expect
-                ? {
-                    expect: {
-                        ...(testCase.expect.must_include && testCase.expect.must_include.length > 0
-                            ? { must_include: testCase.expect.must_include.map((value) => value.trim()).filter(Boolean) }
-                            : {}),
-                        ...(testCase.expect.must_include_one_of && testCase.expect.must_include_one_of.length > 0
-                            ? {
-                                must_include_one_of: testCase.expect.must_include_one_of
-                                    .map((group) => group.map((value) => value.trim()).filter(Boolean))
-                                    .filter((group) => group.length > 0),
-                            }
-                            : {}),
-                        ...(testCase.expect.must_not_include && testCase.expect.must_not_include.length > 0
-                            ? { must_not_include: testCase.expect.must_not_include.map((value) => value.trim()).filter(Boolean) }
-                            : {}),
-                        ...(typeof testCase.expect.min_words === "number"
-                            ? { min_words: testCase.expect.min_words }
-                            : {}),
-                        ...(typeof testCase.expect.max_words === "number"
-                            ? { max_words: testCase.expect.max_words }
-                            : {}),
-                    },
-                }
-                : {}),
-        })),
-    };
-    const parsed = TestSpecSchema.parse(normalizedSpec);
-    writeFileSync(filePath, `${JSON.stringify(serializeTestSpec(parsed), null, 2)}\n`);
-    return filePath;
-}
+// Compatibility shim for historical `src/lib/test-specs.ts` imports.
+// Source of truth: `src/packages/testing/test-specs.ts`.
+export * from "../packages/testing/test-specs.js";

package/dist/lib/test-targets.d.ts

@@ -1,5 +1 @@
-import type { TestTargetCandidate } from "./test-types.js";
-export declare function listCompiledTestTargets(sourcePath: string): TestTargetCandidate[];
-export declare function createCompiledTestTarget(compiledPath: string, compiledName: string, workflowId?: string): TestTargetCandidate;
-export declare function createRawTestTarget(sourcePath: string): TestTargetCandidate;
-export declare function listTestTargets(sourcePath: string): TestTargetCandidate[];
+export * from "../packages/testing/test-targets.js";