@interf/compiler 0.7.3 → 0.9.1

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

@@ -0,0 +1,636 @@
+import { z } from "zod";
+import { ArtifactRefSchema, CompileRunSchema, CompileRunStatusSchema, InterfRunEventSchema, ProofRecordSchema, RunObservabilitySchema, } from "../../execution/lib/schema.js";
+import { DatasetNameSchema, PreparationNameSchema, SourceDatasetConfigSchema, SourcePreparationConfigSchema, SourceReadinessCheckSchema, } from "../../project-model/lib/schema.js";
+import { TestRunComparisonSchema, TestRunModeSchema, } from "../../testing/lib/schema.js";
+import { ReadinessStateSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, WorkflowIdSchema, } from "../../compiler/lib/schema.js";
+const JsonObjectSchema = z.record(z.string(), z.unknown());
+function normalizePreparationMethodRequest(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const input = value;
+    const normalized = { ...input };
+    if (normalized.preparation == null || normalized.preparation === "") {
+        delete normalized.preparation;
+    }
+    if (normalized.method == null || normalized.method === "") {
+        delete normalized.method;
+    }
+    if (typeof normalized.preparation !== "string" && typeof input.dataset === "string") {
+        normalized.preparation = input.dataset;
+    }
+    if (typeof normalized.method !== "string" && typeof input.workflow === "string") {
+        normalized.method = input.workflow;
+    }
+    delete normalized.dataset;
+    delete normalized.workflow;
+    return normalized;
+}
+function normalizePreparationObjectRequest(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const input = value;
+    const normalized = { ...input };
+    if (!normalized.preparation && input.dataset && typeof input.dataset === "object") {
+        normalized.preparation = input.dataset;
+    }
+    delete normalized.dataset;
+    return normalized;
+}
+function normalizePublicActionType(value) {
+    const normalized = normalizePreparationMethodRequest(value);
+    if (!normalized || typeof normalized !== "object" || Array.isArray(normalized)) {
+        return normalized;
+    }
+    const output = { ...normalized };
+    if (output.action_type === "dataset-setup")
+        output.action_type = "preparation-setup";
+    if (output.action_type === "workflow-authoring")
+        output.action_type = "method-authoring";
+    if (output.action_type === "workflow-improvement")
+        output.action_type = "method-improvement";
+    for (const key of ["title", "summary", "assistant_message", "command_preview"]) {
+        if (output[key] == null || output[key] === "") {
+            delete output[key];
+        }
+    }
+    return output;
+}
+function normalizeWorkflowAuthoringRequest(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const input = value;
+    const normalized = normalizePreparationMethodRequest(input);
+    if (typeof normalized.source_folder_path !== "string" && typeof input.dataset_path === "string") {
+        normalized.source_folder_path = input.dataset_path;
+    }
+    if (typeof normalized.method_id !== "string") {
+        if (typeof input.workflow_id === "string")
+            normalized.method_id = input.workflow_id;
+        else if (typeof normalized.method === "string")
+            normalized.method_id = normalized.method;
+    }
+    if (typeof normalized.base_method_id !== "string" && typeof input.base_workflow_id === "string") {
+        normalized.base_method_id = input.base_workflow_id;
+    }
+    if (typeof normalized.reference_method_id !== "string" && typeof input.reference_workflow_id === "string") {
+        normalized.reference_method_id = input.reference_workflow_id;
+    }
+    delete normalized.dataset_path;
+    delete normalized.workflow_id;
+    delete normalized.base_workflow_id;
+    delete normalized.reference_workflow_id;
+    return normalized;
+}
+export const LocalServiceHostSchema = z.string().min(1);
+export const LocalServicePortSchema = z.number().int().min(1).max(65535);
+export const LocalServiceConfigSchema = z.object({
+    host: LocalServiceHostSchema.default("127.0.0.1"),
+    port: LocalServicePortSchema.default(4873),
+}).strict();
+export const LocalServiceHealthSchema = z.object({
+    kind: z.literal("interf-local-service-health"),
+    version: z.literal(1),
+    status: z.literal("ok"),
+    host: LocalServiceHostSchema,
+    port: LocalServicePortSchema,
+    service_url: z.string().min(1),
+    control_path: z.string().min(1).optional(),
+    source_folder_path: z.string().min(1).nullable().optional(),
+    started_at: z.string().min(1).optional(),
+    package_version: z.string().min(1).optional(),
+}).strict();
+export const LocalServiceInstancePointerSchema = z.object({
+    service_url: z.string().min(1),
+    host: LocalServiceHostSchema,
+    port: LocalServicePortSchema,
+    pid: z.number().int().positive(),
+    control_path: z.string().min(1),
+    started_at: z.string().min(1),
+}).strict();
+export const DatasetResourceSchema = z.object({
+    dataset: SourceDatasetConfigSchema,
+    portable_context_path: z.string().min(1).nullable(),
+    readiness: ReadinessStateSchema,
+    latest_compile_run_id: z.string().min(1).nullable().optional(),
+    latest_test_run_id: z.string().min(1).nullable().optional(),
+}).strict();
+export const PreparationReadinessStateSchema = ReadinessStateSchema;
+export const PortableContextMappingSchema = z.object({
+    preparation: PreparationNameSchema,
+    path: z.string().min(1).nullable(),
+    exists: z.boolean(),
+    method_id: WorkflowIdSchema.nullable(),
+    latest_compile_run_id: z.string().min(1).nullable(),
+    latest_test_run_id: z.string().min(1).nullable(),
+}).strict();
+export const PreparationRunLinkageSchema = z.object({
+    latest_compile_run_id: z.string().min(1).nullable(),
+    latest_test_run_id: z.string().min(1).nullable(),
+}).strict();
+export const PreparationResourceSchema = z.object({
+    id: PreparationNameSchema,
+    name: PreparationNameSchema,
+    preparation: SourcePreparationConfigSchema,
+    source_path: z.string().min(1),
+    method_id: WorkflowIdSchema.nullable(),
+    checks: z.array(SourceReadinessCheckSchema).default([]),
+    portable_context: PortableContextMappingSchema,
+    portable_context_path: z.string().min(1).nullable(),
+    readiness: PreparationReadinessStateSchema,
+    runs: PreparationRunLinkageSchema,
+    latest_compile_run_id: z.string().min(1).nullable().optional(),
+    latest_test_run_id: z.string().min(1).nullable().optional(),
+}).strict();
+export const WorkflowPackageResourceSchema = z.object({
+    id: WorkflowIdSchema,
+    path: z.string().min(1),
+    label: z.string().min(1).optional(),
+    hint: z.string().min(1).optional(),
+    source_kind: z.enum(["builtin", "local"]).default("local"),
+    built_in: z.boolean().default(false),
+    active_for_datasets: z.array(DatasetNameSchema).default([]),
+    stages: z.array(z.object({
+        id: z.string().min(1),
+        label: z.string().min(1),
+        description: z.string().min(1).optional(),
+        contract_type: z.string().min(1),
+        skill_dir: z.string().min(1),
+        reads: z.array(z.string().min(1)).default([]),
+        writes: z.array(z.string().min(1)).default([]),
+        acceptance: z.record(z.string(), z.unknown()).optional(),
+    }).strict()).default([]),
+}).strict();
+export const MethodResourceSchema = z.object({
+    id: WorkflowIdSchema,
+    method_id: WorkflowIdSchema,
+    path: z.string().min(1),
+    label: z.string().min(1).optional(),
+    hint: z.string().min(1).optional(),
+    source_kind: z.enum(["builtin", "local"]).default("local"),
+    built_in: z.boolean().default(false),
+    active_for_preparations: z.array(DatasetNameSchema).default([]),
+    stages: z.array(z.object({
+        id: z.string().min(1),
+        label: z.string().min(1),
+        description: z.string().min(1).optional(),
+        contract_type: z.string().min(1),
+        skill_dir: z.string().min(1),
+        reads: z.array(z.string().min(1)).default([]),
+        writes: z.array(z.string().min(1)).default([]),
+        acceptance: z.record(z.string(), z.unknown()).optional(),
+    }).strict()).default([]),
+}).strict();
+export const CompileRunCreateRequestSchema = z.preprocess(normalizePreparationMethodRequest, z.object({
+    preparation: PreparationNameSchema,
+    method: WorkflowIdSchema.optional(),
+    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
+    max_loops: SourceCompiledMaxLoopsSchema.optional(),
+    preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
+}).strict());
+export const CompileRunSummarySchema = z.object({
+    run_id: z.string().min(1),
+    status: CompileRunStatusSchema,
+    preparation: PreparationNameSchema,
+    method: WorkflowIdSchema,
+    portable_context_path: z.string().min(1),
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    latest_event: InterfRunEventSchema.nullable().optional(),
+    latest_proof: ProofRecordSchema.nullable().optional(),
+}).strict();
+export const CompileRunResourceSchema = z.object({
+    run: CompileRunSchema,
+}).strict();
+export const LocalJobTypeSchema = z.enum([
+    "preparation-setup",
+    "readiness-check-draft",
+    "method-authoring",
+    "method-improvement",
+    "compile",
+    "test",
+]);
+export const LocalJobStatusSchema = z.enum([
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+    "cancelled",
+]);
+export const LocalRunHandlerResultSchema = z.object({
+    ok: z.boolean(),
+    error: z.string().min(1).optional(),
+}).strict();
+export const LocalJobAgentSchema = z.object({
+    name: z.string().min(1),
+    display_name: z.string().min(1),
+    command: z.string().min(1).nullable().optional(),
+}).strict();
+export const LocalExecutorOptionSchema = LocalJobAgentSchema.extend({
+    current: z.boolean(),
+}).strict();
+export const LocalJobStepSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    status: LocalJobStatusSchema,
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    summary: z.string().min(1).nullable().optional(),
+    input: JsonObjectSchema.nullable().optional(),
+    output: JsonObjectSchema.nullable().optional(),
+}).strict();
+export const LocalJobEventTypeSchema = z.enum([
+    "job.started",
+    "step.started",
+    "log.appended",
+    "artifact.written",
+    "step.completed",
+    "step.failed",
+    "job.completed",
+    "job.failed",
+]);
+export const LocalJobEventSchema = z.object({
+    event_id: z.string().min(1),
+    run_id: z.string().min(1),
+    timestamp: z.string().min(1),
+    type: LocalJobEventTypeSchema,
+    step_id: z.string().min(1).optional(),
+    message: z.string().min(1).optional(),
+    artifact: ArtifactRefSchema.optional(),
+    input: JsonObjectSchema.nullable().optional(),
+    output: JsonObjectSchema.nullable().optional(),
+}).strict();
+export const LocalJobRunCreateRequestSchema = z.preprocess(normalizePreparationMethodRequest, z.object({
+    job_type: LocalJobTypeSchema,
+    title: z.string().min(1),
+    preparation: PreparationNameSchema.nullable().optional(),
+    method: WorkflowIdSchema.nullable().optional(),
+    source_path: z.string().min(1).nullable().optional(),
+    output_path: z.string().min(1).nullable().optional(),
+    agent: LocalJobAgentSchema.nullable().optional(),
+    steps: z.array(z.object({
+        id: z.string().min(1),
+        label: z.string().min(1),
+        input: JsonObjectSchema.nullable().optional(),
+    }).strict()).default([]),
+}).strict());
+export const PreparationSetupCreateRequestSchema = z.preprocess(normalizePreparationObjectRequest, z.object({
+    preparation: SourcePreparationConfigSchema,
+}).strict());
+export const DatasetSetupCreateRequestSchema = PreparationSetupCreateRequestSchema;
+export const ReadinessCheckDraftCreateRequestSchema = z.preprocess(normalizeWorkflowAuthoringRequest, z.object({
+    preparation: PreparationNameSchema,
+    source_folder_path: z.string().min(1),
+    about: z.string().min(1).optional(),
+    target_count: z.number().int().min(1).max(8).default(4),
+}).strict());
+export const ReadinessCheckDraftResultSchema = z.object({
+    checks: z.array(SourceReadinessCheckSchema).default([]),
+}).strict();
+export const WorkflowAuthoringCreateRequestSchema = z.preprocess(normalizeWorkflowAuthoringRequest, z.object({
+    preparation: PreparationNameSchema.nullable().optional(),
+    source_folder_path: z.string().min(1),
+    base_method_id: WorkflowIdSchema.optional(),
+    reference_method_id: WorkflowIdSchema.optional(),
+    method_id: WorkflowIdSchema,
+    label: z.string().min(1),
+    hint: z.string().min(1),
+    task_prompt: z.string().min(1),
+    checks: z.array(SourceReadinessCheckSchema).default([]),
+}).strict());
+export const WorkflowAuthoringResultSchema = z.object({
+    status: z.enum(["updated", "no-change", "invalid", "executor-failed"]),
+    changed: z.boolean(),
+    summary: z.string().min(1),
+    method_path: z.string().min(1),
+    shell_path: z.string().min(1),
+    validation: z.unknown().nullable().optional(),
+}).strict();
+export const LocalJobEventAppendRequestSchema = z.object({
+    type: LocalJobEventTypeSchema,
+    step_id: z.string().min(1).optional(),
+    message: z.string().min(1).optional(),
+    artifact: ArtifactRefSchema.optional(),
+    input: JsonObjectSchema.nullable().optional(),
+    output: JsonObjectSchema.nullable().optional(),
+}).strict();
+export const LocalJobRunResourceSchema = z.object({
+    kind: z.literal("interf-local-job-run"),
+    version: z.literal(1),
+    run_id: z.string().min(1),
+    job_type: LocalJobTypeSchema,
+    status: LocalJobStatusSchema,
+    title: z.string().min(1),
+    preparation: PreparationNameSchema.nullable().optional(),
+    method: WorkflowIdSchema.nullable().optional(),
+    source_path: z.string().min(1).nullable().optional(),
+    output_path: z.string().min(1).nullable().optional(),
+    agent: LocalJobAgentSchema.nullable().optional(),
+    created_at: z.string().min(1),
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    steps: z.array(LocalJobStepSchema).default([]),
+    events: z.array(LocalJobEventSchema).default([]),
+    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 TestRunCreateRequestSchema = z.preprocess(normalizePreparationMethodRequest, z.object({
+    preparation: PreparationNameSchema,
+    mode: TestRunModeSchema.default("both"),
+}).strict());
+export const TestRunResourceSchema = z.object({
+    run_id: z.string().min(1),
+    status: TestRunStatusSchema,
+    preparation: PreparationNameSchema,
+    mode: TestRunModeSchema,
+    source_path: z.string().min(1),
+    portable_context_path: z.string().min(1).nullable(),
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    comparison: TestRunComparisonSchema.nullable(),
+    readiness: ReadinessStateSchema.nullable().optional(),
+    events: z.array(InterfRunEventSchema).default([]),
+    error: z.string().min(1).nullable().optional(),
+}).strict();
+export const RunObservabilityResourceSchema = RunObservabilitySchema;
+export const RunCreateRequestSchema = z.preprocess(normalizePreparationMethodRequest, z.discriminatedUnion("run_type", [
+    z.object({
+        run_type: z.literal("compile"),
+        preparation: PreparationNameSchema,
+        method: WorkflowIdSchema.optional(),
+        max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
+        max_loops: SourceCompiledMaxLoopsSchema.optional(),
+        preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
+    }).strict(),
+    z.object({
+        run_type: z.literal("prepare"),
+        preparation: PreparationNameSchema,
+        method: WorkflowIdSchema.optional(),
+        max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
+        max_loops: SourceCompiledMaxLoopsSchema.optional(),
+        preserve_stage_shells: z.enum(["on-failure", "always"]).optional(),
+    }).strict(),
+    z.object({
+        run_type: z.literal("test"),
+        preparation: PreparationNameSchema,
+        mode: TestRunModeSchema.default("both"),
+    }).strict(),
+    z.object({
+        run_type: z.literal("check"),
+        preparation: PreparationNameSchema,
+        mode: TestRunModeSchema.default("both"),
+    }).strict(),
+]));
+export const LocalExecutorStatusSchema = z.object({
+    kind: z.literal("interf-local-executor-status"),
+    version: z.literal(1),
+    status: z.enum(["connected", "unavailable"]),
+    checked_at: z.string().min(1),
+    executor: LocalJobAgentSchema.nullable(),
+    available_executors: z.array(LocalExecutorOptionSchema).default([]),
+    message: z.string().min(1),
+}).strict();
+export const LocalExecutorSelectRequestSchema = z.object({
+    agent: z.string().min(1),
+}).strict();
+export const ActionProposalTypeSchema = z.enum([
+    "clarification",
+    "preparation-setup",
+    "readiness-check-draft",
+    "method-authoring",
+    "method-improvement",
+    "compile",
+    "test",
+]);
+export const ActionProposalStatusSchema = z.enum([
+    "needs_clarification",
+    "awaiting_approval",
+    "approved",
+    "denied",
+    "submitted",
+    "failed",
+]);
+export const ActionProposalCreateRequestSchema = z.preprocess(normalizePreparationMethodRequest, z.object({
+    message: z.string().min(1),
+    preparation: PreparationNameSchema.optional(),
+    values: JsonObjectSchema.optional(),
+}).strict());
+export const ActionProposalPlanSchema = z.preprocess(normalizePublicActionType, z.object({
+    action_type: ActionProposalTypeSchema,
+    preparation: PreparationNameSchema.optional(),
+    method: WorkflowIdSchema.optional(),
+    values: JsonObjectSchema.optional(),
+    title: z.string().min(1).optional(),
+    summary: z.string().min(1).optional(),
+    assistant_message: z.string().min(1).optional(),
+    command_preview: z.string().min(1).optional(),
+}).strict());
+export const ActionProposalApprovalRequestSchema = z.object({
+    approved: z.boolean(),
+    note: z.string().min(1).optional(),
+}).strict();
+export const ActionProposalApprovalSchema = z.object({
+    approved: z.boolean(),
+    decided_at: z.string().min(1),
+    note: z.string().min(1).optional(),
+}).strict();
+const ActionProposalResourceBaseSchema = z.object({
+    kind: z.literal("interf-action-proposal"),
+    version: z.literal(1),
+    proposal_id: z.string().min(1),
+    status: ActionProposalStatusSchema,
+    title: z.string().min(1),
+    summary: z.string().min(1),
+    assistant_message: z.string().min(1).optional(),
+    command_preview: z.string().min(1).optional(),
+    message: z.string().min(1),
+    preparation: PreparationNameSchema.nullable().optional(),
+    method: WorkflowIdSchema.nullable().optional(),
+    created_at: z.string().min(1),
+    updated_at: z.string().min(1),
+    proposed_by_executor: LocalJobAgentSchema.nullable().optional(),
+    approval: ActionProposalApprovalSchema.nullable().optional(),
+    submitted_run_id: z.string().min(1).nullable().optional(),
+    submitted_run_type: z.enum(["compile-run", "test-run", "job-run"]).nullable().optional(),
+    error: z.string().min(1).nullable().optional(),
+}).strict();
+export const ActionProposalResourceSchema = z.discriminatedUnion("action_type", [
+    ActionProposalResourceBaseSchema.extend({
+        action_type: z.literal("clarification"),
+        request: JsonObjectSchema,
+    }).strict(),
+    ActionProposalResourceBaseSchema.extend({
+        action_type: z.literal("compile"),
+        request: CompileRunCreateRequestSchema,
+    }).strict(),
+    ActionProposalResourceBaseSchema.extend({
+        action_type: z.literal("preparation-setup"),
+        request: PreparationSetupCreateRequestSchema,
+    }).strict(),
+    ActionProposalResourceBaseSchema.extend({
+        action_type: z.literal("test"),
+        request: TestRunCreateRequestSchema,
+    }).strict(),
+    ActionProposalResourceBaseSchema.extend({
+        action_type: z.literal("readiness-check-draft"),
+        request: ReadinessCheckDraftCreateRequestSchema,
+    }).strict(),
+    ActionProposalResourceBaseSchema.extend({
+        action_type: z.literal("method-authoring"),
+        request: WorkflowAuthoringCreateRequestSchema,
+    }).strict(),
+    ActionProposalResourceBaseSchema.extend({
+        action_type: z.literal("method-improvement"),
+        request: WorkflowAuthoringCreateRequestSchema,
+    }).strict(),
+]);
+export const PortableContextResourceSchema = z.object({
+    preparation: PreparationNameSchema,
+    path: z.string().min(1),
+    exists: z.boolean(),
+    readiness: ReadinessStateSchema,
+    method: WorkflowIdSchema.nullable().optional(),
+    latest_compile_run_id: z.string().min(1).nullable().optional(),
+    latest_test_run_id: z.string().min(1).nullable().optional(),
+    artifacts: z.array(ArtifactRefSchema).default([]),
+}).strict();
+export const ReadinessResourceSchema = PreparationReadinessStateSchema;
+export const SourceFileResourceSchema = z.object({
+    preparation: PreparationNameSchema,
+    path: z.string().min(1),
+    absolute_path: z.string().min(1),
+    size_bytes: z.number().int().min(0),
+    modified_at: z.string().min(1).nullable(),
+    source_folder_path: z.string().min(1),
+}).strict();
+export const WorkspaceFileResourceSchema = z.object({
+    path: z.string().min(1),
+    absolute_path: z.string().min(1),
+    size_bytes: z.number().int().min(0),
+    modified_at: z.string().min(1).nullable(),
+}).strict();
+export const LocalServiceDiscoverySchema = z.object({
+    kind: z.literal("interf-local-service-discovery"),
+    version: z.literal(1),
+    resources: z.object({
+        preparations: z.string().min(1),
+        methods: z.string().min(1),
+        runs: z.string().min(1),
+        readiness: z.string().min(1),
+        portable_contexts: z.string().min(1),
+        source_files: z.string().min(1),
+        workspace_files: z.string().min(1),
+        action_proposals: z.string().min(1),
+        executor: z.string().min(1),
+    }).strict(),
+}).strict();
+export const OpenPathRequestSchema = z.object({
+    path: z.string().min(1),
+}).strict();
+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("dataset"),
+        value: DatasetResourceSchema,
+    }).strict(),
+    z.object({
+        kind: z.literal("preparation"),
+        value: PreparationResourceSchema,
+    }).strict(),
+    z.object({
+        kind: z.literal("workflow-package"),
+        value: WorkflowPackageResourceSchema,
+    }).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 DatasetListResponseSchema = z.object({
+    datasets: z.array(DatasetResourceSchema),
+}).strict();
+export const PreparationListResponseSchema = z.object({
+    preparations: z.array(PreparationResourceSchema),
+}).strict();
+export const WorkflowPackageListResponseSchema = z.object({
+    workflow_packages: z.array(WorkflowPackageResourceSchema),
+}).strict();
+export const MethodListResponseSchema = z.object({
+    methods: z.array(MethodResourceSchema),
+}).strict();
+export const CompileRunListResponseSchema = z.object({
+    compile_runs: z.array(CompileRunResourceSchema),
+}).strict();
+export const LocalJobRunListResponseSchema = z.object({
+    jobs: z.array(LocalJobRunResourceSchema),
+}).strict();
+export const TestRunListResponseSchema = z.object({
+    test_runs: z.array(TestRunResourceSchema),
+}).strict();
+export const RunObservabilityListResponseSchema = z.object({
+    runs: z.array(RunObservabilityResourceSchema),
+}).strict();
+export const ActionProposalListResponseSchema = z.object({
+    action_proposals: z.array(ActionProposalResourceSchema),
+}).strict();
+export const PortableContextListResponseSchema = z.object({
+    portable_contexts: z.array(PortableContextResourceSchema),
+}).strict();
+export const ReadinessListResponseSchema = z.object({
+    readiness: z.array(ReadinessResourceSchema),
+}).strict();
+export const SourceFileListResponseSchema = z.object({
+    source_files: z.array(SourceFileResourceSchema),
+}).strict();
+export const WorkspaceFileListResponseSchema = z.object({
+    workspace_files: z.array(WorkspaceFileResourceSchema),
+}).strict();

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

@@ -0,0 +1,27 @@
+export declare const LOCAL_SERVICE_DEFAULT_HOST = "127.0.0.1";
+export declare const LOCAL_SERVICE_DEFAULT_PORT = 4873;
+export declare const LOCAL_SERVICE_INSTANCE_POINTER_PATH: readonly ["interf", ".service", "local-instance.json"];
+export declare const LOCAL_SERVICE_ROUTES: {
+    readonly root: "/";
+    readonly api: "/v1";
+    readonly health: "/health";
+    readonly preparations: "/v1/preparations";
+    readonly workspaceFiles: "/v1/workspace-files";
+    readonly sourceFiles: "/v1/source-files";
+    readonly methods: "/v1/methods";
+    readonly jobs: "/v1/jobs";
+    readonly readinessCheckDrafts: "/v1/readiness-check-drafts";
+    readonly methodAuthoringRuns: "/v1/method-authoring-runs";
+    readonly runs: "/v1/runs";
+    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 openPath: "/v1/open-path";
+};
+export declare function buildLocalServiceUrl(options?: {
+    host?: string;
+    port?: number;
+}): string;

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

@@ -0,0 +1,32 @@
+export const LOCAL_SERVICE_DEFAULT_HOST = "127.0.0.1";
+export const LOCAL_SERVICE_DEFAULT_PORT = 4873;
+export const LOCAL_SERVICE_INSTANCE_POINTER_PATH = [
+    "interf",
+    ".service",
+    "local-instance.json",
+];
+export const LOCAL_SERVICE_ROUTES = {
+    root: "/",
+    api: "/v1",
+    health: "/health",
+    preparations: "/v1/preparations",
+    workspaceFiles: "/v1/workspace-files",
+    sourceFiles: "/v1/source-files",
+    methods: "/v1/methods",
+    jobs: "/v1/jobs",
+    readinessCheckDrafts: "/v1/readiness-check-drafts",
+    methodAuthoringRuns: "/v1/method-authoring-runs",
+    runs: "/v1/runs",
+    executor: "/v1/executor",
+    actionProposals: "/v1/action-proposals",
+    compileRuns: "/v1/compile-runs",
+    testRuns: "/v1/test-runs",
+    portableContexts: "/v1/portable-contexts",
+    readiness: "/v1/readiness",
+    openPath: "/v1/open-path",
+};
+export function buildLocalServiceUrl(options = {}) {
+    const host = options.host ?? LOCAL_SERVICE_DEFAULT_HOST;
+    const port = options.port ?? LOCAL_SERVICE_DEFAULT_PORT;
+    return `http://${host}:${port}`;
+}