@interf/compiler 0.9.5 → 0.13.0

package/dist/packages/local-service/lib/schema.js

@@ -4,12 +4,122 @@ import { SourcePreparationConfigSchema, SourceReadinessCheckSchema, } from "../.
 import { PreparationNameSchema, ReadinessStateSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, MethodIdSchema, } from "../../contracts/lib/schema.js";
 import { ReadinessCheckRunSchema, TestRunModeSchema, } from "../../testing/lib/schema.js";
 const JsonObjectSchema = z.record(z.string(), z.unknown());
-export const LocalServiceHostSchema = z.string().min(1);
+// ───────────────────────────────────────────────────────────────────────────
+// 0.13 — preparation-first additions
+// ───────────────────────────────────────────────────────────────────────────
+/** Source binding shape on the API (only `local-folder` ships in 0.13). */
+export const SourceBindingSchema = z.object({
+    kind: z.enum(["local-folder"]),
+    locator: z.string().min(1),
+}).strict();
+/** Discriminated locator for an artifact returned by the API. */
+export const ArtifactLocatorSchema = z.object({
+    kind: z.enum(["local-path", "remote-url"]),
+    value: z.string().min(1),
+}).strict();
+/** Per-instance metadata from `GET /v1/instance` (replaces /v1/status). */
+export const InstanceResourceSchema = z.object({
+    kind: z.literal("interf-instance"),
+    version: z.literal(1),
+    url: z.string().min(1),
+    host: z.string().min(1),
+    port: z.number().int().min(1).max(65535),
+    started_at: z.string().min(1),
+    package_version: z.string().min(1).optional(),
+    preparation_count: z.number().int().min(0),
+    active_run_count: z.number().int().min(0),
+    idle_for_seconds: z.number().int().min(0),
+    auth_required: z.boolean(),
+}).strict();
+/** Body of `POST /v1/preparations` — the 0.13 preparation create request. */
+export const PreparationCreateRequestSchema = z.object({
+    id: PreparationNameSchema,
+    source: SourceBindingSchema,
+    method_id: MethodIdSchema,
+    about: z.string().min(1).optional(),
+    checks: z.array(SourceReadinessCheckSchema).default([]),
+    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
+    max_loops: SourceCompiledMaxLoopsSchema.optional(),
+}).strict();
+/** Body of `POST /v1/methods` — install a Method package by path. */
+export const MethodInstallRequestSchema = z.object({
+    source_path: z.string().min(1),
+    overwrite: z.boolean().default(false),
+}).strict();
+export const MethodInstallResultSchema = z.object({
+    method_id: MethodIdSchema,
+    installed: z.boolean(),
+    path: z.string().min(1),
+}).strict();
+export const PreparationDeleteResponseSchema = z.object({
+    deleted: z.boolean(),
+    id: PreparationNameSchema,
+}).strict();
+/**
+ * The local service must only ever bind to a loopback interface. Any other
+ * host (LAN IP, 0.0.0.0, public address) lets a remote browser tab POST at
+ * the service, which is the CSRF model we are explicitly rejecting. Keep
+ * the allowlist literal — refactoring to a `.refine()` over `z.string()`
+ * would lose the static type narrowing.
+ */
+export const LOCAL_SERVICE_LOOPBACK_HOSTS = ["127.0.0.1", "localhost", "::1"];
+export const LocalServiceHostSchema = z
+    .string()
+    .min(1)
+    .refine((value) => LOCAL_SERVICE_LOOPBACK_HOSTS.includes(value), {
+    message: `Local service host must be one of: ${LOCAL_SERVICE_LOOPBACK_HOSTS.join(", ")}.`,
+});
 export const LocalServicePortSchema = z.number().int().min(1).max(65535);
+/**
+ * Per-instance bearer token. Generated at startup with crypto.randomBytes(32)
+ * and rendered as a 64-char hex string. Any deviation should fail validation
+ * loud and early.
+ */
+export const LocalServiceAuthTokenSchema = z
+    .string()
+    .regex(/^[0-9a-f]{64}$/i, "Auth token must be a 64-character hex string.");
 export const LocalServiceConfigSchema = z.object({
     host: LocalServiceHostSchema.default("127.0.0.1"),
     port: LocalServicePortSchema.default(4873),
 }).strict();
+export const ServiceRegistryWorkspaceSchema = z.object({
+    control_path: z.string().min(1),
+    registered_at: z.string().min(1),
+    last_activity: z.string().min(1),
+}).strict();
+export const ServiceRegistryEntrySchema = z.object({
+    pid: z.number().int().positive(),
+    host: LocalServiceHostSchema,
+    port: LocalServicePortSchema,
+    url: z.string().min(1),
+    started_at: z.string().min(1),
+    /**
+     * Bearer token mutating clients must send. Optional in the schema so
+     * older registry files (pre-0.12.1) keep parsing; the runtime treats a
+     * missing token as "open" only when the entry already exists on disk —
+     * fresh entries always have one.
+     */
+    auth_token: LocalServiceAuthTokenSchema.optional(),
+    workspaces: z.array(ServiceRegistryWorkspaceSchema).default([]),
+}).strict();
+export const ServiceRegistrySchema = z.object({
+    services: z.array(ServiceRegistryEntrySchema).default([]),
+}).strict();
+export const WorkspaceRegistrationRequestSchema = z.object({
+    control_path: z.string().min(1),
+}).strict();
+export const WorkspaceRegistrationResponseSchema = z.object({
+    workspace: ServiceRegistryWorkspaceSchema,
+    service: ServiceRegistryEntrySchema,
+}).strict();
+export const WorkspaceListResponseSchema = z.object({
+    workspaces: z.array(ServiceRegistryWorkspaceSchema),
+}).strict();
+export const WorkspaceDeregisterResponseSchema = z.object({
+    deregistered: z.boolean(),
+    control_path: z.string().min(1),
+    remaining_workspaces: z.number().int().min(0),
+}).strict();
 export const LocalServiceHealthSchema = z.object({
     kind: z.literal("interf-local-service-health"),
     version: z.literal(1),
@@ -21,6 +131,10 @@ export const LocalServiceHealthSchema = z.object({
     source_folder_path: z.string().min(1).nullable().optional(),
     started_at: z.string().min(1).optional(),
     package_version: z.string().min(1).optional(),
+    instance_started_at: z.string().min(1).optional(),
+    registered_workspaces: z.array(ServiceRegistryWorkspaceSchema).default([]),
+    active_runs: z.number().int().min(0).default(0),
+    idle_for_seconds: z.number().int().min(0).default(0),
 }).strict();
 export const LocalServiceErrorSchema = z.object({
     error: z.object({
@@ -35,8 +149,12 @@ export const LocalServicePointerSchema = z.object({
     pid: z.number().int().positive(),
     control_path: z.string().min(1),
     started_at: z.string().min(1),
+    /**
+     * Per-workspace copy of the bearer token. Optional so legacy pointer
+     * files keep parsing during upgrades; new pointers always include it.
+     */
+    auth_token: LocalServiceAuthTokenSchema.optional(),
 }).strict();
-export const PreparationReadinessStateSchema = ReadinessStateSchema;
 export const PortableContextMappingSchema = z.object({
     preparation: PreparationNameSchema,
     path: z.string().min(1).nullable(),
@@ -58,7 +176,7 @@ export const PreparationResourceSchema = z.object({
     checks: z.array(SourceReadinessCheckSchema).default([]),
     portable_context: PortableContextMappingSchema,
     portable_context_path: z.string().min(1).nullable(),
-    readiness: PreparationReadinessStateSchema,
+    readiness: ReadinessStateSchema,
     runs: PreparationRunLinkageSchema,
     latest_compile_run_id: z.string().min(1).nullable().optional(),
     latest_test_run_id: z.string().min(1).nullable().optional(),
@@ -110,13 +228,14 @@ export const LocalJobTypeSchema = z.enum([
     "method-authoring",
     "method-improvement",
 ]);
-export const LocalJobStatusSchema = z.enum([
+export const RunStatusSchema = z.enum([
     "queued",
     "running",
     "succeeded",
     "failed",
     "cancelled",
 ]);
+export const LocalJobStatusSchema = RunStatusSchema;
 export const LocalRunHandlerResultSchema = z.object({
     ok: z.boolean(),
     error: z.string().min(1).optional(),
@@ -194,6 +313,24 @@ export const PreparationSetupResultSchema = z.object({
     submitted_run_id: z.string().min(1).nullable().optional(),
     submitted_run_type: z.literal("compile-run").nullable().optional(),
 }).strict();
+export const WorkspaceBootstrapCreateRequestSchema = z.object({
+    source_folder: z.object({
+        path: z.string().min(1),
+    }).strict().optional(),
+    seed_default_method: z.boolean().default(true),
+}).strict();
+export const WorkspaceBootstrapResultSchema = z.object({
+    kind: z.literal("interf-workspace-bootstrap-result"),
+    version: z.literal(1),
+    control_path: z.string().min(1),
+    config_path: z.string().min(1),
+    source_folder_path: z.string().min(1).nullable(),
+    preparations: z.number().int().min(0),
+    seeded_default_method: z.boolean(),
+    default_method_id: MethodIdSchema.nullable(),
+    changed: z.boolean(),
+    message: z.string().min(1),
+}).strict();
 export const MethodChangeCreateRequestSchema = z.discriminatedUnion("operation", [
     z.object({
         action_type: z.literal("method-change").optional(),
@@ -309,13 +446,7 @@ export const LocalJobRunResourceSchema = z.object({
     result: z.record(z.string(), z.unknown()).nullable().optional(),
     error: z.string().min(1).nullable().optional(),
 }).strict();
-export const TestRunStatusSchema = z.enum([
-    "queued",
-    "running",
-    "succeeded",
-    "failed",
-    "cancelled",
-]);
+export const TestRunStatusSchema = RunStatusSchema;
 export const TestRunCreateRequestSchema = z.object({
     preparation: PreparationNameSchema,
     mode: TestRunModeSchema.default("both"),
@@ -464,7 +595,7 @@ export const PortableContextResourceSchema = z.object({
     latest_test_run_id: z.string().min(1).nullable().optional(),
     artifacts: z.array(ArtifactRefSchema).default([]),
 }).strict();
-export const ReadinessResourceSchema = PreparationReadinessStateSchema;
+export const ReadinessResourceSchema = ReadinessStateSchema;
 export const SourceFileResourceSchema = z.object({
     preparation: PreparationNameSchema,
     path: z.string().min(1),
@@ -494,6 +625,7 @@ export const LocalServiceDiscoverySchema = z.object({
         preparation_setups: z.string().min(1),
         preparation_changes: z.string().min(1),
         method_changes: z.string().min(1),
+        workspace_bootstraps: z.string().min(1).optional(),
         readiness_check_drafts: z.string().min(1),
         method_authoring_runs: z.string().min(1),
         method_improvement_runs: z.string().min(1),
@@ -501,6 +633,8 @@ export const LocalServiceDiscoverySchema = z.object({
         test_runs: z.string().min(1),
         reset: z.string().min(1),
         executor: z.string().min(1),
+        workspaces: z.string().min(1).optional(),
+        status: z.string().min(1).optional(),
     }).strict(),
 }).strict();
 export const OpenPathRequestSchema = z.object({
@@ -510,56 +644,6 @@ export const OpenPathResponseSchema = z.object({
     opened: z.boolean(),
     path: z.string().min(1),
 }).strict();
-export const LocalServiceResourceSchema = z.discriminatedUnion("kind", [
-    z.object({
-        kind: z.literal("preparation"),
-        value: PreparationResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("method"),
-        value: MethodResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("compile-run"),
-        value: CompileRunResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("job-run"),
-        value: LocalJobRunResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("test-run"),
-        value: TestRunResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("run-observability"),
-        value: RunObservabilityResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("executor-status"),
-        value: LocalExecutorStatusSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("action-proposal"),
-        value: ActionProposalResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("portable-context"),
-        value: PortableContextResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("readiness"),
-        value: ReadinessResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("source-file"),
-        value: SourceFileResourceSchema,
-    }).strict(),
-    z.object({
-        kind: z.literal("workspace-file"),
-        value: WorkspaceFileResourceSchema,
-    }).strict(),
-]);
 export const PreparationListResponseSchema = z.object({
     preparations: z.array(PreparationResourceSchema),
 }).strict();

package/dist/packages/local-service/native-run-handlers.js

@@ -84,7 +84,7 @@ function printSavedReadinessOutcome(prefix, outcome) {
 function bestVariationRestorePaths(compiledPath) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     const zonePaths = (schema?.zones ?? [])
-        .filter((zone) => zone.id !== "raw" && zone.kind !== "runtime")
+        .filter((zone) => zone.kind !== "runtime")
         .map((zone) => zone.path);
     return [
         "AGENTS.md",
@@ -551,7 +551,7 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 mode: request.mode,
                 executor,
             });
-            const missingSourceFiles = (request.mode === "raw" || request.mode === "both") && !result.rawOutcome;
+            const missingSourceFiles = (request.mode === "source-files" || request.mode === "both") && !result.sourceFilesOutcome;
             const missingPortableContext = (request.mode === "compiled" || request.mode === "both") && !result.compiledOutcome;
             if (missingSourceFiles || missingPortableContext) {
                 return {
@@ -601,7 +601,7 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 message: `Using ${executor.displayName} for Method authoring.`,
             });
             const result = await runMethodAuthoringDraft({
-                sourcePath: context.sourcePath,
+                prepDataDir: context.sourcePath,
                 sourceFolderPath: request.source_folder_path,
                 baseMethodId: request.reference_method_id ?? request.base_method_id,
                 methodId: request.method_id,

package/dist/packages/local-service/preparation-store.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 0.13 preparation store.
+ *
+ * Each preparation lives at `~/.interf/preparations/<id>/` and is also
+ * registered with the runtime as a synthetic workspace so the existing
+ * compile / test / readiness machinery (preparation-keyed under the hood)
+ * keeps working without a parallel implementation.
+ *
+ *   ~/.interf/preparations/<id>/
+ *     interf.json          ← preparation config, single preparation entry name=<id>
+ *     <id>/                ← portable context (matches preparation name)
+ *
+ * NOTE: We keep the synthetic `interf.json` shape (with a `preparations[]`
+ * array of length 1, name=id, path=id) so the existing compile/test
+ * machinery stays functional. The doc-shape `config.json` /
+ * `portable-context/` from `instance-paths.ts` is aspirational; transitioning
+ * the entire compile pipeline to read those names is out of scope for the
+ * 0.13 cutover.
+ *
+ * Public callers reach this through the preparation-keyed HTTP routes.
+ */
+import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
+import type { LocalServiceRuntime } from "./runtime.js";
+export interface PreparationCreateInput {
+    id: string;
+    source: {
+        kind: "local-folder";
+        locator: string;
+    };
+    method_id: string;
+    about?: string;
+    checks?: Array<{
+        question: string;
+        answer?: string;
+        strictness?: string;
+        expect?: string;
+    }>;
+    max_attempts?: number;
+    max_loops?: number;
+}
+export interface StoredPreparation {
+    id: string;
+    prepDataDir: string;
+    source: {
+        kind: "local-folder";
+        locator: string;
+    };
+    methodId: string;
+    about: string | null;
+    config: SourcePreparationConfig;
+    portableContextPath: string;
+    configPath: string;
+}
+/** List every preparation registered under `~/.interf/preparations/`. */
+export declare function listStoredPreparations(): StoredPreparation[];
+/** Read one preparation by id. Returns null when missing. */
+export declare function getStoredPreparation(prepId: string): StoredPreparation | null;
+/**
+ * Create a preparation: scaffold its data dir, write the synthetic
+ * workspace config, and register it with the runtime so subsequent
+ * compile / test / readiness calls find it.
+ *
+ * Throws on validation errors (bad id, bad method id, source missing).
+ */
+export declare function createStoredPreparation(runtime: LocalServiceRuntime, input: PreparationCreateInput): StoredPreparation;
+/**
+ * Delete a preparation: deregister its synthetic workspace and remove
+ * `~/.interf/preparations/<id>/` from disk. Returns true when something
+ * was actually removed.
+ */
+export declare function deleteStoredPreparation(runtime: LocalServiceRuntime, prepId: string): boolean;
+/**
+ * Re-register every preparation directory with the runtime on startup so
+ * synthetic workspaces survive a `interf web` restart.
+ */
+export declare function rehydratePreparations(runtime: LocalServiceRuntime): void;
+/** Build the wire shape for `GET /v1/preparations/<id>` given a stored preparation. */
+export declare function preparationWireShape(stored: StoredPreparation): {
+    id: string;
+    source: {
+        kind: string;
+        locator: string;
+    };
+    method_id: string;
+    about: string | null;
+    config_path: string;
+    portable_context: {
+        kind: "local-path";
+        value: string;
+    };
+    checks: SourcePreparationConfig["checks"];
+};

package/dist/packages/local-service/preparation-store.js

@@ -0,0 +1,171 @@
+/**
+ * 0.13 preparation store.
+ *
+ * Each preparation lives at `~/.interf/preparations/<id>/` and is also
+ * registered with the runtime as a synthetic workspace so the existing
+ * compile / test / readiness machinery (preparation-keyed under the hood)
+ * keeps working without a parallel implementation.
+ *
+ *   ~/.interf/preparations/<id>/
+ *     interf.json          ← preparation config, single preparation entry name=<id>
+ *     <id>/                ← portable context (matches preparation name)
+ *
+ * NOTE: We keep the synthetic `interf.json` shape (with a `preparations[]`
+ * array of length 1, name=id, path=id) so the existing compile/test
+ * machinery stays functional. The doc-shape `config.json` /
+ * `portable-context/` from `instance-paths.ts` is aspirational; transitioning
+ * the entire compile pipeline to read those names is out of scope for the
+ * 0.13 cutover.
+ *
+ * Public callers reach this through the preparation-keyed HTTP routes.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import { PreparationNameSchema, MethodIdSchema, } from "../contracts/lib/schema.js";
+import { preparationDataDir, preparationsRoot, } from "./instance-paths.js";
+import { saveSourceFolderConfig, loadSourceFolderConfig, } from "../project-model/source-config.js";
+function ensurePreparationsRoot() {
+    mkdirSync(preparationsRoot(), { recursive: true });
+}
+function readSourceFolderBindingFromInterfJson(prepDataDir) {
+    const filePath = join(prepDataDir, "interf.json");
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(filePath, "utf8"));
+        const sourceFolder = raw.source_folder;
+        if (!sourceFolder?.path)
+            return null;
+        return { path: sourceFolder.path, about: sourceFolder.about ?? null };
+    }
+    catch {
+        return null;
+    }
+}
+function loadStoredPreparation(prepId) {
+    const prepDataDir = preparationDataDir(prepId);
+    if (!existsSync(prepDataDir) || !statSync(prepDataDir).isDirectory())
+        return null;
+    const config = loadSourceFolderConfig(prepDataDir);
+    if (!config)
+        return null;
+    const preparation = config.preparations?.find((p) => p.name === prepId);
+    if (!preparation)
+        return null;
+    const binding = readSourceFolderBindingFromInterfJson(prepDataDir);
+    if (!binding?.path)
+        return null;
+    return {
+        id: prepId,
+        prepDataDir,
+        source: { kind: "local-folder", locator: binding.path },
+        methodId: preparation.method ?? "interf-default",
+        about: binding.about ?? null,
+        config: preparation,
+        portableContextPath: join(prepDataDir, prepId),
+        configPath: join(prepDataDir, "interf.json"),
+    };
+}
+/** List every preparation registered under `~/.interf/preparations/`. */
+export function listStoredPreparations() {
+    const root = preparationsRoot();
+    if (!existsSync(root))
+        return [];
+    const entries = readdirSync(root, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const stored = loadStoredPreparation(entry.name);
+        if (stored)
+            out.push(stored);
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+/** Read one preparation by id. Returns null when missing. */
+export function getStoredPreparation(prepId) {
+    return loadStoredPreparation(prepId);
+}
+/**
+ * Create a preparation: scaffold its data dir, write the synthetic
+ * workspace config, and register it with the runtime so subsequent
+ * compile / test / readiness calls find it.
+ *
+ * Throws on validation errors (bad id, bad method id, source missing).
+ */
+export function createStoredPreparation(runtime, input) {
+    PreparationNameSchema.parse(input.id);
+    MethodIdSchema.parse(input.method_id);
+    const sourceLocator = resolve(input.source.locator);
+    if (!existsSync(sourceLocator)) {
+        throw new Error(`Source folder does not exist: ${sourceLocator}`);
+    }
+    if (!statSync(sourceLocator).isDirectory()) {
+        throw new Error(`Source folder is not a directory: ${sourceLocator}`);
+    }
+    ensurePreparationsRoot();
+    const prepDataDir = preparationDataDir(input.id);
+    if (existsSync(prepDataDir) && loadStoredPreparation(input.id)) {
+        throw new Error(`Preparation already exists: ${input.id}`);
+    }
+    mkdirSync(prepDataDir, { recursive: true });
+    const preparation = {
+        name: input.id,
+        path: input.id,
+        method: input.method_id,
+        checks: (input.checks ?? []).map((check) => ({
+            question: check.question,
+            ...(check.answer ? { answer: check.answer } : {}),
+            ...(check.strictness ? { strictness: check.strictness } : {}),
+            ...(check.expect ? { expect: check.expect } : {}),
+        })),
+        ...(input.about ? { about: input.about } : {}),
+        ...(input.max_attempts ? { max_attempts: input.max_attempts } : {}),
+        ...(input.max_loops ? { max_loops: input.max_loops } : {}),
+    };
+    saveSourceFolderConfig(prepDataDir, {
+        source_folder: { path: sourceLocator, ...(input.about ? { about: input.about } : {}) },
+        preparations: [preparation],
+    });
+    // Hand the synthetic workspace to the runtime so the existing
+    // compile/test/readiness paths see it.
+    runtime.registerPreparation(prepDataDir);
+    const stored = loadStoredPreparation(input.id);
+    if (!stored)
+        throw new Error(`Failed to load freshly-created preparation ${input.id}`);
+    return stored;
+}
+/**
+ * Delete a preparation: deregister its synthetic workspace and remove
+ * `~/.interf/preparations/<id>/` from disk. Returns true when something
+ * was actually removed.
+ */
+export function deleteStoredPreparation(runtime, prepId) {
+    const prepDataDir = preparationDataDir(prepId);
+    if (!existsSync(prepDataDir))
+        return false;
+    runtime.deregisterPreparation(prepDataDir);
+    rmSync(prepDataDir, { recursive: true, force: true });
+    return true;
+}
+/**
+ * Re-register every preparation directory with the runtime on startup so
+ * synthetic workspaces survive a `interf web` restart.
+ */
+export function rehydratePreparations(runtime) {
+    for (const stored of listStoredPreparations()) {
+        runtime.registerPreparation(stored.prepDataDir);
+    }
+}
+/** Build the wire shape for `GET /v1/preparations/<id>` given a stored preparation. */
+export function preparationWireShape(stored) {
+    return {
+        id: stored.id,
+        source: stored.source,
+        method_id: stored.methodId,
+        about: stored.about,
+        config_path: stored.configPath,
+        portable_context: { kind: "local-path", value: stored.portableContextPath },
+        checks: stored.config.checks ?? [],
+    };
+}

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

@@ -1,32 +1,49 @@
 export declare const LOCAL_SERVICE_DEFAULT_HOST = "127.0.0.1";
 export declare const LOCAL_SERVICE_DEFAULT_PORT = 4873;
-export declare const LOCAL_SERVICE_POINTER_PATH: readonly ["interf", ".service", "local-service.json"];
 export declare const LOCAL_SERVICE_ROUTES: {
     readonly root: "/";
     readonly api: "/v1";
     readonly health: "/health";
+    readonly instance: "/v1/instance";
     readonly preparations: "/v1/preparations";
-    readonly workspaceFiles: "/v1/workspace-files";
-    readonly sourceFiles: "/v1/source-files";
     readonly methods: "/v1/methods";
-    readonly preparationSetups: "/v1/preparation-setups";
-    readonly preparationChanges: "/v1/preparation-changes";
-    readonly methodChanges: "/v1/method-changes";
-    readonly jobs: "/v1/jobs";
-    readonly readinessCheckDrafts: "/v1/readiness-check-drafts";
-    readonly methodAuthoringRuns: "/v1/method-authoring-runs";
-    readonly methodImprovementRuns: "/v1/method-improvement-runs";
     readonly runs: "/v1/runs";
-    readonly reset: "/v1/reset";
-    readonly executor: "/v1/executor";
     readonly actionProposals: "/v1/action-proposals";
-    readonly compileRuns: "/v1/compile-runs";
-    readonly testRuns: "/v1/test-runs";
-    readonly portableContexts: "/v1/portable-contexts";
-    readonly readiness: "/v1/readiness";
+    readonly executor: "/v1/executor";
     readonly openPath: "/v1/open-path";
 };
+/** Preparation-scoped sub-resources (relative to /v1/preparations/<id>/). */
+export declare const PREPARATION_SUBRESOURCES: {
+    readonly compileRuns: "compile-runs";
+    readonly testRuns: "test-runs";
+    readonly methodAuthoringRuns: "method-authoring-runs";
+    readonly methodImprovementRuns: "method-improvement-runs";
+    readonly readinessCheckDrafts: "readiness-check-drafts";
+    readonly changes: "changes";
+    readonly reset: "reset";
+    readonly runs: "runs";
+    readonly readiness: "readiness";
+    readonly sourceFiles: "source-files";
+    readonly portableContext: "portable-context";
+};
+/** Run-scoped sub-resources (relative to /v1/runs/<run-id>/). */
+export declare const RUN_SUBRESOURCES: {
+    readonly events: "events";
+    readonly cancel: "cancel";
+    readonly proof: "proof";
+    readonly artifacts: "artifacts";
+};
 export declare function buildLocalServiceUrl(options?: {
     host?: string;
     port?: number;
 }): string;
+/** Path builder: /v1/preparations/<id>. */
+export declare function preparationResourcePath(prepId: string): string;
+/** Path builder: /v1/preparations/<id>/<subresource>. */
+export declare function preparationSubresourcePath(prepId: string, sub: keyof typeof PREPARATION_SUBRESOURCES): string;
+/** Path builder: /v1/runs/<run-id>. */
+export declare function runResourcePath(runId: string): string;
+/** Path builder: /v1/runs/<run-id>/<subresource>. */
+export declare function runSubresourcePath(runId: string, sub: keyof typeof RUN_SUBRESOURCES): string;
+/** Path builder: /v1/methods/<id>. */
+export declare function methodResourcePath(methodId: string): string;