@interf/compiler 0.6.1 → 0.6.4

package/dist/packages/project-model/source-config.js

@@ -0,0 +1,298 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
+import { readInterfConfig, } from "./interf.js";
+import { seedCompiledWorkflowPackage } from "../workflow-package/interf-workflow-package.js";
+import { readJsonFileWithSchema } from "../shared/parse.js";
+import { getCompiledWorkflow } from "../workflow-package/workflow-definitions.js";
+import { SourceFolderConfigSchema, } from "./lib/schema.js";
+import { slugify } from "../shared/naming.js";
+import { assertPathWithinRoot } from "../shared/path-guards.js";
+import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "../compiler/compiled-paths.js";
+export const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
+function sourceConfigPath(sourcePath) {
+    return join(sourcePath, SOURCE_FOLDER_CONFIG_FILE);
+}
+function normalizeTruthChecks(cases) {
+    const seen = new Set();
+    return cases.map((caseSpec, index) => {
+        const baseId = slugify(caseSpec.id ?? caseSpec.question) || `check-${index + 1}`;
+        let id = baseId;
+        let suffix = 2;
+        while (seen.has(id)) {
+            id = `${baseId}-${suffix}`;
+            suffix += 1;
+        }
+        seen.add(id);
+        return {
+            id,
+            question: caseSpec.question.trim(),
+            ...(caseSpec.answer ? { answer: caseSpec.answer.trim() } : {}),
+            ...(caseSpec.strictness ? { strictness: caseSpec.strictness.trim() } : {}),
+            ...(caseSpec.expect ? { expect: caseSpec.expect } : {}),
+        };
+    });
+}
+export function fingerprintTruthChecks(checks) {
+    const normalized = checks.map((check) => ({
+        question: check.question.trim(),
+        ...(check.answer ? { answer: check.answer.trim() } : {}),
+        ...(check.strictness ? { strictness: check.strictness.trim() } : {}),
+        ...(check.expect ? { expect: check.expect } : {}),
+    }));
+    return createHash("sha256")
+        .update(JSON.stringify(normalized))
+        .digest("hex")
+        .slice(0, 16);
+}
+export function loadSourceFolderConfig(sourcePath) {
+    const filePath = sourceConfigPath(sourcePath);
+    if (!existsSync(filePath))
+        return null;
+    return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
+}
+export function listSourceDatasetConfigs(config) {
+    return config?.datasets ?? [];
+}
+export function resolveDatasetCompileMaxAttempts(datasetConfig, override = null) {
+    const configured = override ?? datasetConfig.max_attempts ?? null;
+    if (configured == null)
+        return null;
+    const normalized = Math.trunc(configured);
+    if (!Number.isFinite(normalized) || normalized < 1)
+        return 1;
+    return Math.min(5, normalized);
+}
+export function resolveDatasetCompileMaxLoops(datasetConfig, override = null) {
+    const configured = override ?? datasetConfig.max_loops ?? null;
+    if (configured == null)
+        return null;
+    const normalized = Math.trunc(configured);
+    if (!Number.isFinite(normalized) || normalized < 1)
+        return 1;
+    return Math.min(3, normalized);
+}
+export function getDefaultSourceDatasetConfig(config) {
+    const datasets = listSourceDatasetConfigs(config);
+    return datasets[0] ?? null;
+}
+export function findSourceDatasetConfig(config, datasetName) {
+    return listSourceDatasetConfigs(config).find((dataset) => dataset.name === datasetName) ?? null;
+}
+function toWritableSourceProjectConfig(config) {
+    const datasets = config?.datasets ?? [];
+    if (datasets.length > 0) {
+        return {
+            datasets: datasets.map((dataset) => toWritableSourceDatasetConfig(dataset)),
+        };
+    }
+    return {};
+}
+function toWritableSourceDatasetConfig(dataset) {
+    return {
+        name: dataset.name,
+        path: dataset.path,
+        ...(dataset.about ? { about: dataset.about } : {}),
+        ...(dataset.workflow && dataset.workflow !== "interf" ? { workflow: dataset.workflow } : {}),
+        ...(typeof dataset.max_attempts === "number" ? { max_attempts: dataset.max_attempts } : {}),
+        ...(typeof dataset.max_loops === "number" ? { max_loops: dataset.max_loops } : {}),
+        checks: dataset.checks,
+    };
+}
+export function saveSourceFolderConfig(sourcePath, config) {
+    writeFileSync(sourceConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(config), null, 2) + "\n");
+}
+export function appendSourceDatasetChecks(sourcePath, datasetName, checks) {
+    const existing = loadSourceFolderConfig(sourcePath);
+    const currentDataset = findSourceDatasetConfig(existing, datasetName);
+    const otherDatasets = listSourceDatasetConfigs(existing).filter((dataset) => dataset.name !== datasetName);
+    const currentChecks = currentDataset?.checks ?? [];
+    const nextDataset = {
+        ...toWritableSourceDatasetConfig(currentDataset ?? {
+            name: datasetName,
+            path: `./${datasetName}`,
+            checks: [],
+        }),
+        checks: [...currentChecks, ...checks],
+    };
+    saveSourceFolderConfig(sourcePath, {
+        datasets: [
+            nextDataset,
+            ...otherDatasets,
+        ],
+    });
+}
+export function upsertSourceDatasetConfig(sourcePath, datasetConfig, options = {}) {
+    const existing = loadSourceFolderConfig(sourcePath);
+    const datasets = listSourceDatasetConfigs(existing);
+    const candidateNames = Array.from(new Set([datasetConfig.name, options.matchName].filter((value) => Boolean(value))));
+    const existingIndex = datasets.findIndex((entry) => candidateNames.includes(entry.name));
+    if (existingIndex >= 0) {
+        datasets[existingIndex] = datasetConfig;
+    }
+    else {
+        datasets.push(datasetConfig);
+    }
+    saveSourceFolderConfig(sourcePath, {
+        datasets,
+    });
+}
+export function compiledMaxAttempts(maxAttempts) {
+    if (maxAttempts == null)
+        return undefined;
+    return resolveDatasetCompileMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
+}
+export function compiledMaxLoops(maxLoops) {
+    if (maxLoops == null)
+        return undefined;
+    return resolveDatasetCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
+}
+export function sourceDatasetConfigFromInterfConfig(config, datasetPath = `./${config.name}`) {
+    return {
+        name: config.name,
+        path: datasetPath,
+        ...(config.about ? { about: config.about } : {}),
+        ...(config.workflow ? { workflow: config.workflow } : {}),
+        ...(typeof config.max_attempts === "number"
+            ? { max_attempts: config.max_attempts }
+            : {}),
+        ...(typeof config.max_loops === "number"
+            ? { max_loops: config.max_loops }
+            : {}),
+        checks: config.checks ?? [],
+    };
+}
+export function loadCompiledDatasetConfig(compiledPath) {
+    const config = readInterfConfig(compiledPath);
+    if (!config)
+        return null;
+    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
+    const configuredDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(projectPath));
+    const fallbackDatasetPath = configuredDatasets.length === 1
+        ? configuredDatasets[0].path
+        : `./${config.name}`;
+    const datasetPath = typeof config.source?.dataset_path === "string" && config.source.dataset_path.length > 0
+        ? relative(projectPath, assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Compiled context source path")).split(sep).join("/") || fallbackDatasetPath
+        : fallbackDatasetPath;
+    return sourceDatasetConfigFromInterfConfig(config, datasetPath);
+}
+export function saveCompiledInterfConfig(compiledPath, config) {
+    mkdirSync(compiledInterfRoot(compiledPath), { recursive: true });
+    writeFileSync(compiledInterfConfigPath(compiledPath), JSON.stringify(config, null, 2) + "\n");
+    return config;
+}
+export function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, datasetConfig) {
+    const current = readInterfConfig(compiledPath);
+    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
+    const datasetAbsolutePath = resolve(projectPath, datasetConfig.path);
+    const datasetRelativePath = relative(compiledPath, datasetAbsolutePath).split(sep).join("/") || ".";
+    const workflowId = datasetConfig.workflow ?? current?.workflow ?? "interf";
+    const workflowChanged = current?.workflow !== undefined && current.workflow !== workflowId;
+    const workflowOrigin = workflowChanged || !current?.workflow_origin
+        ? {
+            selected: workflowId,
+            local_draft: false,
+        }
+        : current.workflow_origin;
+    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, workflow: _ignoredWorkflow, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, workflow_origin: _ignoredWorkflowOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
+    const nextConfig = {
+        ...passthrough,
+        ...(!current ? {
+            type: "compiled",
+            source: {
+                path: "./raw",
+            },
+        } : {}),
+        type: "compiled",
+        name: datasetConfig.name,
+        ...(datasetConfig.about ? { about: datasetConfig.about } : {}),
+        workflow: workflowId,
+        ...(typeof datasetConfig.max_attempts === "number"
+            ? { max_attempts: datasetConfig.max_attempts }
+            : {}),
+        ...(typeof datasetConfig.max_loops === "number"
+            ? { max_loops: datasetConfig.max_loops }
+            : {}),
+        checks: datasetConfig.checks,
+        workflow_origin: workflowOrigin,
+        source: {
+            path: current?.source?.path ?? "./raw",
+            control_path: defaultControlPathForCompiled(compiledPath),
+            dataset_path: datasetRelativePath,
+        },
+    };
+    const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
+    if (workflowChanged) {
+        const sourcePath = projectPath;
+        const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
+        seedCompiledWorkflowPackage({
+            compiledPath,
+            sourcePath,
+            workflowId: selectedWorkflow.id,
+        });
+    }
+    refreshCompiledBootstrapGuidance(compiledPath);
+    return saved;
+}
+function buildLoadedTestSpec(options) {
+    if (options.checks.length === 0)
+        return null;
+    const testId = options.id ?? slugify(options.name);
+    return {
+        id: options.targetType === "raw" ? `${testId}-raw` : testId,
+        filePath: options.filePath,
+        type: options.targetType,
+        name: options.name,
+        description: options.about ?? options.fallbackDescription,
+        cases: normalizeTruthChecks(options.checks),
+    };
+}
+export function buildTestSpecFromSourceFolderConfig(options) {
+    const { sourcePath, targetName, targetType = "compiled" } = options;
+    const config = loadSourceFolderConfig(sourcePath);
+    if (!config)
+        return null;
+    const datasets = listSourceDatasetConfigs(config);
+    if (datasets.length === 0)
+        return null;
+    const match = targetName
+        ? datasets.find((entry) => entry.name === targetName)
+        : datasets.length === 1
+            ? datasets[0]
+            : getDefaultSourceDatasetConfig(config);
+    if (!match)
+        return null;
+    const configPath = sourceConfigPath(sourcePath);
+    return buildLoadedTestSpec({
+        id: match.id,
+        name: match.name,
+        about: match.about,
+        checks: match.checks,
+        targetType,
+        filePath: targetType === "raw"
+            ? `${configPath}#datasets/${match.name}:file-as-is`
+            : `${configPath}#datasets/${match.name}:compiled`,
+        fallbackDescription: `Derived from saved dataset checks in ${SOURCE_FOLDER_CONFIG_FILE}`,
+    });
+}
+export function buildTestSpecFromCompiledDatasetConfig(options) {
+    const { compiledPath, targetType = "compiled" } = options;
+    const config = readInterfConfig(compiledPath);
+    const configPath = compiledInterfConfigPath(compiledPath);
+    if (!config)
+        return null;
+    return buildLoadedTestSpec({
+        name: config.name,
+        about: config.about,
+        checks: config.checks ?? [],
+        targetType,
+        filePath: targetType === "raw"
+            ? `${configPath}#checks:file-as-is`
+            : `${configPath}#checks:compiled`,
+        fallbackDescription: "Derived from checks in the compiled context config.",
+    });
+}
+export function resolveSourceDatasetPath(projectPath, datasetConfig) {
+    return assertPathWithinRoot(projectPath, resolve(projectPath, datasetConfig.path), "Dataset path");
+}

package/dist/packages/shared/file-types.d.ts

@@ -0,0 +1 @@
+export declare function isMarkdownFile(filePath: string): boolean;

package/dist/packages/shared/file-types.js

@@ -0,0 +1,4 @@
+import { extname } from "node:path";
+export function isMarkdownFile(filePath) {
+    return extname(filePath).toLowerCase() === ".md";
+}

package/dist/packages/shared/filesystem.d.ts

@@ -0,0 +1,2 @@
+export declare function countFilesRecursive(dirPath: string): number;
+export declare function listFilesRecursive(dirPath: string, predicate?: (filePath: string) => boolean): string[];

package/dist/packages/shared/filesystem.js

@@ -0,0 +1,55 @@
+import { existsSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { join } from "node:path";
+export function countFilesRecursive(dirPath) {
+    if (!existsSync(dirPath))
+        return 0;
+    let total = 0;
+    walkFilesRecursive(dirPath, () => {
+        total += 1;
+    });
+    return total;
+}
+export function listFilesRecursive(dirPath, predicate) {
+    const files = [];
+    if (!existsSync(dirPath))
+        return files;
+    walkFilesRecursive(dirPath, (filePath) => {
+        if (!predicate || predicate(filePath)) {
+            files.push(filePath);
+        }
+    });
+    return files;
+}
+function walkFilesRecursive(dirPath, onFile, visitedDirs = new Set()) {
+    if (!existsSync(dirPath))
+        return;
+    walkFilesRecursiveInternal(dirPath, onFile, visitedDirs);
+}
+function walkFilesRecursiveInternal(dirPath, onFile, visitedDirs) {
+    let resolvedDir;
+    try {
+        resolvedDir = realpathSync(dirPath);
+    }
+    catch {
+        return;
+    }
+    if (visitedDirs.has(resolvedDir))
+        return;
+    visitedDirs.add(resolvedDir);
+    for (const entry of readdirSync(dirPath)) {
+        const fullPath = join(dirPath, entry);
+        let stat;
+        try {
+            stat = statSync(fullPath);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isDirectory()) {
+            walkFilesRecursiveInternal(fullPath, onFile, visitedDirs);
+        }
+        else if (stat.isFile()) {
+            onFile(fullPath);
+        }
+    }
+}

package/dist/packages/shared/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./file-types.js";
+export * from "./filesystem.js";
+export * from "./logger.js";
+export * from "./naming.js";
+export * from "./parse.js";
+export * from "./path-guards.js";
+export * from "./util.js";

package/dist/packages/shared/index.js

@@ -0,0 +1,7 @@
+export * from "./file-types.js";
+export * from "./filesystem.js";
+export * from "./logger.js";
+export * from "./naming.js";
+export * from "./parse.js";
+export * from "./path-guards.js";
+export * from "./util.js";

package/dist/packages/shared/logger.d.ts

@@ -0,0 +1,3 @@
+export type InterfWarningHandler = (message: string) => void;
+export declare function setInterfWarningHandler(handler?: InterfWarningHandler): void;
+export declare function warnInterf(message: string): void;

package/dist/packages/shared/logger.js

@@ -0,0 +1,10 @@
+const defaultWarningHandler = (message) => {
+    console.warn(message);
+};
+let currentWarningHandler = defaultWarningHandler;
+export function setInterfWarningHandler(handler) {
+    currentWarningHandler = handler ?? defaultWarningHandler;
+}
+export function warnInterf(message) {
+    currentWarningHandler(message);
+}

package/dist/packages/shared/naming.d.ts

@@ -0,0 +1 @@
+export declare function slugify(input: string): string;

package/dist/packages/shared/naming.js

@@ -0,0 +1,8 @@
+export function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}

package/dist/packages/shared/parse.d.ts

@@ -0,0 +1,8 @@
+import type { ZodType } from "zod";
+export declare function readJsonFileUnchecked<T>(filePath: string, label: string): T | null;
+export declare function readJsonFileWithSchema<T>(filePath: string, label: string, schema: ZodType<T>): T | null;
+export declare function renderJsonFrontmatter(frontmatter: Record<string, unknown>): string;
+export declare function parseJsonFrontmatter(content: string): {
+    frontmatter: Record<string, unknown>;
+    body: string;
+} | null;

package/dist/packages/shared/parse.js

@@ -0,0 +1,145 @@
+import { readFileSync } from "node:fs";
+import { warnInterf } from "./logger.js";
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function readJsonFileUnchecked(filePath, label) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch (error) {
+        warnInterf(`Warning: failed to parse ${label} at ${filePath}: ${formatError(error)}`);
+        return null;
+    }
+}
+export function readJsonFileWithSchema(filePath, label, schema) {
+    const raw = readJsonFileUnchecked(filePath, label);
+    if (raw === null)
+        return null;
+    const parsed = schema.safeParse(raw);
+    if (!parsed.success) {
+        warnInterf(`Warning: failed to validate ${label} at ${filePath}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        return null;
+    }
+    return parsed.data;
+}
+export function renderJsonFrontmatter(frontmatter) {
+    return [
+        "---",
+        JSON.stringify(frontmatter, null, 2),
+        "---",
+    ].join("\n");
+}
+function parseQuotedString(value) {
+    if (value.length < 2)
+        return null;
+    const quote = value[0];
+    if ((quote !== "\"" && quote !== "'") || value[value.length - 1] !== quote)
+        return null;
+    const inner = value.slice(1, -1);
+    if (quote === "\"") {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    return inner.replace(/\\'/g, "'");
+}
+function parseYamlScalar(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return "";
+    const quoted = parseQuotedString(trimmed);
+    if (quoted !== null)
+        return quoted;
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    if (trimmed === "null")
+        return null;
+    if (/^-?\d+(?:\.\d+)?$/.test(trimmed))
+        return Number(trimmed);
+    if ((trimmed.startsWith("[") && trimmed.endsWith("]"))
+        || (trimmed.startsWith("{") && trimmed.endsWith("}"))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed;
+        }
+    }
+    return trimmed;
+}
+function parseYamlFrontmatter(frontmatterText) {
+    const lines = frontmatterText.split("\n");
+    const frontmatter = {};
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.startsWith("#"))
+            continue;
+        const match = line.match(/^([A-Za-z0-9_-]+):(?:\s+(.*))?$/);
+        if (!match)
+            return null;
+        const [, key, inlineValue] = match;
+        if (!key)
+            return null;
+        if (inlineValue && inlineValue.trim().length > 0) {
+            frontmatter[key] = parseYamlScalar(inlineValue);
+            continue;
+        }
+        const items = [];
+        let cursor = index + 1;
+        while (cursor < lines.length) {
+            const nextLine = lines[cursor] ?? "";
+            const nextTrimmed = nextLine.trim();
+            if (nextTrimmed.length === 0) {
+                cursor += 1;
+                continue;
+            }
+            const itemMatch = nextLine.match(/^\s*-\s+(.*)$/);
+            if (!itemMatch || !/^\s+/.test(nextLine))
+                break;
+            items.push(parseYamlScalar(itemMatch[1] ?? ""));
+            cursor += 1;
+        }
+        if (items.length > 0) {
+            frontmatter[key] = items;
+            index = cursor - 1;
+            continue;
+        }
+        frontmatter[key] = "";
+    }
+    return Object.keys(frontmatter).length > 0 ? frontmatter : null;
+}
+export function parseJsonFrontmatter(content) {
+    const normalized = content.replace(/\r\n/g, "\n");
+    const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match)
+        return null;
+    const [, frontmatterText, body = ""] = match;
+    if (frontmatterText === undefined)
+        return null;
+    try {
+        const frontmatter = JSON.parse(frontmatterText);
+        if (!frontmatter || typeof frontmatter !== "object" || Array.isArray(frontmatter)) {
+            return null;
+        }
+        return {
+            frontmatter: frontmatter,
+            body,
+        };
+    }
+    catch {
+        const frontmatter = parseYamlFrontmatter(frontmatterText);
+        if (!frontmatter)
+            return null;
+        return {
+            frontmatter,
+            body,
+        };
+    }
+}

package/dist/packages/shared/path-guards.d.ts

@@ -0,0 +1,2 @@
+export declare function isPathWithinRoot(rootPath: string, candidatePath: string): boolean;
+export declare function assertPathWithinRoot(rootPath: string, candidatePath: string, label: string): string;

package/dist/packages/shared/path-guards.js

@@ -0,0 +1,14 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+export function isPathWithinRoot(rootPath, candidatePath) {
+    const root = resolve(rootPath);
+    const candidate = resolve(candidatePath);
+    const relativePath = relative(root, candidate);
+    return relativePath === "" || (!isAbsolute(relativePath) && relativePath !== ".." && !relativePath.startsWith(`..${sep}`));
+}
+export function assertPathWithinRoot(rootPath, candidatePath, label) {
+    const resolvedPath = resolve(candidatePath);
+    if (!isPathWithinRoot(rootPath, resolvedPath)) {
+        throw new Error(`${label} must stay inside ${resolve(rootPath)}: ${resolvedPath}`);
+    }
+    return resolvedPath;
+}

package/dist/packages/shared/util.d.ts

@@ -0,0 +1,3 @@
+export { isMarkdownFile } from "./file-types.js";
+export { slugify } from "./naming.js";
+export { assertPathWithinRoot, isPathWithinRoot } from "./path-guards.js";

package/dist/packages/shared/util.js

@@ -0,0 +1,3 @@
+export { isMarkdownFile } from "./file-types.js";
+export { slugify } from "./naming.js";
+export { assertPathWithinRoot, isPathWithinRoot } from "./path-guards.js";

package/dist/packages/testing/index.d.ts

@@ -0,0 +1,13 @@
+export * as schema from "./lib/schema.js";
+export * as test from "./test.js";
+export * as execution from "./test-execution.js";
+export * as matrices from "./test-matrices.js";
+export * as paths from "./test-paths.js";
+export * as profilePresets from "./test-profile-presets.js";
+export * as sandbox from "./test-sandbox.js";
+export * as specs from "./test-specs.js";
+export * as targets from "./test-targets.js";
+export * as types from "./test-types.js";
+export type { TestCase, TestCaseExpect, TestCheckResult, TestCaseResult, TestSpec, TestTargetResult, TestTargetRun, TestRunComparison, TestTargetType, } from "./lib/schema.js";
+export type { LoadedTestSpec, TestTargetCandidate, } from "./test-types.js";
+export type { TestSandboxRetentionMode, } from "./test-sandbox.js";

package/dist/packages/testing/index.js

@@ -0,0 +1,10 @@
+export * as schema from "./lib/schema.js";
+export * as test from "./test.js";
+export * as execution from "./test-execution.js";
+export * as matrices from "./test-matrices.js";
+export * as paths from "./test-paths.js";
+export * as profilePresets from "./test-profile-presets.js";
+export * as sandbox from "./test-sandbox.js";
+export * as specs from "./test-specs.js";
+export * as targets from "./test-targets.js";
+export * as types from "./test-types.js";