@interf/compiler 0.16.0 → 0.21.0

package/dist/packages/engine/wire-schemas.d.ts

@@ -0,0 +1,549 @@
+/**
+ * 0.17 — private wire-shape registry for the Compiler UI.
+ *
+ * The UI consumes the local-service API at `/v1/...`. Before 0.17 it
+ * cast each `getJson` response to a TypeScript type without runtime
+ * validation, which let the 0.16 prepRuns shape-mismatch bug
+ * (UI typed `{ runs: CompileRunResource[] }`, API returns
+ * `{ runs: CompileRun[] }`) ship to production. This module exposes
+ * the response schemas the UI needs so `getJson` can validate at the
+ * fetch boundary.
+ *
+ * **Stays private.** Do NOT re-export from
+ * `src/packages/engine/index.ts` and do NOT add a `package.json#exports`
+ * subpath. 0.16 just pruned three subpath exports
+ * (`./contracts`, `./execution`, `./local-service`); adding wire
+ * schemas to the public ABI would reverse that direction-of-travel.
+ * The Compiler UI builds inside the same repo and imports these
+ * schemas via relative path — no public ABI change.
+ */
+import { z } from "zod";
+import { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, MethodListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema } from "./lib/schema.js";
+export { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, MethodListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema, };
+/**
+ * `GET /v1/preparations/<id>/runs` returns a flat list of compile runs.
+ * The 0.16 bug came from typing this as `{ runs: CompileRunResource[] }`
+ * (the wrapped form `{ run: CompileRun }`) when the API returns the
+ * unwrapped form. Pinning the schema here prevents the regression.
+ */
+export declare const PreparationCompileRunListResponseSchema: z.ZodObject<{
+    runs: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"interf-compile-run">;
+        version: z.ZodLiteral<1>;
+        run_id: z.ZodString;
+        status: z.ZodEnum<{
+            succeeded: "succeeded";
+            failed: "failed";
+            running: "running";
+            cancelled: "cancelled";
+            queued: "queued";
+        }>;
+        preparation: z.ZodString;
+        method: z.ZodString;
+        backend: z.ZodEnum<{
+            native: "native";
+            "workflow-sdk": "workflow-sdk";
+        }>;
+        source_path: z.ZodString;
+        portable_context_path: z.ZodString;
+        created_at: z.ZodString;
+        started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            run_id: z.ZodString;
+            stage_id: z.ZodString;
+            stage_label: z.ZodOptional<z.ZodString>;
+            stage_index: z.ZodOptional<z.ZodNumber>;
+            stage_total: z.ZodOptional<z.ZodNumber>;
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+                running: "running";
+                queued: "queued";
+            }>;
+            started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            contract: z.ZodOptional<z.ZodObject<{
+                stage_label: z.ZodOptional<z.ZodString>;
+                stage_index: z.ZodOptional<z.ZodNumber>;
+                stage_total: z.ZodOptional<z.ZodNumber>;
+                reads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            executor: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    "local-agent": "local-agent";
+                    "connected-provider": "connected-provider";
+                    managed: "managed";
+                }>;
+                name: z.ZodString;
+                display_name: z.ZodString;
+                command: z.ZodNullable<z.ZodString>;
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                profile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                timeout_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strip>>>;
+            artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                role: z.ZodEnum<{
+                    runtime: "runtime";
+                    output: "output";
+                    source: "source";
+                    proof: "proof";
+                    test: "test";
+                }>;
+                stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                label: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            logs: z.ZodOptional<z.ZodObject<{
+                prompt_path: z.ZodOptional<z.ZodString>;
+                event_stream_path: z.ZodOptional<z.ZodString>;
+                status_path: z.ZodOptional<z.ZodString>;
+                contract_path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            latest_proof: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                run_id: z.ZodString;
+                stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                generated_at: z.ZodString;
+                summary: z.ZodString;
+                files_processed: z.ZodOptional<z.ZodNumber>;
+                artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    role: z.ZodEnum<{
+                        runtime: "runtime";
+                        output: "output";
+                        source: "source";
+                        proof: "proof";
+                        test: "test";
+                    }>;
+                    stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    label: z.ZodOptional<z.ZodString>;
+                    sha256: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    ok: z.ZodBoolean;
+                    detail: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>>;
+            failure: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>>;
+        events: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"run.started">;
+            preparation: z.ZodString;
+            method: z.ZodString;
+            portable_context_path: z.ZodString;
+            backend: z.ZodEnum<{
+                native: "native";
+                "workflow-sdk": "workflow-sdk";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"stage.started">;
+            stage_id: z.ZodString;
+            stage_index: z.ZodOptional<z.ZodNumber>;
+            stage_total: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"file.processed">;
+            stage_id: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"artifact.written">;
+            stage_id: z.ZodString;
+            artifact: z.ZodObject<{
+                path: z.ZodString;
+                role: z.ZodEnum<{
+                    runtime: "runtime";
+                    output: "output";
+                    source: "source";
+                    proof: "proof";
+                    test: "test";
+                }>;
+                stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                label: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"proof.updated">;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            proof: z.ZodObject<{
+                id: z.ZodString;
+                run_id: z.ZodString;
+                stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                generated_at: z.ZodString;
+                summary: z.ZodString;
+                files_processed: z.ZodOptional<z.ZodNumber>;
+                artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    role: z.ZodEnum<{
+                        runtime: "runtime";
+                        output: "output";
+                        source: "source";
+                        proof: "proof";
+                        test: "test";
+                    }>;
+                    stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    label: z.ZodOptional<z.ZodString>;
+                    sha256: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    ok: z.ZodBoolean;
+                    detail: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"log.appended">;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stream: z.ZodEnum<{
+                status: "status";
+                trace: "trace";
+                system: "system";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"stage.passed">;
+            stage_id: z.ZodString;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"stage.failed">;
+            stage_id: z.ZodString;
+            error: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"run.completed">;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"run.failed">;
+            error: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"run.cancelled">;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"checks.evaluated">;
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+            target: z.ZodOptional<z.ZodEnum<{
+                "source-files": "source-files";
+                compiled: "compiled";
+            }>>;
+            checks_fingerprint: z.ZodOptional<z.ZodString>;
+            stale: z.ZodOptional<z.ZodBoolean>;
+            test_run_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            event_id: z.ZodString;
+            run_id: z.ZodString;
+            timestamp: z.ZodString;
+            type: z.ZodLiteral<"readiness.updated">;
+            preparation: z.ZodString;
+            readiness: z.ZodObject<{
+                kind: z.ZodLiteral<"interf-readiness-state">;
+                version: z.ZodLiteral<1>;
+                generated_at: z.ZodString;
+                preparation: z.ZodString;
+                status: z.ZodEnum<{
+                    ready: "ready";
+                    failed: "failed";
+                    "not-configured": "not-configured";
+                    "not-built": "not-built";
+                    building: "building";
+                    built: "built";
+                    checking: "checking";
+                    "not-ready": "not-ready";
+                    stale: "stale";
+                }>;
+                ready: z.ZodBoolean;
+                summary: z.ZodString;
+                portable_context_path: z.ZodNullable<z.ZodString>;
+                latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                compile: z.ZodNullable<z.ZodObject<{
+                    gate: z.ZodEnum<{
+                        "portable-context": "portable-context";
+                        "preparation-config": "preparation-config";
+                        "compile-run": "compile-run";
+                        "artifact-checks": "artifact-checks";
+                        "readiness-checks": "readiness-checks";
+                        "checks-current": "checks-current";
+                    }>;
+                    ok: z.ZodBoolean;
+                    status: z.ZodOptional<z.ZodEnum<{
+                        ready: "ready";
+                        failed: "failed";
+                        "not-configured": "not-configured";
+                        "not-built": "not-built";
+                        building: "building";
+                        built: "built";
+                        checking: "checking";
+                        "not-ready": "not-ready";
+                        stale: "stale";
+                    }>>;
+                    summary: z.ZodString;
+                    detail: z.ZodOptional<z.ZodString>;
+                    run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>>;
+                check_results: z.ZodObject<{
+                    configured: z.ZodNumber;
+                    fingerprint: z.ZodNullable<z.ZodString>;
+                    source_files: z.ZodNullable<z.ZodObject<{
+                        passed: z.ZodNumber;
+                        total: z.ZodNumber;
+                        pass_rate: z.ZodNullable<z.ZodNumber>;
+                        checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        stale: z.ZodDefault<z.ZodBoolean>;
+                        run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strict>>;
+                    portable_context: z.ZodNullable<z.ZodObject<{
+                        passed: z.ZodNumber;
+                        total: z.ZodNumber;
+                        pass_rate: z.ZodNullable<z.ZodNumber>;
+                        checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        stale: z.ZodDefault<z.ZodBoolean>;
+                        run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    gate: z.ZodEnum<{
+                        "portable-context": "portable-context";
+                        "preparation-config": "preparation-config";
+                        "compile-run": "compile-run";
+                        "artifact-checks": "artifact-checks";
+                        "readiness-checks": "readiness-checks";
+                        "checks-current": "checks-current";
+                    }>;
+                    ok: z.ZodBoolean;
+                    status: z.ZodOptional<z.ZodEnum<{
+                        ready: "ready";
+                        failed: "failed";
+                        "not-configured": "not-configured";
+                        "not-built": "not-built";
+                        building: "building";
+                        built: "built";
+                        checking: "checking";
+                        "not-ready": "not-ready";
+                        stale: "stale";
+                    }>>;
+                    summary: z.ZodString;
+                    detail: z.ZodOptional<z.ZodString>;
+                    run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "type">>>;
+        latest_proof: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            run_id: z.ZodString;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            generated_at: z.ZodString;
+            summary: z.ZodString;
+            files_processed: z.ZodOptional<z.ZodNumber>;
+            artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                role: z.ZodEnum<{
+                    runtime: "runtime";
+                    output: "output";
+                    source: "source";
+                    proof: "proof";
+                    test: "test";
+                }>;
+                stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                label: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                ok: z.ZodBoolean;
+                detail: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        readiness: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            kind: z.ZodLiteral<"interf-readiness-state">;
+            version: z.ZodLiteral<1>;
+            generated_at: z.ZodString;
+            preparation: z.ZodString;
+            status: z.ZodEnum<{
+                ready: "ready";
+                failed: "failed";
+                "not-configured": "not-configured";
+                "not-built": "not-built";
+                building: "building";
+                built: "built";
+                checking: "checking";
+                "not-ready": "not-ready";
+                stale: "stale";
+            }>;
+            ready: z.ZodBoolean;
+            summary: z.ZodString;
+            portable_context_path: z.ZodNullable<z.ZodString>;
+            latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            compile: z.ZodNullable<z.ZodObject<{
+                gate: z.ZodEnum<{
+                    "portable-context": "portable-context";
+                    "preparation-config": "preparation-config";
+                    "compile-run": "compile-run";
+                    "artifact-checks": "artifact-checks";
+                    "readiness-checks": "readiness-checks";
+                    "checks-current": "checks-current";
+                }>;
+                ok: z.ZodBoolean;
+                status: z.ZodOptional<z.ZodEnum<{
+                    ready: "ready";
+                    failed: "failed";
+                    "not-configured": "not-configured";
+                    "not-built": "not-built";
+                    building: "building";
+                    built: "built";
+                    checking: "checking";
+                    "not-ready": "not-ready";
+                    stale: "stale";
+                }>>;
+                summary: z.ZodString;
+                detail: z.ZodOptional<z.ZodString>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            check_results: z.ZodObject<{
+                configured: z.ZodNumber;
+                fingerprint: z.ZodNullable<z.ZodString>;
+                source_files: z.ZodNullable<z.ZodObject<{
+                    passed: z.ZodNumber;
+                    total: z.ZodNumber;
+                    pass_rate: z.ZodNullable<z.ZodNumber>;
+                    checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    stale: z.ZodDefault<z.ZodBoolean>;
+                    run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>>;
+                portable_context: z.ZodNullable<z.ZodObject<{
+                    passed: z.ZodNumber;
+                    total: z.ZodNumber;
+                    pass_rate: z.ZodNullable<z.ZodNumber>;
+                    checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    stale: z.ZodDefault<z.ZodBoolean>;
+                    run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                gate: z.ZodEnum<{
+                    "portable-context": "portable-context";
+                    "preparation-config": "preparation-config";
+                    "compile-run": "compile-run";
+                    "artifact-checks": "artifact-checks";
+                    "readiness-checks": "readiness-checks";
+                    "checks-current": "checks-current";
+                }>;
+                ok: z.ZodBoolean;
+                status: z.ZodOptional<z.ZodEnum<{
+                    ready: "ready";
+                    failed: "failed";
+                    "not-configured": "not-configured";
+                    "not-built": "not-built";
+                    building: "building";
+                    built: "built";
+                    checking: "checking";
+                    "not-ready": "not-ready";
+                    stale: "stale";
+                }>>;
+                summary: z.ZodString;
+                detail: z.ZodOptional<z.ZodString>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            artifact_id: z.ZodString;
+            status: z.ZodEnum<{
+                ready: "ready";
+                not_ready: "not_ready";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+            built_by_stages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            proofs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                check_id: z.ZodString;
+                kind: z.ZodEnum<{
+                    file_exists: "file_exists";
+                    min_file_count: "min_file_count";
+                    min_file_count_matches_source: "min_file_count_matches_source";
+                    frontmatter_valid: "frontmatter_valid";
+                    frontmatter_required_keys: "frontmatter_required_keys";
+                    wikilinks_valid: "wikilinks_valid";
+                    must_not_contain: "must_not_contain";
+                    must_contain: "must_contain";
+                    qa_match: "qa_match";
+                }>;
+                passed: z.ZodBoolean;
+                required: z.ZodBoolean;
+                summary: z.ZodString;
+                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                evaluated_at: z.ZodString;
+            }, z.core.$strict>>>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PreparationCompileRunListResponse = z.infer<typeof PreparationCompileRunListResponseSchema>;
+/**
+ * Thrown when `getJson` parses a response that fails the registered
+ * schema. Surfaces the request path and the zod issue list so the UI
+ * can render an actionable error rather than a stack trace.
+ *
+ * `issues` is typed as `unknown[]` so the class works across both
+ * `zod` dependency trees in the monorepo (root + `src/apps/compiler-ui`).
+ * Callers cast or render structurally as needed.
+ */
+export declare class WireShapeError extends Error {
+    readonly name = "WireShapeError";
+    readonly path: string;
+    readonly issues: readonly unknown[];
+    constructor(options: {
+        path: string;
+        issues: readonly unknown[];
+    });
+}

package/dist/packages/engine/wire-schemas.js

@@ -0,0 +1,59 @@
+/**
+ * 0.17 — private wire-shape registry for the Compiler UI.
+ *
+ * The UI consumes the local-service API at `/v1/...`. Before 0.17 it
+ * cast each `getJson` response to a TypeScript type without runtime
+ * validation, which let the 0.16 prepRuns shape-mismatch bug
+ * (UI typed `{ runs: CompileRunResource[] }`, API returns
+ * `{ runs: CompileRun[] }`) ship to production. This module exposes
+ * the response schemas the UI needs so `getJson` can validate at the
+ * fetch boundary.
+ *
+ * **Stays private.** Do NOT re-export from
+ * `src/packages/engine/index.ts` and do NOT add a `package.json#exports`
+ * subpath. 0.16 just pruned three subpath exports
+ * (`./contracts`, `./execution`, `./local-service`); adding wire
+ * schemas to the public ABI would reverse that direction-of-travel.
+ * The Compiler UI builds inside the same repo and imports these
+ * schemas via relative path — no public ABI change.
+ */
+import { z } from "zod";
+import { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, MethodListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema, } from "./lib/schema.js";
+import { CompileRunSchema, } from "./execution/lib/schema.js";
+export { ActionProposalListResponseSchema, InstanceResourceSchema, LocalExecutorStatusSchema, LocalServiceHealthSchema, MethodListResponseSchema, PreparationListResponseSchema, RunObservabilityListResponseSchema, ReadinessListResponseSchema, SourceFileListResponseSchema, VerifyRunListResponseSchema, };
+/**
+ * `GET /v1/preparations/<id>/runs` returns a flat list of compile runs.
+ * The 0.16 bug came from typing this as `{ runs: CompileRunResource[] }`
+ * (the wrapped form `{ run: CompileRun }`) when the API returns the
+ * unwrapped form. Pinning the schema here prevents the regression.
+ */
+export const PreparationCompileRunListResponseSchema = z.object({
+    runs: z.array(CompileRunSchema),
+}).strict();
+/**
+ * Thrown when `getJson` parses a response that fails the registered
+ * schema. Surfaces the request path and the zod issue list so the UI
+ * can render an actionable error rather than a stack trace.
+ *
+ * `issues` is typed as `unknown[]` so the class works across both
+ * `zod` dependency trees in the monorepo (root + `src/apps/compiler-ui`).
+ * Callers cast or render structurally as needed.
+ */
+export class WireShapeError extends Error {
+    name = "WireShapeError";
+    path;
+    issues;
+    constructor(options) {
+        super(`Wire-shape validation failed for ${options.path}: ${options.issues.map((issue) => describeIssue(issue)).join("; ")}`);
+        this.path = options.path;
+        this.issues = options.issues;
+    }
+}
+function describeIssue(issue) {
+    if (typeof issue === "object" && issue !== null && "message" in issue) {
+        const message = issue.message;
+        if (typeof message === "string")
+            return message;
+    }
+    return JSON.stringify(issue);
+}

package/dist/packages/methods/authoring/method-authoring.d.ts

@@ -1,6 +1,7 @@
+import { type MethodAuthoringArtifactRequirement } from "../../engine/agents/lib/shells.js";
 import type { MethodExecutor } from "../../engine/agents/lib/executors.js";
 import { validateMethodPackage } from "../package/local-methods.js";
-import type { SourceReadinessCheck } from "../../project/lib/schema.js";
+import type { RequestedArtifact, SourceProfile, SourceReadinessCheck } from "../../project/lib/schema.js";
 /**
  * Walk method.json after a successful authoring run and fill in
  * `role: "general"` for any stage missing a role field. Custom role
@@ -26,6 +27,9 @@ export declare function runMethodAuthoringDraft(options: {
     hint: string;
     taskPrompt: string;
     checks?: SourceReadinessCheck[];
+    requestedArtifacts?: RequestedArtifact[];
+    sourceProfile?: SourceProfile | null;
+    artifactRequirements?: MethodAuthoringArtifactRequirement[];
     executor: MethodExecutor;
     onStatus?: (line: string) => void;
 }): Promise<MethodAuthoringRunResult>;