@interf/compiler 0.16.0 → 0.21.0

package/dist/packages/engine/server.d.ts

@@ -1,5 +1,7 @@
 import { type Server } from "node:http";
 import { type LocalServiceRunHandlers, type LocalServiceRuntime } from "./runtime.js";
+import type { IdempotencyStore, RunLeaseStore, TokenValidator } from "./cloud-seams.js";
+import type { BillingEventSink } from "./compile/billing-events.js";
 /** Generate a fresh per-instance bearer token. */
 export declare function createLocalServiceAuthToken(): string;
 export interface StartLocalServiceOptions {
@@ -21,6 +23,29 @@ export interface StartLocalServiceOptions {
      * and any caller that explicitly opts in).
      */
     authToken?: string | null | "auto";
+    /**
+     * 0.17 — cloud-variant auth seam (B4.3). When provided, every
+     * mutating request runs through this validator instead of the local
+     * constant-time bearer check, and the resulting `account_id` is
+     * stashed on the runtime context for billing-event attribution.
+     * Local default: `undefined` — fall back to `runtime.authToken`
+     * comparison.
+     */
+    tokenValidator?: TokenValidator;
+    /**
+     * 0.17 — cloud-variant interface seams forwarded to
+     * `LocalServiceRuntime`. Local default: in-process `Map`s on the
+     * runtime. Cloud variants pass shared implementations (Redis,
+     * Cassandra, etc.) so multi-replica engines coordinate. See
+     * `cloud-seams.ts` for the contracts.
+     */
+    idempotencyStore?: IdempotencyStore;
+    runLeaseStore?: RunLeaseStore;
+    /**
+     * 0.17 — billing event sink. Local default writes per-run JSONL.
+     * Cloud variants inject a Metronome HTTP sender once 0.18+ ships.
+     */
+    billingEventSink?: BillingEventSink;
 }
 export interface StartedLocalService {
     runtime: LocalServiceRuntime;

package/dist/packages/engine/server.js

@@ -4,7 +4,7 @@ import { randomBytes } from "node:crypto";
 import { existsSync, statSync, readFileSync } from "node:fs";
 import { dirname, extname, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { LOCAL_SERVICE_LOOPBACK_HOSTS, LocalServiceConfigSchema, LocalServiceDiscoverySchema, LocalServiceErrorSchema, OpenPathRequestSchema, ServiceRegistryEntrySchema, } from "./lib/schema.js";
+import { LOCAL_SERVICE_LOOPBACK_HOSTS, LocalServiceConfigSchema, LocalServiceDiscoverySchema, LocalServiceErrorSchema, OpenPathRequestSchema, PreparationCreateRequestSchema, PreparationUpdateRequestSchema, ServiceRegistryEntrySchema, } from "./lib/schema.js";
 import { assertPathWithinRoot, } from "../contracts/utils/path-guards.js";
 import { createLocalServiceRuntime, } from "./runtime.js";
 import { buildLocalServiceUrl, LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_ROUTES, PREPARATION_SUBRESOURCES, } from "./routes.js";
@@ -124,7 +124,7 @@ function packageRoot() {
 }
 export function resolveCompilerUiStaticRoot(rootPath = packageRoot()) {
     const distRoot = join(rootPath, "dist", "compiler-ui");
-    const sourceExportRoot = join(rootPath, "apps", "compiler-ui", "out");
+    const sourceExportRoot = join(rootPath, "src", "apps", "compiler-ui", "out");
     if (existsSync(join(distRoot, "index.html")))
         return distRoot;
     if (existsSync(join(sourceExportRoot, "index.html")))
@@ -309,9 +309,18 @@ function sendFile(res, filePath) {
     try {
         if (!statSync(filePath).isFile())
             return false;
-        writeHeaders(res, 200, {
-            "content-type": contentType(filePath),
-        });
+        const type = contentType(filePath);
+        const headers = { "content-type": type };
+        // 0.17 — never cache HTML responses. UI deploys ship a fresh
+        // dist via `npm run web:build` and a restart; without `no-store`,
+        // a browser sitting on a stale `index.html` would keep loading
+        // hashed asset paths that no longer exist. Hashed Next.js bundles
+        // under `_next/static/<hash>/` keep the default long-cache
+        // because the filename itself changes when content changes.
+        if (type.startsWith("text/html")) {
+            headers["cache-control"] = "no-store";
+        }
+        writeHeaders(res, 200, headers);
         res.end(readFileSync(filePath));
         return true;
     }
@@ -375,6 +384,78 @@ async function routeApi(req, res, runtime) {
     const method = req.method ?? "GET";
     const origin = originHeaderValue(req);
     const allowed = buildAllowedOrigins(runtime.host, runtime.port);
+    const prepDataDirsForInstance = () => {
+        const dirs = listStoredPreparations().map((prep) => prep.prepDataDir);
+        return dirs.length > 0 ? dirs : [runtime.rootPath];
+    };
+    const listInstanceRuns = () => {
+        return prepDataDirsForInstance()
+            .flatMap((prepDataDir) => runtime.listRunObservability(prepDataDir))
+            .sort((left, right) => {
+            const leftMs = Date.parse(left.started_at ?? left.created_at ?? left.finished_at ?? "");
+            const rightMs = Date.parse(right.started_at ?? right.created_at ?? right.finished_at ?? "");
+            return (Number.isFinite(rightMs) ? rightMs : 0) - (Number.isFinite(leftMs) ? leftMs : 0);
+        });
+    };
+    const findInstanceRun = (runId) => {
+        for (const prepDataDir of prepDataDirsForInstance()) {
+            const run = runtime.getRunObservability(prepDataDir, runId);
+            if (run)
+                return run;
+        }
+        return null;
+    };
+    const findInstanceJob = (runId) => {
+        for (const prepDataDir of prepDataDirsForInstance()) {
+            const job = runtime.getJob(prepDataDir, runId);
+            if (job)
+                return { job, prepDataDir };
+        }
+        return null;
+    };
+    const listInstanceMethods = () => {
+        const byId = new Map();
+        for (const prepDataDir of prepDataDirsForInstance()) {
+            for (const methodResource of runtime.listMethods(prepDataDir)) {
+                const existing = byId.get(methodResource.id);
+                if (!existing) {
+                    byId.set(methodResource.id, methodResource);
+                    continue;
+                }
+                const preferred = existing.built_in && !methodResource.built_in
+                    ? methodResource
+                    : existing;
+                byId.set(methodResource.id, {
+                    ...preferred,
+                    active_for_preparations: Array.from(new Set([
+                        ...existing.active_for_preparations,
+                        ...methodResource.active_for_preparations,
+                    ])).sort(),
+                });
+            }
+        }
+        return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
+    };
+    const findInstanceMethod = (methodId) => {
+        return listInstanceMethods().find((methodResource) => methodResource.id === methodId) ?? null;
+    };
+    const listInstanceMethodRuns = (methodId) => {
+        return prepDataDirsForInstance()
+            .flatMap((prepDataDir) => runtime.listMethodRuns(prepDataDir, methodId))
+            .sort((left, right) => {
+            const leftMs = Date.parse(left.started_at ?? left.created_at ?? left.finished_at ?? "");
+            const rightMs = Date.parse(right.started_at ?? right.created_at ?? right.finished_at ?? "");
+            return (Number.isFinite(rightMs) ? rightMs : 0) - (Number.isFinite(leftMs) ? leftMs : 0);
+        });
+    };
+    const resolveInstanceMethodPackageRoot = (methodId) => {
+        for (const prepDataDir of prepDataDirsForInstance()) {
+            const localPath = methodDefinitionPath(prepDataDir, methodId);
+            if (existsSync(join(localPath, "method.json")))
+                return localPath;
+        }
+        return resolveMethodPackageRoot(methodId);
+    };
     // CORS preflight — answered for allowed origins, refused otherwise.
     if (method === "OPTIONS") {
         if (!isOriginAllowed(origin, allowed)) {
@@ -480,21 +561,15 @@ async function routeApi(req, res, runtime) {
     // POST /v1/preparations — create a new preparation.
     if (method === "POST" && path === LOCAL_SERVICE_ROUTES.preparations) {
         try {
-            const body = (await readJsonBody(req));
-            if (!body || typeof body !== "object") {
-                sendError(res, 400, "Request body must be a JSON object.");
-                return true;
-            }
-            if (!body.id || typeof body.id !== "string") {
-                sendError(res, 400, "Missing required field: id");
-                return true;
-            }
-            if (!body.method_id || typeof body.method_id !== "string") {
-                sendError(res, 400, "Missing required field: method_id");
-                return true;
-            }
-            if (!body.source || typeof body.source !== "object" || !body.source.locator) {
-                sendError(res, 400, "Missing required field: source.locator");
+            const body = PreparationCreateRequestSchema.parse(await readJsonBody(req));
+            // TODO(cloud): activate remote-folder validator branch when the
+            // cloud variant lands. The local binary only knows how to read
+            // bytes from a local path; a `remote-folder` binding requires
+            // the cloud variant's per-account object-storage mount layer.
+            // Until then, reject any kind other than `local-folder` so the
+            // wire shape and runtime stay consistent.
+            if (body.source.kind !== "local-folder") {
+                sendError(res, 400, `Unsupported source kind: ${body.source.kind}. The local engine only accepts local-folder bindings; remote-folder requires the cloud variant.`);
                 return true;
             }
             const stored = createStoredPreparation(runtime, {
@@ -502,6 +577,8 @@ async function routeApi(req, res, runtime) {
                 source: { kind: "local-folder", locator: body.source.locator },
                 method_id: body.method_id,
                 about: body.about,
+                requested_artifacts: body.requested_artifacts,
+                source_profile: body.source_profile,
                 checks: body.checks,
                 max_attempts: body.max_attempts,
                 max_loops: body.max_loops,
@@ -531,19 +608,26 @@ async function routeApi(req, res, runtime) {
         if (subPath === "") {
             // Bare /v1/preparations/{id}
             if (method === "GET") {
-                sendJson(res, 200, preparationWireShape(storedPrep));
+                const preparation = runtime.getPreparation(storedPrep.prepDataDir, storedPrep.id);
+                sendJson(res, 200, preparation
+                    ? {
+                        ...preparation,
+                        source: storedPrep.source,
+                        about: storedPrep.about,
+                        config_path: storedPrep.configPath,
+                    }
+                    : preparationWireShape(storedPrep));
                 return true;
             }
             if (method === "PATCH") {
                 try {
-                    const body = (await readJsonBody(req));
-                    if (!body || typeof body !== "object") {
-                        sendError(res, 400, "Request body must be a JSON object.");
-                        return true;
-                    }
+                    const body = PreparationUpdateRequestSchema.parse(await readJsonBody(req));
                     const updated = updateStoredPreparation(decodedPrepId, {
                         method_id: body.method_id,
                         about: body.about,
+                        ...(body.checks !== undefined ? { checks: body.checks } : {}),
+                        ...(body.requested_artifacts !== undefined ? { requested_artifacts: body.requested_artifacts } : {}),
+                        ...(body.source_profile !== undefined ? { source_profile: body.source_profile } : {}),
                     });
                     sendJson(res, 200, preparationWireShape(updated));
                 }
@@ -561,7 +645,7 @@ async function routeApi(req, res, runtime) {
         else if (subPath === PREPARATION_SUBRESOURCES.compileRuns) {
             if (method === "POST") {
                 if (!storedPrep.methodId) {
-                    sendError(res, 400, `Preparation ${storedPrep.id} has no method bound. Set one via PATCH /v1/preparations/${storedPrep.id} { "method_id": "<id>" } before compiling.`);
+                    sendError(res, 400, `Preparation ${storedPrep.id} has no Build Plan selected. Select one via PATCH /v1/preparations/${storedPrep.id} { "method_id": "<id>" } before compiling.`);
                     return true;
                 }
                 try {
@@ -597,7 +681,7 @@ async function routeApi(req, res, runtime) {
         else if (subPath === PREPARATION_SUBRESOURCES.verifyRuns) {
             if (method === "POST") {
                 if (!storedPrep.methodId) {
-                    sendError(res, 400, `Preparation ${storedPrep.id} has no method bound. Set one via PATCH /v1/preparations/${storedPrep.id} { "method_id": "<id>" } before verifying.`);
+                    sendError(res, 400, `Preparation ${storedPrep.id} has no Build Plan selected. Select one via PATCH /v1/preparations/${storedPrep.id} { "method_id": "<id>" } before verifying.`);
                     return true;
                 }
                 try {
@@ -738,6 +822,29 @@ async function routeApi(req, res, runtime) {
                 return true;
             }
         }
+        else if (subPath.startsWith(`${PREPARATION_SUBRESOURCES.artifacts}/`)) {
+            // GET /v1/preparations/<id>/artifacts/<artifact-id> — per-Artifact
+            // status from the latest compile run. 0.17.
+            if (method === "GET") {
+                const rawArtifactId = subPath.slice(PREPARATION_SUBRESOURCES.artifacts.length + 1);
+                let artifactId;
+                try {
+                    artifactId = decodeURIComponent(rawArtifactId);
+                }
+                catch {
+                    sendError(res, 400, "Artifact id is not valid URI-encoded UTF-8.");
+                    return true;
+                }
+                const preparation = runtime.getPreparation(storedPrep.prepDataDir, storedPrep.id);
+                const status = preparation?.artifacts.find((entry) => entry.artifact_id === artifactId);
+                if (!status) {
+                    sendError(res, 404, `Artifact not found: ${artifactId}`);
+                    return true;
+                }
+                sendJson(res, 200, status);
+                return true;
+            }
+        }
         sendError(res, 404, `Unknown preparation sub-route: ${subPath}`);
         return true;
     }
@@ -745,17 +852,12 @@ async function routeApi(req, res, runtime) {
     // Method resources — preparation-independent (workspace draft + user lib + bundled).
     // ─────────────────────────────────────────────────────────────────────────
     if (method === "GET" && path === LOCAL_SERVICE_ROUTES.methods) {
-        // The runtime needs SOME prep data dir to discover preparation-draft methods.
-        // Fall back to the first registered preparation (if any) so user-library
-        // and bundled methods still surface even when no preparation has drafts.
-        const firstPrep = listStoredPreparations()[0];
-        sendJson(res, 200, { methods: runtime.listMethods(firstPrep?.prepDataDir ?? runtime.rootPath) });
+        sendJson(res, 200, { methods: listInstanceMethods() });
         return true;
     }
     const methodMatch = path.match(/^\/v1\/methods\/([^/]+)$/);
     if (method === "GET" && methodMatch?.[1]) {
-        const firstPrep = listStoredPreparations()[0];
-        const methodResource = runtime.getMethod(firstPrep?.prepDataDir ?? runtime.rootPath, decodeURIComponent(methodMatch[1]));
+        const methodResource = findInstanceMethod(decodeURIComponent(methodMatch[1]));
         if (!methodResource)
             sendError(res, 404, "Method not found.");
         else
@@ -764,8 +866,7 @@ async function routeApi(req, res, runtime) {
     }
     const methodRunsMatch = path.match(/^\/v1\/methods\/([^/]+)\/runs$/);
     if (method === "GET" && methodRunsMatch?.[1]) {
-        const firstPrep = listStoredPreparations()[0];
-        const runs = runtime.listMethodRuns(firstPrep?.prepDataDir ?? runtime.rootPath, decodeURIComponent(methodRunsMatch[1]));
+        const runs = listInstanceMethodRuns(decodeURIComponent(methodRunsMatch[1]));
         sendJson(res, 200, { runs });
         return true;
     }
@@ -790,8 +891,7 @@ async function routeApi(req, res, runtime) {
             sendError(res, 400, "File path escapes method root.");
             return true;
         }
-        const firstPrep = listStoredPreparations()[0];
-        const root = resolveMethodPackageRoot(methodId, firstPrep?.prepDataDir);
+        const root = resolveInstanceMethodPackageRoot(methodId);
         if (!root) {
             sendError(res, 404, `Method not found: ${methodId}`);
             return true;
@@ -811,14 +911,12 @@ async function routeApi(req, res, runtime) {
     // so the runtime takes a "first prep" hint to scan registered preparations.
     // ─────────────────────────────────────────────────────────────────────────
     if (method === "GET" && path === LOCAL_SERVICE_ROUTES.runs) {
-        const firstPrep = listStoredPreparations()[0];
-        sendJson(res, 200, { runs: runtime.listRunObservability(firstPrep?.prepDataDir ?? runtime.rootPath) });
+        sendJson(res, 200, { runs: listInstanceRuns() });
         return true;
     }
     const observableRunMatch = path.match(/^\/v1\/runs\/([^/]+)$/);
     if (method === "GET" && observableRunMatch?.[1]) {
-        const firstPrep = listStoredPreparations()[0];
-        const run = runtime.getRunObservability(firstPrep?.prepDataDir ?? runtime.rootPath, decodeURIComponent(observableRunMatch[1]));
+        const run = findInstanceRun(decodeURIComponent(observableRunMatch[1]));
         if (!run)
             sendError(res, 404, "Run not found.");
         else
@@ -931,18 +1029,16 @@ async function routeApi(req, res, runtime) {
     if (jobMatch?.[1]) {
         const runId = decodeURIComponent(jobMatch[1]);
         const child = jobMatch[2];
-        const firstPrep = listStoredPreparations()[0];
-        const prepDataDir = firstPrep?.prepDataDir ?? runtime.rootPath;
+        const found = findInstanceJob(runId);
         if (method === "GET" && !child) {
-            const job = runtime.getJob(prepDataDir, runId);
-            if (!job)
+            if (!found)
                 sendError(res, 404, "Job run not found.");
             else
-                sendJson(res, 200, job);
+                sendJson(res, 200, found.job);
             return true;
         }
         if (method === "GET" && child === "events") {
-            const events = runtime.getJobEvents(prepDataDir, runId);
+            const events = found ? runtime.getJobEvents(found.prepDataDir, runId) : null;
             if (!events)
                 sendError(res, 404, "Job run not found.");
             else
@@ -1074,7 +1170,7 @@ async function routeApi(req, res, runtime) {
                 allowedRoots.push(stored.source.locator);
         }
         allowedRoots.push(userMethodsRoot());
-        allowedRoots.push(packageRoot()); // covers <pkg>/builtin-methods/...
+        allowedRoots.push(packageRoot()); // covers <pkg>/public-repo/methods/...
         const openedPath = await openLocalPath(allowedRoots, body.path);
         sendJson(res, 202, { opened: true, path: openedPath });
         return true;
@@ -1181,7 +1277,22 @@ export async function startLocalService(options = {}) {
         packageVersion: options.packageVersion,
         handlers: options.handlers,
         ...(authToken ? { authToken } : {}),
+        // 0.17 — forward cloud-variant injection points. Local default
+        // ignores idempotencyStore / runLeaseStore (the runtime's
+        // in-process maps stay authoritative); they're accepted on the
+        // options surface so cloud forks have a stable target.
+        ...(options.billingEventSink ? { billingEventSink: options.billingEventSink } : {}),
+        ...(options.idempotencyStore ? { idempotencyStore: options.idempotencyStore } : {}),
+        ...(options.runLeaseStore ? { runLeaseStore: options.runLeaseStore } : {}),
     });
+    // 0.17 — token validator (B4.3). Local default: undefined. Cloud
+    // variants pass an async per-account validator. Stashed on the
+    // runtime via `setTokenValidator` so `isAuthorizedMutation` can
+    // pick it up; the local engine ignores it (the static bearer
+    // check still runs).
+    if (options.tokenValidator) {
+        runtime.setTokenValidator(options.tokenValidator);
+    }
     // Rehydrate 0.13 preparations as synthetic workspaces so subsequent
     // compile / test / readiness calls find them after a service restart.
     try {

package/dist/packages/engine/verify/index.d.ts

@@ -1,13 +1,13 @@
 export * as schema from "./lib/schema.js";
-export * as test from "./test.js";
-export * as execution from "./test-execution.js";
-export * as paths from "./test-paths.js";
-export * as profilePresets from "./test-profile-presets.js";
+export * as verify from "./verify.js";
+export * as execution from "./verify-execution.js";
+export * as paths from "./verify-paths.js";
+export * as profilePresets from "./verify-profile-presets.js";
 export * as readinessCheckRun from "./readiness-check-run.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 * as sandbox from "./verify-sandbox.js";
+export * as specs from "./verify-specs.js";
+export * as targets from "./verify-targets.js";
+export * as types from "./verify-types.js";
 export type { TestCase, TestCaseExpect, TestCheckResult, TestCaseResult, TestSpec, TestTargetResult, TestTargetRun, ReadinessCheckRun, TestTargetType, } from "./lib/schema.js";
-export type { LoadedTestSpec, TestTargetCandidate, } from "./test-types.js";
-export type { TestSandboxRetentionMode, } from "./test-sandbox.js";
+export type { LoadedTestSpec, TestTargetCandidate, } from "./verify-types.js";
+export type { TestSandboxRetentionMode, } from "./verify-sandbox.js";

package/dist/packages/engine/verify/index.js

@@ -1,10 +1,10 @@
 export * as schema from "./lib/schema.js";
-export * as test from "./test.js";
-export * as execution from "./test-execution.js";
-export * as paths from "./test-paths.js";
-export * as profilePresets from "./test-profile-presets.js";
+export * as verify from "./verify.js";
+export * as execution from "./verify-execution.js";
+export * as paths from "./verify-paths.js";
+export * as profilePresets from "./verify-profile-presets.js";
 export * as readinessCheckRun from "./readiness-check-run.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 * as sandbox from "./verify-sandbox.js";
+export * as specs from "./verify-specs.js";
+export * as targets from "./verify-targets.js";
+export * as types from "./verify-types.js";

package/dist/packages/engine/verify/readiness-check-run.d.ts

@@ -1,7 +1,8 @@
 import type { MethodExecutor } from "../agents/lib/executors.js";
 import type { SourcePreparationConfig } from "../../project/lib/schema.js";
-import { type TestTargetCandidate, type TestTargetResult } from "./test.js";
-import type { TestSandboxRetentionMode } from "./test-sandbox.js";
+import type { TestTargetType } from "../../contracts/lib/schema.js";
+import { type TestTargetCandidate, type TestTargetResult } from "./verify.js";
+import type { TestSandboxRetentionMode } from "./verify-sandbox.js";
 import { type ReadinessCheckRun } from "./lib/schema.js";
 export interface SavedReadinessCheckOutcome {
     runPath: string;
@@ -14,8 +15,9 @@ export interface ReadinessCheckRunResult {
     preparationConfig: SourcePreparationConfig;
     portableContextPath: string | null;
     /**
-     * 0.15 — `sourceFilesOutcome` is always `null`. Kept on the type so
-     * older readers parse cleanly during the rollout; remove in 0.16+.
+     * 0.17 — restored. Populated when the verify run targets
+     * `source-files`; null when targeting `compiled`. Aggregates back
+     * onto the saved `ReadinessCheckRun` payload's `source_files` field.
      */
     sourceFilesOutcome: SavedReadinessCheckOutcome | null;
     compiledOutcome: SavedReadinessCheckOutcome | null;
@@ -39,6 +41,7 @@ export declare function saveReadinessCheckRun(options: {
     portableContextPath: string | null;
     preparationName: string;
     checksFingerprint: string;
+    sourceFilesOutcome?: SavedReadinessCheckOutcome | null;
     compiledOutcome: SavedReadinessCheckOutcome | null;
 }): string;
 export declare function runSavedPortableContextCheck(options: {
@@ -49,6 +52,20 @@ export declare function runSavedPortableContextCheck(options: {
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;
 }): Promise<SavedReadinessCheckOutcome | null>;
+/**
+ * 0.17 — restored. Runs the saved readiness checks against the source
+ * folder baseline (no portable-context indirection) so users can see how
+ * much value the Method actually adds. The lower-level `verify-execution`
+ * + `verify-sandbox` source-files paths have stayed in tree since 0.13;
+ * this is the orchestrator hook that was missing.
+ */
+export declare function runSavedSourceFilesCheck(options: {
+    sourcePath: string;
+    preparationConfig: SourcePreparationConfig;
+    executor?: MethodExecutor | null;
+    preserveSandboxes?: TestSandboxRetentionMode;
+    runSuffix?: string | null;
+}): Promise<SavedReadinessCheckOutcome | null>;
 export declare function runReadinessChecksForExecutor(options: {
     sourcePath: string;
     preparationConfig: SourcePreparationConfig;
@@ -57,4 +74,10 @@ export declare function runReadinessChecksForExecutor(options: {
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;
     saveLatest?: boolean;
+    /**
+     * 0.17 — selects which target the readiness checks judge against.
+     * Defaults to `compiled` for backward compatibility with existing
+     * callers.
+     */
+    target?: TestTargetType;
 }): Promise<ReadinessCheckRunResult>;