@interf/compiler 0.9.5 → 0.16.0

package/dist/packages/engine/compile/state.d.ts

@@ -0,0 +1,7 @@
+export type { RuntimeStatus, CompiledStage, CompiledState, CompiledHealth, ViewSection, ViewCard, CompiledViewSpec, SourceFiles, SourceSnapshot, StageInputs, } from "./lib/schema.js";
+export { statePath, healthPath, viewSpecPath, sourceFilesPath, sourceSnapshotPath, } from "./state-paths.js";
+export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompiledViewSpec, loadCompiledSourceFiles, loadCompiledSourceSnapshot, saveCompiledViewSpec, initCompiledState, } from "./state-io.js";
+export { refreshCompiledArtifacts, } from "./state-artifacts.js";
+export { computeCompiledHealth, resolveCompiledStatus, resolveCompiledStage, } from "./state-health.js";
+export { ensureCompiledViewSpec, ensureCompiledSourceFiles, ensureCompiledSourceSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";
+export declare function initializeCompiledRuntimeState(dirPath: string): void;

package/dist/packages/{compiler → engine/compile}/state.js

@@ -1,8 +1,8 @@
-export { statePath, healthPath, viewSpecPath, rawSnapshotPath, } from "./state-paths.js";
-export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompiledViewSpec, loadCompiledRawSnapshot, saveCompiledViewSpec, initCompiledState, } from "./state-io.js";
+export { statePath, healthPath, viewSpecPath, sourceFilesPath, sourceSnapshotPath, } from "./state-paths.js";
+export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompiledViewSpec, loadCompiledSourceFiles, loadCompiledSourceSnapshot, saveCompiledViewSpec, initCompiledState, } from "./state-io.js";
 export { refreshCompiledArtifacts, } from "./state-artifacts.js";
 export { computeCompiledHealth, resolveCompiledStatus, resolveCompiledStage, } from "./state-health.js";
-export { ensureCompiledViewSpec, ensureCompiledRawSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";
+export { ensureCompiledViewSpec, ensureCompiledSourceFiles, ensureCompiledSourceSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";
 import { saveEmptyCompiledInventory, initCompiledState, saveState } from "./state-io.js";
 import { refreshCompiledArtifacts } from "./state-artifacts.js";
 export function initializeCompiledRuntimeState(dirPath) {

package/dist/packages/{compiler → engine/compile}/validate-compiled.js

@@ -1,12 +1,12 @@
 import { existsSync } from "node:fs";
 import { discoverSourceFiles } from "./discovery.js";
 import { METHOD_SCHEMA_FILE, findCompiledSchemaZone, readCompiledSchemaFile, methodSchemaExists, } from "./compiled-schema.js";
-import { resolveSourceFolderPath } from "../project-model/interf-detect.js";
+import { resolveSourceFolderPath } from "../../project/interf-detect.js";
 import { compiledInterfConfigPath, methodPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledConfig } from "./validate.js";
 import { loadState } from "./state.js";
 import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime-acceptance.js";
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../method-package/method-definitions.js";
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../../methods/package/method-definitions.js";
 import { countCompiledZoneArtifacts } from "./artifact-counts.js";
 function methodSchemaPresent(dirPath) {
     return methodSchemaExists(methodPackagePathForCompiled(dirPath));

package/dist/packages/{compiler → engine/compile}/validate.d.ts

@@ -1,4 +1,4 @@
-import { readInterfConfig } from "../project-model/interf-detect.js";
+import { readInterfConfig } from "../../project/interf-detect.js";
 export declare function readCompiledConfig(dirPath: string): {
     present: boolean;
     valid: boolean;

package/dist/packages/{compiler → engine/compile}/validate.js

@@ -3,9 +3,9 @@ import { basename, dirname, extname, join, resolve } from "node:path";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
 import { compiledKnowledgeRootPath } from "./compiled-schema.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { listFilesRecursive } from "../shared/filesystem.js";
-import { readInterfConfig } from "../project-model/interf-detect.js";
-import { parseJsonFrontmatter } from "../shared/parse.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
+import { readInterfConfig } from "../../project/interf-detect.js";
+import { parseJsonFrontmatter } from "../../contracts/utils/parse.js";
 import { compiledInterfConfigPath } from "./compiled-paths.js";
 const MIN_ABSTRACT_WORDS = 5;
 const WIKILINK_PATTERN = /!?\[\[([^[\]]+)\]\]/g;

package/dist/packages/engine/connection-config.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Single CLI connection record at `~/.interf/connection.json`.
+ *
+ * The CLI is a thin authorized client of one connected instance. Switch by
+ * starting `interf web` (writes a local connection), `interf login` (writes a
+ * remote connection), or by passing `--url` / env vars to override per-call.
+ *
+ * No per-folder pointer files. No registry of multiple connections.
+ */
+import { z } from "zod";
+export declare const ConnectionRecordSchema: z.ZodObject<{
+    url: z.ZodString;
+    auth_token: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type ConnectionRecord = z.infer<typeof ConnectionRecordSchema>;
+export declare const INTERF_SERVICE_URL_ENV = "INTERF_SERVICE_URL";
+export declare const INTERF_AUTH_TOKEN_ENV = "INTERF_AUTH_TOKEN";
+/**
+ * Resolve the active connection.
+ *
+ * Order of precedence:
+ *   1. Explicit `urlOverride` argument (e.g. CLI --url flag).
+ *   2. `INTERF_SERVICE_URL` / `INTERF_AUTH_TOKEN` env vars.
+ *   3. `~/.interf/connection.json`.
+ *   4. null — caller must error with the connect-or-error hint.
+ */
+export declare function readActiveConnection(options?: {
+    urlOverride?: string | null;
+    authTokenOverride?: string | null;
+}): ConnectionRecord | null;
+/** Write a new connection record. Overwrites any existing record. */
+export declare function writeConnection(record: ConnectionRecord): void;
+/** Clear the connection record. No-op if missing. */
+export declare function clearConnection(): void;
+/** Ensure `~/.interf/` exists and is a directory. */
+export declare function ensureInterfHome(): void;
+/** Canonical message printed when a CLI command needs a connection but has none. */
+export declare const CONNECT_OR_ERROR_HINT: string;

package/dist/packages/engine/connection-config.js

@@ -0,0 +1,75 @@
+/**
+ * Single CLI connection record at `~/.interf/connection.json`.
+ *
+ * The CLI is a thin authorized client of one connected instance. Switch by
+ * starting `interf web` (writes a local connection), `interf login` (writes a
+ * remote connection), or by passing `--url` / env vars to override per-call.
+ *
+ * No per-folder pointer files. No registry of multiple connections.
+ */
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { z } from "zod";
+import { connectionConfigPath, interfHomeRoot } from "./instance-paths.js";
+export const ConnectionRecordSchema = z.object({
+    url: z.string().url(),
+    /** Bearer token for non-loopback connections. Null for loopback. */
+    auth_token: z.string().min(1).nullable().default(null),
+}).strict();
+export const INTERF_SERVICE_URL_ENV = "INTERF_SERVICE_URL";
+export const INTERF_AUTH_TOKEN_ENV = "INTERF_AUTH_TOKEN";
+/**
+ * Resolve the active connection.
+ *
+ * Order of precedence:
+ *   1. Explicit `urlOverride` argument (e.g. CLI --url flag).
+ *   2. `INTERF_SERVICE_URL` / `INTERF_AUTH_TOKEN` env vars.
+ *   3. `~/.interf/connection.json`.
+ *   4. null — caller must error with the connect-or-error hint.
+ */
+export function readActiveConnection(options = {}) {
+    const overrideUrl = options.urlOverride?.trim();
+    if (overrideUrl) {
+        return ConnectionRecordSchema.parse({
+            url: overrideUrl,
+            auth_token: options.authTokenOverride?.trim() || null,
+        });
+    }
+    const envUrl = process.env[INTERF_SERVICE_URL_ENV]?.trim();
+    if (envUrl) {
+        return ConnectionRecordSchema.parse({
+            url: envUrl,
+            auth_token: process.env[INTERF_AUTH_TOKEN_ENV]?.trim() || null,
+        });
+    }
+    const configPath = connectionConfigPath();
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const raw = readFileSync(configPath, "utf8");
+        return ConnectionRecordSchema.parse(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+/** Write a new connection record. Overwrites any existing record. */
+export function writeConnection(record) {
+    const validated = ConnectionRecordSchema.parse(record);
+    const configPath = connectionConfigPath();
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, `${JSON.stringify(validated, null, 2)}\n`);
+}
+/** Clear the connection record. No-op if missing. */
+export function clearConnection() {
+    const configPath = connectionConfigPath();
+    if (existsSync(configPath))
+        rmSync(configPath, { force: true });
+}
+/** Ensure `~/.interf/` exists and is a directory. */
+export function ensureInterfHome() {
+    mkdirSync(interfHomeRoot(), { recursive: true });
+}
+/** Canonical message printed when a CLI command needs a connection but has none. */
+export const CONNECT_OR_ERROR_HINT = "Not connected to any Interf instance.\n" +
+    "Start one with `interf web`, or set --url / `interf login` for a remote one.";

package/dist/packages/{execution → engine/execution}/lib/schema.d.ts

@@ -155,14 +155,14 @@ export declare const ObservableRunTypeSchema: z.ZodEnum<{
     compile: "compile";
     "method-authoring": "method-authoring";
     "method-improvement": "method-improvement";
-    test: "test";
+    verify: "verify";
     "readiness-check-draft": "readiness-check-draft";
     job: "job";
 }>;
 export declare const ObservableRunStatusSchema: z.ZodEnum<{
+    succeeded: "succeeded";
     failed: "failed";
     running: "running";
-    succeeded: "succeeded";
     cancelled: "cancelled";
     queued: "queued";
 }>;
@@ -176,33 +176,33 @@ export declare const ExecutionBackendKindSchema: z.ZodEnum<{
     "workflow-sdk": "workflow-sdk";
 }>;
 export declare const CompileRunStatusSchema: z.ZodEnum<{
+    succeeded: "succeeded";
     failed: "failed";
     running: "running";
-    succeeded: "succeeded";
     cancelled: "cancelled";
     queued: "queued";
 }>;
 export declare const StageRunStatusSchema: z.ZodEnum<{
+    succeeded: "succeeded";
     failed: "failed";
     running: "running";
-    succeeded: "succeeded";
     queued: "queued";
 }>;
 export declare const ArtifactRoleSchema: z.ZodEnum<{
-    output: "output";
     runtime: "runtime";
+    output: "output";
     source: "source";
-    test: "test";
     proof: "proof";
+    test: "test";
 }>;
 export declare const ArtifactRefSchema: z.ZodObject<{
     path: z.ZodString;
     role: z.ZodEnum<{
-        output: "output";
         runtime: "runtime";
+        output: "output";
         source: "source";
-        test: "test";
         proof: "proof";
+        test: "test";
     }>;
     stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     label: z.ZodOptional<z.ZodString>;
@@ -222,15 +222,15 @@ export declare const RunObservabilitySchema: z.ZodObject<{
         compile: "compile";
         "method-authoring": "method-authoring";
         "method-improvement": "method-improvement";
-        test: "test";
+        verify: "verify";
         "readiness-check-draft": "readiness-check-draft";
         job: "job";
     }>;
     title: z.ZodString;
     status: z.ZodEnum<{
+        succeeded: "succeeded";
         failed: "failed";
         running: "running";
-        succeeded: "succeeded";
         cancelled: "cancelled";
         queued: "queued";
     }>;
@@ -264,11 +264,11 @@ export declare const RunObservabilitySchema: z.ZodObject<{
     artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         role: z.ZodEnum<{
-            output: "output";
             runtime: "runtime";
+            output: "output";
             source: "source";
-            test: "test";
             proof: "proof";
+            test: "test";
         }>;
         stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         label: z.ZodOptional<z.ZodString>;
@@ -303,12 +303,10 @@ export declare const RunObservabilitySchema: z.ZodObject<{
         latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         compile: z.ZodNullable<z.ZodObject<{
             gate: z.ZodEnum<{
-                "preparation-config": "preparation-config";
                 "portable-context": "portable-context";
+                "preparation-config": "preparation-config";
                 "compile-run": "compile-run";
                 "readiness-checks": "readiness-checks";
-                "source-baseline": "source-baseline";
-                "portable-context-check": "portable-context-check";
                 "checks-current": "checks-current";
             }>;
             ok: z.ZodBoolean;
@@ -352,12 +350,10 @@ export declare const RunObservabilitySchema: z.ZodObject<{
         }, z.core.$strict>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             gate: z.ZodEnum<{
-                "preparation-config": "preparation-config";
                 "portable-context": "portable-context";
+                "preparation-config": "preparation-config";
                 "compile-run": "compile-run";
                 "readiness-checks": "readiness-checks";
-                "source-baseline": "source-baseline";
-                "portable-context-check": "portable-context-check";
                 "checks-current": "checks-current";
             }>;
             ok: z.ZodBoolean;
@@ -451,11 +447,11 @@ export declare const ProofRecordSchema: z.ZodObject<{
     artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         role: z.ZodEnum<{
-            output: "output";
             runtime: "runtime";
+            output: "output";
             source: "source";
-            test: "test";
             proof: "proof";
+            test: "test";
         }>;
         stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         label: z.ZodOptional<z.ZodString>;
@@ -521,11 +517,11 @@ export declare const ArtifactWrittenEventSchema: z.ZodObject<{
     artifact: z.ZodObject<{
         path: z.ZodString;
         role: z.ZodEnum<{
-            output: "output";
             runtime: "runtime";
+            output: "output";
             source: "source";
-            test: "test";
             proof: "proof";
+            test: "test";
         }>;
         stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         label: z.ZodOptional<z.ZodString>;
@@ -548,11 +544,11 @@ export declare const ProofUpdatedEventSchema: z.ZodObject<{
         artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             role: z.ZodEnum<{
-                output: "output";
                 runtime: "runtime";
+                output: "output";
                 source: "source";
-                test: "test";
                 proof: "proof";
+                test: "test";
             }>;
             stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             label: z.ZodOptional<z.ZodString>;
@@ -617,8 +613,8 @@ export declare const ChecksEvaluatedEventSchema: z.ZodObject<{
     passed: z.ZodNumber;
     total: z.ZodNumber;
     target: z.ZodOptional<z.ZodEnum<{
+        "source-files": "source-files";
         compiled: "compiled";
-        raw: "raw";
     }>>;
     checks_fingerprint: z.ZodOptional<z.ZodString>;
     stale: z.ZodOptional<z.ZodBoolean>;
@@ -653,12 +649,10 @@ export declare const ReadinessUpdatedEventSchema: z.ZodObject<{
         latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         compile: z.ZodNullable<z.ZodObject<{
             gate: z.ZodEnum<{
-                "preparation-config": "preparation-config";
                 "portable-context": "portable-context";
+                "preparation-config": "preparation-config";
                 "compile-run": "compile-run";
                 "readiness-checks": "readiness-checks";
-                "source-baseline": "source-baseline";
-                "portable-context-check": "portable-context-check";
                 "checks-current": "checks-current";
             }>;
             ok: z.ZodBoolean;
@@ -702,12 +696,10 @@ export declare const ReadinessUpdatedEventSchema: z.ZodObject<{
         }, z.core.$strict>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             gate: z.ZodEnum<{
-                "preparation-config": "preparation-config";
                 "portable-context": "portable-context";
+                "preparation-config": "preparation-config";
                 "compile-run": "compile-run";
                 "readiness-checks": "readiness-checks";
-                "source-baseline": "source-baseline";
-                "portable-context-check": "portable-context-check";
                 "checks-current": "checks-current";
             }>;
             ok: z.ZodBoolean;
@@ -765,11 +757,11 @@ export declare const InterfRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     artifact: z.ZodObject<{
         path: z.ZodString;
         role: z.ZodEnum<{
-            output: "output";
             runtime: "runtime";
+            output: "output";
             source: "source";
-            test: "test";
             proof: "proof";
+            test: "test";
         }>;
         stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         label: z.ZodOptional<z.ZodString>;
@@ -791,11 +783,11 @@ export declare const InterfRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             role: z.ZodEnum<{
-                output: "output";
                 runtime: "runtime";
+                output: "output";
                 source: "source";
-                test: "test";
                 proof: "proof";
+                test: "test";
             }>;
             stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             label: z.ZodOptional<z.ZodString>;
@@ -854,8 +846,8 @@ export declare const InterfRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     passed: z.ZodNumber;
     total: z.ZodNumber;
     target: z.ZodOptional<z.ZodEnum<{
+        "source-files": "source-files";
         compiled: "compiled";
-        raw: "raw";
     }>>;
     checks_fingerprint: z.ZodOptional<z.ZodString>;
     stale: z.ZodOptional<z.ZodBoolean>;
@@ -889,12 +881,10 @@ export declare const InterfRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         compile: z.ZodNullable<z.ZodObject<{
             gate: z.ZodEnum<{
-                "preparation-config": "preparation-config";
                 "portable-context": "portable-context";
+                "preparation-config": "preparation-config";
                 "compile-run": "compile-run";
                 "readiness-checks": "readiness-checks";
-                "source-baseline": "source-baseline";
-                "portable-context-check": "portable-context-check";
                 "checks-current": "checks-current";
             }>;
             ok: z.ZodBoolean;
@@ -938,12 +928,10 @@ export declare const InterfRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         }, z.core.$strict>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             gate: z.ZodEnum<{
-                "preparation-config": "preparation-config";
                 "portable-context": "portable-context";
+                "preparation-config": "preparation-config";
                 "compile-run": "compile-run";
                 "readiness-checks": "readiness-checks";
-                "source-baseline": "source-baseline";
-                "portable-context-check": "portable-context-check";
                 "checks-current": "checks-current";
             }>;
             ok: z.ZodBoolean;
@@ -972,9 +960,9 @@ export declare const StageRunSchema: z.ZodObject<{
     stage_index: z.ZodOptional<z.ZodNumber>;
     stage_total: z.ZodOptional<z.ZodNumber>;
     status: z.ZodEnum<{
+        succeeded: "succeeded";
         failed: "failed";
         running: "running";
-        succeeded: "succeeded";
         queued: "queued";
     }>;
     started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -1005,11 +993,11 @@ export declare const StageRunSchema: z.ZodObject<{
     artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         role: z.ZodEnum<{
-            output: "output";
             runtime: "runtime";
+            output: "output";
             source: "source";
-            test: "test";
             proof: "proof";
+            test: "test";
         }>;
         stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         label: z.ZodOptional<z.ZodString>;
@@ -1031,11 +1019,11 @@ export declare const StageRunSchema: z.ZodObject<{
         artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             role: z.ZodEnum<{
-                output: "output";
                 runtime: "runtime";
+                output: "output";
                 source: "source";
-                test: "test";
                 proof: "proof";
+                test: "test";
             }>;
             stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             label: z.ZodOptional<z.ZodString>;
@@ -1055,9 +1043,9 @@ export declare const CompileRunSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     run_id: z.ZodString;
     status: z.ZodEnum<{
+        succeeded: "succeeded";
         failed: "failed";
         running: "running";
-        succeeded: "succeeded";
         cancelled: "cancelled";
         queued: "queued";
     }>;
@@ -1079,9 +1067,9 @@ export declare const CompileRunSchema: z.ZodObject<{
         stage_index: z.ZodOptional<z.ZodNumber>;
         stage_total: z.ZodOptional<z.ZodNumber>;
         status: z.ZodEnum<{
+            succeeded: "succeeded";
             failed: "failed";
             running: "running";
-            succeeded: "succeeded";
             queued: "queued";
         }>;
         started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -1112,11 +1100,11 @@ export declare const CompileRunSchema: z.ZodObject<{
         artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             role: z.ZodEnum<{
-                output: "output";
                 runtime: "runtime";
+                output: "output";
                 source: "source";
-                test: "test";
                 proof: "proof";
+                test: "test";
             }>;
             stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             label: z.ZodOptional<z.ZodString>;
@@ -1138,11 +1126,11 @@ export declare const CompileRunSchema: z.ZodObject<{
             artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 path: z.ZodString;
                 role: z.ZodEnum<{
-                    output: "output";
                     runtime: "runtime";
+                    output: "output";
                     source: "source";
-                    test: "test";
                     proof: "proof";
+                    test: "test";
                 }>;
                 stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 label: z.ZodOptional<z.ZodString>;
@@ -1193,11 +1181,11 @@ export declare const CompileRunSchema: z.ZodObject<{
         artifact: z.ZodObject<{
             path: z.ZodString;
             role: z.ZodEnum<{
-                output: "output";
                 runtime: "runtime";
+                output: "output";
                 source: "source";
-                test: "test";
                 proof: "proof";
+                test: "test";
             }>;
             stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             label: z.ZodOptional<z.ZodString>;
@@ -1219,11 +1207,11 @@ export declare const CompileRunSchema: z.ZodObject<{
             artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 path: z.ZodString;
                 role: z.ZodEnum<{
-                    output: "output";
                     runtime: "runtime";
+                    output: "output";
                     source: "source";
-                    test: "test";
                     proof: "proof";
+                    test: "test";
                 }>;
                 stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 label: z.ZodOptional<z.ZodString>;
@@ -1282,8 +1270,8 @@ export declare const CompileRunSchema: z.ZodObject<{
         passed: z.ZodNumber;
         total: z.ZodNumber;
         target: z.ZodOptional<z.ZodEnum<{
+            "source-files": "source-files";
             compiled: "compiled";
-            raw: "raw";
         }>>;
         checks_fingerprint: z.ZodOptional<z.ZodString>;
         stale: z.ZodOptional<z.ZodBoolean>;
@@ -1317,12 +1305,10 @@ export declare const CompileRunSchema: z.ZodObject<{
             latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             compile: z.ZodNullable<z.ZodObject<{
                 gate: z.ZodEnum<{
-                    "preparation-config": "preparation-config";
                     "portable-context": "portable-context";
+                    "preparation-config": "preparation-config";
                     "compile-run": "compile-run";
                     "readiness-checks": "readiness-checks";
-                    "source-baseline": "source-baseline";
-                    "portable-context-check": "portable-context-check";
                     "checks-current": "checks-current";
                 }>;
                 ok: z.ZodBoolean;
@@ -1366,12 +1352,10 @@ export declare const CompileRunSchema: z.ZodObject<{
             }, z.core.$strict>;
             checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 gate: z.ZodEnum<{
-                    "preparation-config": "preparation-config";
                     "portable-context": "portable-context";
+                    "preparation-config": "preparation-config";
                     "compile-run": "compile-run";
                     "readiness-checks": "readiness-checks";
-                    "source-baseline": "source-baseline";
-                    "portable-context-check": "portable-context-check";
                     "checks-current": "checks-current";
                 }>;
                 ok: z.ZodBoolean;
@@ -1403,11 +1387,11 @@ export declare const CompileRunSchema: z.ZodObject<{
         artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             role: z.ZodEnum<{
-                output: "output";
                 runtime: "runtime";
+                output: "output";
                 source: "source";
-                test: "test";
                 proof: "proof";
+                test: "test";
             }>;
             stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             label: z.ZodOptional<z.ZodString>;
@@ -1443,12 +1427,10 @@ export declare const CompileRunSchema: z.ZodObject<{
         latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         compile: z.ZodNullable<z.ZodObject<{
             gate: z.ZodEnum<{
-                "preparation-config": "preparation-config";
                 "portable-context": "portable-context";
+                "preparation-config": "preparation-config";
                 "compile-run": "compile-run";
                 "readiness-checks": "readiness-checks";
-                "source-baseline": "source-baseline";
-                "portable-context-check": "portable-context-check";
                 "checks-current": "checks-current";
             }>;
             ok: z.ZodBoolean;
@@ -1492,12 +1474,10 @@ export declare const CompileRunSchema: z.ZodObject<{
         }, z.core.$strict>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             gate: z.ZodEnum<{
-                "preparation-config": "preparation-config";
                 "portable-context": "portable-context";
+                "preparation-config": "preparation-config";
                 "compile-run": "compile-run";
                 "readiness-checks": "readiness-checks";
-                "source-baseline": "source-baseline";
-                "portable-context-check": "portable-context-check";
                 "checks-current": "checks-current";
             }>;
             ok: z.ZodBoolean;

package/dist/packages/{execution → engine/execution}/lib/schema.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { RuntimeExecutorInfoSchema, RuntimeStageSchema, MethodIdSchema, ReadinessStateSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
+import { RuntimeExecutorInfoSchema, RuntimeStageSchema, MethodIdSchema, ReadinessStateSchema, PreparationNameSchema, } from "../../../contracts/lib/schema.js";
 const RunIdSchema = z.string().min(1);
 const JsonObjectSchema = z.record(z.string(), z.unknown());
 export const MethodTraceRunStatusSchema = z.enum([
@@ -72,7 +72,7 @@ export const MethodTraceSchema = z.object({
 }).strict();
 export const ObservableRunTypeSchema = z.enum([
     "compile",
-    "test",
+    "verify",
     "readiness-check-draft",
     "method-authoring",
     "method-improvement",
@@ -234,7 +234,7 @@ export const ChecksEvaluatedEventSchema = RunEventBaseSchema.extend({
     type: z.literal("checks.evaluated"),
     passed: z.number().int().min(0),
     total: z.number().int().min(0),
-    target: z.enum(["raw", "compiled"]).optional(),
+    target: z.enum(["source-files", "compiled"]).optional(),
     checks_fingerprint: z.string().min(1).optional(),
     stale: z.boolean().optional(),
     test_run_id: z.string().min(1).optional(),