@interf/compiler 0.9.5 → 0.13.0

package/dist/packages/local-service/client.d.ts

@@ -1,7 +1,12 @@
-import { type ActionProposalApprovalRequest, type ActionProposalCreateRequest, type ActionProposalResource, type CompileRunCreateRequest, type CompileRunListResponse, type CompileRunResource, type LocalJobRunListResponse, type LocalJobRunResource, type LocalServiceHealth, type MethodChangeCreateRequest, type MethodChangeResult, type PreparationChangeCreateRequest, type PreparationChangeResult, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type ReadinessListResponse, type ResetRequest, type ResetResult, type TestRunCreateRequest, type TestRunListResponse, type TestRunResource, type MethodAuthoringCreateRequest, type MethodAuthoringResult, type PreparationSetupCreateRequest, type PreparationSetupResult } from "./lib/schema.js";
+import { type ActionProposalApprovalRequest, type ActionProposalCreateRequest, type ActionProposalResource, type CompileRunCreateRequest, type CompileRunResource, type LocalJobRunResource, type LocalServiceHealth, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type ResetRequest, type ResetResult, type TestRunCreateRequest, type TestRunResource, type MethodAuthoringCreateRequest, type MethodAuthoringResult } from "./lib/schema.js";
+export interface FindOrStartLocalServiceOptions {
+    url?: string;
+    authToken?: string;
+}
 export interface LocalServiceConnection {
     serviceUrl: string;
     health: LocalServiceHealth;
+    authToken: string | null;
 }
 export interface LocalServiceJobSubmission<T> {
     serviceUrl: string;
@@ -13,69 +18,59 @@ export interface LocalServiceJobSubmitted {
     serviceUrl: string;
     job: LocalJobRunResource;
 }
-export interface LocalServiceRunSnapshot {
-    jobs: LocalJobRunResource[];
-    compileRuns: CompileRunResource[];
-    testRuns: TestRunResource[];
-}
 export declare function configuredLocalServiceUrl(): string;
-export declare function findLocalService(options: {
-    projectPath: string;
+/**
+ * Resolve the bearer token for the active connection. In 0.13 there is
+ * exactly one source of truth: `~/.interf/connection.json` (or the
+ * `INTERF_SERVICE_TOKEN` env override).
+ */
+export declare function resolveLocalServiceAuthToken(): string | null;
+/**
+ * Resolve a connection. In 0.13 this is the only path to the engine — read
+ * `~/.interf/connection.json` (written by `interf web`) or honor the
+ * `INTERF_SERVICE_URL` / `INTERF_SERVICE_TOKEN` env overrides.
+ */
+export declare function findLocalService(options?: {
     timeoutMs?: number;
 }): Promise<LocalServiceConnection | null>;
 export declare function submitCompileRunToLocalService(options: {
-    projectPath: string;
+    preparationId: string;
     request: CompileRunCreateRequest;
+    idempotencyKey?: string;
 }): Promise<{
     serviceUrl: string;
     resource: CompileRunResource;
 } | null>;
 export declare function submitTestRunToLocalService(options: {
-    projectPath: string;
+    preparationId: string;
     request: TestRunCreateRequest;
 }): Promise<{
     serviceUrl: string;
     resource: TestRunResource;
 } | null>;
-export declare function submitPreparationSetupToLocalService(options: {
-    projectPath: string;
-    request: PreparationSetupCreateRequest;
-}): Promise<{
-    serviceUrl: string;
-    result: PreparationSetupResult;
-} | null>;
-export declare function submitPreparationChangeToLocalService(options: {
-    projectPath: string;
-    request: PreparationChangeCreateRequest;
-}): Promise<{
-    serviceUrl: string;
-    result: PreparationChangeResult;
-} | null>;
 export declare function submitResetToLocalService(options: {
-    projectPath: string;
+    preparationId: string;
     request: ResetRequest;
 }): Promise<{
     serviceUrl: string;
     result: ResetResult;
 } | null>;
 export declare function createActionProposalInLocalService(options: {
-    projectPath: string;
     request: ActionProposalCreateRequest;
 }): Promise<{
     serviceUrl: string;
     resource: ActionProposalResource;
 } | null>;
 export declare function decideActionProposalInLocalService(options: {
-    projectPath: string;
     proposalId: string;
     request: ActionProposalApprovalRequest;
     serviceUrl?: string;
+    authToken?: string | null;
 }): Promise<{
     serviceUrl: string;
     resource: ActionProposalResource;
 } | null>;
 export declare function approveActionProposalInLocalService(options: {
-    projectPath: string;
     request: ActionProposalCreateRequest;
 }): Promise<{
     serviceUrl: string;
@@ -84,67 +79,71 @@ export declare function approveActionProposalInLocalService(options: {
 export declare function getLocalCompileRun(options: {
     serviceUrl: string;
     runId: string;
+    authToken?: string | null;
 }): Promise<CompileRunResource>;
-export declare function listLocalCompileRuns(options: {
-    serviceUrl: string;
-    timeoutMs?: number;
-}): Promise<CompileRunListResponse>;
-export declare function listLocalReadiness(options: {
+export interface LocalCompileRunCancelResult {
+    cancelled: boolean;
+    reason?: string;
+}
+/**
+ * Ask the local service to cancel a running compile run by id. Resolves
+ * with the typed cancel result on success and throws when the service
+ * returns 404 (unknown run id) or any non-2xx status.
+ */
+export declare function cancelLocalCompileRun(options: {
     serviceUrl: string;
+    runId: string;
     timeoutMs?: number;
-}): Promise<ReadinessListResponse>;
+    authToken?: string | null;
+}): Promise<LocalCompileRunCancelResult>;
 export declare function waitForLocalCompileRun(options: {
     serviceUrl: string;
     runId: string;
     pollMs?: number;
+    authToken?: string | null;
     onUpdate?: (resource: CompileRunResource) => void;
 }): Promise<CompileRunResource>;
 export declare function getLocalTestRun(options: {
     serviceUrl: string;
     runId: string;
+    authToken?: string | null;
 }): Promise<TestRunResource>;
-export declare function listLocalTestRuns(options: {
-    serviceUrl: string;
-    timeoutMs?: number;
-}): Promise<TestRunListResponse>;
 export declare function waitForLocalTestRun(options: {
     serviceUrl: string;
     runId: string;
     pollMs?: number;
+    authToken?: string | null;
     onUpdate?: (resource: TestRunResource) => void;
 }): Promise<TestRunResource>;
 export declare function getLocalJobRun(options: {
     serviceUrl: string;
     runId: string;
+    authToken?: string | null;
 }): Promise<LocalJobRunResource>;
-export declare function listLocalJobRuns(options: {
-    serviceUrl: string;
-    timeoutMs?: number;
-}): Promise<LocalJobRunListResponse>;
-export declare function readLocalServiceRunSnapshot(options: {
-    serviceUrl: string;
-    timeoutMs?: number;
-}): Promise<LocalServiceRunSnapshot>;
 export declare function waitForLocalJobRun(options: {
     serviceUrl: string;
     runId: string;
     pollMs?: number;
     timeoutMs?: number;
+    authToken?: string | null;
     onUpdate?: (job: LocalJobRunResource) => void;
 }): Promise<LocalJobRunResource>;
 export declare function submitReadinessCheckDraftToLocalService(options: {
-    projectPath: string;
+    preparationId: string;
     request: ReadinessCheckDraftCreateRequest;
     onSubmitted?: (submission: LocalServiceJobSubmitted) => void;
     onUpdate?: (job: LocalJobRunResource) => void;
 }): Promise<LocalServiceJobSubmission<ReadinessCheckDraftResult> | null>;
 export declare function submitMethodAuthoringRunToLocalService(options: {
-    projectPath: string;
+    preparationId: string;
     request: MethodAuthoringCreateRequest;
     onSubmitted?: (submission: LocalServiceJobSubmitted) => void;
     onUpdate?: (job: LocalJobRunResource) => void;
 }): Promise<LocalServiceJobSubmission<MethodAuthoringResult> | null>;
-export declare function submitMethodChangeToLocalService(options: {
-    projectPath: string;
-    request: MethodChangeCreateRequest;
-}): Promise<MethodChangeResult | null>;
+/**
+ * Fetch the engine instance health/status.
+ */
+export declare function getLocalServiceHealth(options: {
+    serviceUrl: string;
+    timeoutMs?: number;
+}): Promise<LocalServiceHealth>;

package/dist/packages/local-service/client.js

@@ -1,7 +1,29 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { CompileRunCreateRequestSchema, CompileRunListResponseSchema, CompileRunResourceSchema, ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalResourceSchema, LocalServicePointerSchema, LocalJobRunListResponseSchema, LocalJobRunResourceSchema, LocalServiceHealthSchema, MethodChangeCreateRequestSchema, MethodChangeResultSchema, PreparationChangeCreateRequestSchema, PreparationChangeResultSchema, PreparationSetupCreateRequestSchema, PreparationSetupResultSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ReadinessListResponseSchema, ResetRequestSchema, ResetResultSchema, TestRunCreateRequestSchema, TestRunListResponseSchema, TestRunResourceSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, } from "./lib/schema.js";
-import { LOCAL_SERVICE_POINTER_PATH, LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, } from "./routes.js";
+import { CompileRunCreateRequestSchema, CompileRunResourceSchema, ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalResourceSchema, LocalJobRunResourceSchema, LocalServiceHealthSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ResetRequestSchema, ResetResultSchema, TestRunCreateRequestSchema, TestRunResourceSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, } from "./lib/schema.js";
+import { LOCAL_SERVICE_ROUTES, buildLocalServiceUrl, preparationSubresourcePath, } from "./routes.js";
+import { readActiveConnection } from "./connection-config.js";
+async function connectOrNull(options = {}) {
+    const conn = readActiveConnection({
+        urlOverride: options.url ?? null,
+        authTokenOverride: options.authToken ?? null,
+    });
+    if (!conn)
+        return null;
+    // Probe the engine; we expose the LocalServiceHealth-shaped object the
+    // legacy callers expect so submitCompileRun et al. keep compiling.
+    try {
+        const headers = {};
+        if (conn.auth_token)
+            headers["authorization"] = `Bearer ${conn.auth_token}`;
+        const response = await fetch(`${conn.url.replace(/\/+$/, "")}/health`, { headers });
+        if (response.status !== 200)
+            return null;
+        const health = (await response.json());
+        return { serviceUrl: conn.url, health, authToken: conn.auth_token ?? null };
+    }
+    catch {
+        return null;
+    }
+}
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/, "");
 }
@@ -11,26 +33,17 @@ export function configuredLocalServiceUrl() {
         return trimTrailingSlash(explicit);
     return buildLocalServiceUrl();
 }
-function projectLocalServiceUrl(projectPath) {
-    const pointerPath = join(projectPath, ...LOCAL_SERVICE_POINTER_PATH);
-    if (!existsSync(pointerPath))
-        return null;
-    try {
-        const pointer = LocalServicePointerSchema.parse(JSON.parse(readFileSync(pointerPath, "utf8")));
-        return trimTrailingSlash(pointer.service_url);
-    }
-    catch {
-        return null;
-    }
-}
-function localServiceUrlCandidates(projectPath) {
-    const explicit = process.env.INTERF_SERVICE_URL?.trim();
+/**
+ * Resolve the bearer token for the active connection. In 0.13 there is
+ * exactly one source of truth: `~/.interf/connection.json` (or the
+ * `INTERF_SERVICE_TOKEN` env override).
+ */
+export function resolveLocalServiceAuthToken() {
+    const explicit = process.env.INTERF_SERVICE_TOKEN?.trim();
     if (explicit)
-        return [trimTrailingSlash(explicit)];
-    return Array.from(new Set([
-        projectLocalServiceUrl(projectPath),
-        buildLocalServiceUrl(),
-    ].filter((value) => Boolean(value))));
+        return explicit;
+    const conn = readActiveConnection();
+    return conn?.auth_token ?? null;
 }
 async function fetchJson(url, options = {}) {
     const controller = new AbortController();
@@ -54,40 +67,35 @@ async function fetchJson(url, options = {}) {
         clearTimeout(timeout);
     }
 }
-function healthMatchesProject(health, projectPath, explicitServiceUrl) {
-    if (explicitServiceUrl)
-        return true;
-    if (!health.control_path)
-        return true;
-    return resolve(health.control_path) === resolve(projectPath);
-}
-export async function findLocalService(options) {
-    const explicitServiceUrl = Boolean(process.env.INTERF_SERVICE_URL?.trim());
-    for (const serviceUrl of localServiceUrlCandidates(options.projectPath)) {
-        try {
-            const health = LocalServiceHealthSchema.parse(await fetchJson(`${serviceUrl}${LOCAL_SERVICE_ROUTES.health}`, {
-                method: "GET",
-                timeoutMs: options.timeoutMs,
-            }));
-            if (!healthMatchesProject(health, options.projectPath, explicitServiceUrl)) {
-                continue;
-            }
-            return { serviceUrl, health };
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}
+/**
+ * Resolve a connection. In 0.13 this is the only path to the engine — read
+ * `~/.interf/connection.json` (written by `interf web`) or honor the
+ * `INTERF_SERVICE_URL` / `INTERF_SERVICE_TOKEN` env overrides.
+ */
+export async function findLocalService(options = {}) {
+    void options.timeoutMs;
+    return connectOrNull();
+}
+function authHeaders(authToken) {
+    return authToken ? { authorization: `Bearer ${authToken}` } : {};
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Preparation-keyed run submission helpers (0.13)
+// ─────────────────────────────────────────────────────────────────────────
 export async function submitCompileRunToLocalService(options) {
-    const connection = await findLocalService({ projectPath: options.projectPath });
+    const connection = await connectOrNull();
     if (!connection)
         return null;
     const request = CompileRunCreateRequestSchema.parse(options.request);
-    const resource = CompileRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.compileRuns}`, {
+    const headers = {
+        ...authHeaders(connection.authToken),
+        ...(options.idempotencyKey ? { "x-interf-idempotency-key": options.idempotencyKey } : {}),
+    };
+    const url = `${connection.serviceUrl}${preparationSubresourcePath(options.preparationId, "compileRuns")}`;
+    const resource = CompileRunResourceSchema.parse(await fetchJson(url, {
         method: "POST",
         body: JSON.stringify(request),
+        headers,
     }));
     return {
         serviceUrl: connection.serviceUrl,
@@ -95,55 +103,31 @@ export async function submitCompileRunToLocalService(options) {
     };
 }
 export async function submitTestRunToLocalService(options) {
-    const connection = await findLocalService({ projectPath: options.projectPath });
+    const connection = await connectOrNull();
     if (!connection)
         return null;
     const request = TestRunCreateRequestSchema.parse(options.request);
-    const resource = TestRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.testRuns}`, {
+    const url = `${connection.serviceUrl}${preparationSubresourcePath(options.preparationId, "testRuns")}`;
+    const resource = TestRunResourceSchema.parse(await fetchJson(url, {
         method: "POST",
         body: JSON.stringify(request),
+        headers: authHeaders(connection.authToken),
     }));
     return {
         serviceUrl: connection.serviceUrl,
         resource,
     };
 }
-export async function submitPreparationSetupToLocalService(options) {
-    const connection = await findLocalService({ projectPath: options.projectPath });
-    if (!connection)
-        return null;
-    const request = PreparationSetupCreateRequestSchema.parse(options.request);
-    const result = PreparationSetupResultSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.preparationSetups}`, {
-        method: "POST",
-        body: JSON.stringify(request),
-    }));
-    return {
-        serviceUrl: connection.serviceUrl,
-        result,
-    };
-}
-export async function submitPreparationChangeToLocalService(options) {
-    const connection = await findLocalService({ projectPath: options.projectPath });
-    if (!connection)
-        return null;
-    const request = PreparationChangeCreateRequestSchema.parse(options.request);
-    const result = PreparationChangeResultSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.preparationChanges}`, {
-        method: "POST",
-        body: JSON.stringify(request),
-    }));
-    return {
-        serviceUrl: connection.serviceUrl,
-        result,
-    };
-}
 export async function submitResetToLocalService(options) {
-    const connection = await findLocalService({ projectPath: options.projectPath });
+    const connection = await connectOrNull();
     if (!connection)
         return null;
     const request = ResetRequestSchema.parse(options.request);
-    const result = ResetResultSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.reset}`, {
+    const url = `${connection.serviceUrl}${preparationSubresourcePath(options.preparationId, "reset")}`;
+    const result = ResetResultSchema.parse(await fetchJson(url, {
         method: "POST",
         body: JSON.stringify(request),
+        headers: authHeaders(connection.authToken),
     }));
     return {
         serviceUrl: connection.serviceUrl,
@@ -151,13 +135,14 @@ export async function submitResetToLocalService(options) {
     };
 }
 export async function createActionProposalInLocalService(options) {
-    const connection = await findLocalService({ projectPath: options.projectPath });
+    const connection = await connectOrNull();
     if (!connection)
         return null;
     const request = ActionProposalCreateRequestSchema.parse(options.request);
     const resource = ActionProposalResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.actionProposals}`, {
         method: "POST",
         body: JSON.stringify(request),
+        headers: authHeaders(connection.authToken),
     }));
     return {
         serviceUrl: connection.serviceUrl,
@@ -166,14 +151,15 @@ export async function createActionProposalInLocalService(options) {
 }
 export async function decideActionProposalInLocalService(options) {
     const connection = options.serviceUrl
-        ? { serviceUrl: options.serviceUrl }
-        : await findLocalService({ projectPath: options.projectPath });
+        ? { serviceUrl: options.serviceUrl, authToken: options.authToken ?? resolveLocalServiceAuthToken() }
+        : (await connectOrNull());
     if (!connection)
         return null;
     const request = ActionProposalApprovalRequestSchema.parse(options.request);
     const resource = ActionProposalResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.actionProposals}/${encodeURIComponent(options.proposalId)}/decision`, {
         method: "POST",
         body: JSON.stringify(request),
+        headers: authHeaders(connection.authToken ?? null),
     }));
     return {
         serviceUrl: connection.serviceUrl,
@@ -187,7 +173,6 @@ export async function approveActionProposalInLocalService(options) {
     if (proposal.resource.status !== "awaiting_approval")
         return proposal;
     const decided = await decideActionProposalInLocalService({
-        projectPath: options.projectPath,
         proposalId: proposal.resource.proposal_id,
         request: { approved: true },
         serviceUrl: proposal.serviceUrl,
@@ -201,85 +186,88 @@ function isTerminalRunStatus(status) {
     return status === "succeeded" || status === "failed" || status === "cancelled";
 }
 export async function getLocalCompileRun(options) {
-    return CompileRunResourceSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.compileRuns}/${encodeURIComponent(options.runId)}`, {
+    return CompileRunResourceSchema.parse(await fetchJson(`${options.serviceUrl}/v1/compile-runs/${encodeURIComponent(options.runId)}`, {
         method: "GET",
         timeoutMs: 2000,
+        headers: authHeaders(options.authToken ?? resolveLocalServiceAuthToken()),
     }));
 }
-export async function listLocalCompileRuns(options) {
-    return CompileRunListResponseSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.compileRuns}`, {
-        method: "GET",
-        timeoutMs: options.timeoutMs ?? 2000,
-    }));
-}
-export async function listLocalReadiness(options) {
-    return ReadinessListResponseSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.readiness}`, {
-        method: "GET",
+/**
+ * Ask the local service to cancel a running compile run by id. Resolves
+ * with the typed cancel result on success and throws when the service
+ * returns 404 (unknown run id) or any non-2xx status.
+ */
+export async function cancelLocalCompileRun(options) {
+    const value = await fetchJson(`${options.serviceUrl}/v1/compile-runs/${encodeURIComponent(options.runId)}/cancel`, {
+        method: "POST",
         timeoutMs: options.timeoutMs ?? 2000,
-    }));
+        headers: authHeaders(options.authToken ?? resolveLocalServiceAuthToken()),
+    });
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Local service returned an unexpected cancel response.");
+    }
+    const record = value;
+    const cancelled = record.cancelled === true;
+    const reason = typeof record.reason === "string" && record.reason.trim().length > 0
+        ? record.reason.trim()
+        : undefined;
+    return reason ? { cancelled, reason } : { cancelled };
 }
 export async function waitForLocalCompileRun(options) {
-    const pollMs = options.pollMs ?? 1000;
+    // Exponential backoff: start at 250ms (responsive for short runs) and
+    // double up to 4s (don't hammer the local service for long compile
+    // runs). When the caller passes an explicit `pollMs`, honor it as a
+    // fixed interval to keep the previous opt-out path.
+    const explicit = options.pollMs;
+    let delay = explicit ?? 250;
     while (true) {
         const resource = await getLocalCompileRun({
             serviceUrl: options.serviceUrl,
             runId: options.runId,
+            authToken: options.authToken ?? null,
         });
         options.onUpdate?.(resource);
         if (isTerminalRunStatus(resource.run.status))
             return resource;
-        await new Promise((resolveWait) => setTimeout(resolveWait, pollMs));
+        await new Promise((resolveWait) => setTimeout(resolveWait, delay));
+        if (explicit === undefined) {
+            delay = Math.min(delay * 2, 4000);
+        }
     }
 }
 export async function getLocalTestRun(options) {
-    return TestRunResourceSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.testRuns}/${encodeURIComponent(options.runId)}`, {
+    return TestRunResourceSchema.parse(await fetchJson(`${options.serviceUrl}/v1/test-runs/${encodeURIComponent(options.runId)}`, {
         method: "GET",
         timeoutMs: 2000,
-    }));
-}
-export async function listLocalTestRuns(options) {
-    return TestRunListResponseSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.testRuns}`, {
-        method: "GET",
-        timeoutMs: options.timeoutMs ?? 2000,
+        headers: authHeaders(options.authToken ?? resolveLocalServiceAuthToken()),
     }));
 }
 export async function waitForLocalTestRun(options) {
-    const pollMs = options.pollMs ?? 1000;
+    // Same exponential backoff as `waitForLocalCompileRun`.
+    const explicit = options.pollMs;
+    let delay = explicit ?? 250;
     while (true) {
         const resource = await getLocalTestRun({
             serviceUrl: options.serviceUrl,
             runId: options.runId,
+            authToken: options.authToken ?? null,
         });
         options.onUpdate?.(resource);
         if (isTerminalRunStatus(resource.status))
             return resource;
-        await new Promise((resolveWait) => setTimeout(resolveWait, pollMs));
+        await new Promise((resolveWait) => setTimeout(resolveWait, delay));
+        if (explicit === undefined) {
+            delay = Math.min(delay * 2, 4000);
+        }
     }
 }
 export async function getLocalJobRun(options) {
-    return LocalJobRunResourceSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.jobs}/${encodeURIComponent(options.runId)}`, {
+    return LocalJobRunResourceSchema.parse(await fetchJson(`${options.serviceUrl}/v1/jobs/${encodeURIComponent(options.runId)}`, {
         method: "GET",
         timeoutMs: 2000,
+        headers: authHeaders(options.authToken ?? resolveLocalServiceAuthToken()),
     }));
 }
-export async function listLocalJobRuns(options) {
-    return LocalJobRunListResponseSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.jobs}`, {
-        method: "GET",
-        timeoutMs: options.timeoutMs ?? 2000,
-    }));
-}
-export async function readLocalServiceRunSnapshot(options) {
-    const [jobs, compileRuns, testRuns] = await Promise.all([
-        listLocalJobRuns(options),
-        listLocalCompileRuns(options),
-        listLocalTestRuns(options),
-    ]);
-    return {
-        jobs: jobs.jobs,
-        compileRuns: compileRuns.compile_runs,
-        testRuns: testRuns.test_runs,
-    };
-}
 export async function waitForLocalJobRun(options) {
     const startedAt = Date.now();
     const pollMs = options.pollMs ?? 1000;
@@ -287,6 +275,7 @@ export async function waitForLocalJobRun(options) {
         const job = await getLocalJobRun({
             serviceUrl: options.serviceUrl,
             runId: options.runId,
+            authToken: options.authToken ?? null,
         });
         options.onUpdate?.(job);
         if (isTerminalJobStatus(job.status))
@@ -306,13 +295,14 @@ function resultError(job, defaultMessage) {
     return job.error ?? defaultMessage;
 }
 export async function submitReadinessCheckDraftToLocalService(options) {
-    const connection = await findLocalService({ projectPath: options.projectPath });
+    const connection = await connectOrNull();
     if (!connection)
         return null;
     const request = ReadinessCheckDraftCreateRequestSchema.parse(options.request);
-    const initialJob = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.readinessCheckDrafts}`, {
+    const initialJob = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${preparationSubresourcePath(options.preparationId, "readinessCheckDrafts")}`, {
         method: "POST",
         body: JSON.stringify(request),
+        headers: authHeaders(connection.authToken),
     }));
     options.onSubmitted?.({
         serviceUrl: connection.serviceUrl,
@@ -321,6 +311,7 @@ export async function submitReadinessCheckDraftToLocalService(options) {
     const job = await waitForLocalJobRun({
         serviceUrl: connection.serviceUrl,
         runId: initialJob.run_id,
+        authToken: connection.authToken,
         onUpdate: options.onUpdate,
     });
     if (job.status !== "succeeded") {
@@ -347,13 +338,14 @@ export async function submitReadinessCheckDraftToLocalService(options) {
     };
 }
 export async function submitMethodAuthoringRunToLocalService(options) {
-    const connection = await findLocalService({ projectPath: options.projectPath });
+    const connection = await connectOrNull();
     if (!connection)
         return null;
     const request = MethodAuthoringCreateRequestSchema.parse(options.request);
-    const initialJob = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.methodAuthoringRuns}`, {
+    const initialJob = LocalJobRunResourceSchema.parse(await fetchJson(`${connection.serviceUrl}${preparationSubresourcePath(options.preparationId, "methodAuthoringRuns")}`, {
         method: "POST",
         body: JSON.stringify(request),
+        headers: authHeaders(connection.authToken),
     }));
     options.onSubmitted?.({
         serviceUrl: connection.serviceUrl,
@@ -362,6 +354,7 @@ export async function submitMethodAuthoringRunToLocalService(options) {
     const job = await waitForLocalJobRun({
         serviceUrl: connection.serviceUrl,
         runId: initialJob.run_id,
+        authToken: connection.authToken,
         onUpdate: options.onUpdate,
     });
     if (job.status !== "succeeded") {
@@ -387,13 +380,12 @@ export async function submitMethodAuthoringRunToLocalService(options) {
         result: parsed.data,
     };
 }
-export async function submitMethodChangeToLocalService(options) {
-    const connection = await findLocalService({ projectPath: options.projectPath });
-    if (!connection)
-        return null;
-    const request = MethodChangeCreateRequestSchema.parse(options.request);
-    return MethodChangeResultSchema.parse(await fetchJson(`${connection.serviceUrl}${LOCAL_SERVICE_ROUTES.methodChanges}`, {
-        method: "POST",
-        body: JSON.stringify(request),
+/**
+ * Fetch the engine instance health/status.
+ */
+export async function getLocalServiceHealth(options) {
+    return LocalServiceHealthSchema.parse(await fetchJson(`${options.serviceUrl}${LOCAL_SERVICE_ROUTES.health}`, {
+        method: "GET",
+        timeoutMs: options.timeoutMs ?? 2000,
     }));
 }