@interf/compiler 0.7.3 → 0.9.3

package/dist/packages/contracts/lib/schema.d.ts

@@ -0,0 +1,205 @@
+import { z } from "zod";
+export declare const InterfIdPattern: RegExp;
+export declare const PreparationNamePattern: RegExp;
+export declare const PreparationNameSchema: z.ZodString;
+export declare const MethodIdSchema: z.ZodString;
+export declare const RuntimeStageSchema: z.ZodString;
+export declare const RuntimeContractTypeSchema: z.ZodString;
+export declare const RuntimeTargetTypeSchema: z.ZodEnum<{
+    compiled: "compiled";
+}>;
+export declare const TestTargetTypeSchema: z.ZodEnum<{
+    compiled: "compiled";
+    raw: "raw";
+}>;
+export declare const SourceCompiledMaxAttemptsSchema: z.ZodNumber;
+export declare const SourceCompiledMaxLoopsSchema: z.ZodNumber;
+export declare const ReadinessStatusSchema: z.ZodEnum<{
+    "not-configured": "not-configured";
+    "not-built": "not-built";
+    building: "building";
+    built: "built";
+    checking: "checking";
+    ready: "ready";
+    "not-ready": "not-ready";
+    stale: "stale";
+    failed: "failed";
+}>;
+export declare const ReadinessGateSchema: z.ZodEnum<{
+    "preparation-config": "preparation-config";
+    "portable-context": "portable-context";
+    "compile-run": "compile-run";
+    "readiness-checks": "readiness-checks";
+    "source-baseline": "source-baseline";
+    "portable-context-check": "portable-context-check";
+    "checks-current": "checks-current";
+}>;
+export declare const ReadinessCheckSchema: z.ZodObject<{
+    gate: z.ZodEnum<{
+        "preparation-config": "preparation-config";
+        "portable-context": "portable-context";
+        "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;
+    status: z.ZodOptional<z.ZodEnum<{
+        "not-configured": "not-configured";
+        "not-built": "not-built";
+        building: "building";
+        built: "built";
+        checking: "checking";
+        ready: "ready";
+        "not-ready": "not-ready";
+        stale: "stale";
+        failed: "failed";
+    }>>;
+    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>;
+export declare const ReadinessTargetResultSchema: 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>;
+export declare const ReadinessStateSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-readiness-state">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    preparation: z.ZodString;
+    status: z.ZodEnum<{
+        "not-configured": "not-configured";
+        "not-built": "not-built";
+        building: "building";
+        built: "built";
+        checking: "checking";
+        ready: "ready";
+        "not-ready": "not-ready";
+        stale: "stale";
+        failed: "failed";
+    }>;
+    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<{
+            "preparation-config": "preparation-config";
+            "portable-context": "portable-context";
+            "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;
+        status: z.ZodOptional<z.ZodEnum<{
+            "not-configured": "not-configured";
+            "not-built": "not-built";
+            building: "building";
+            built: "built";
+            checking: "checking";
+            ready: "ready";
+            "not-ready": "not-ready";
+            stale: "stale";
+            failed: "failed";
+        }>>;
+        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>>;
+        delta: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        gate: z.ZodEnum<{
+            "preparation-config": "preparation-config";
+            "portable-context": "portable-context";
+            "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;
+        status: z.ZodOptional<z.ZodEnum<{
+            "not-configured": "not-configured";
+            "not-built": "not-built";
+            building: "building";
+            built: "built";
+            checking: "checking";
+            ready: "ready";
+            "not-ready": "not-ready";
+            stale: "stale";
+            failed: "failed";
+        }>>;
+        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>;
+export declare const RuntimeExecutorInfoSchema: 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>;
+export declare const TestCaseExpectSchema: z.ZodObject<{
+    must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+    must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    min_words: z.ZodOptional<z.ZodNumber>;
+    max_words: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PreparationName = z.infer<typeof PreparationNameSchema>;
+export type MethodId = z.infer<typeof MethodIdSchema>;
+export type RuntimeStage = z.infer<typeof RuntimeStageSchema>;
+export type RuntimeContractType = z.infer<typeof RuntimeContractTypeSchema>;
+export type RuntimeTargetType = z.infer<typeof RuntimeTargetTypeSchema>;
+export type TestTargetType = z.infer<typeof TestTargetTypeSchema>;
+export type ReadinessStatus = z.infer<typeof ReadinessStatusSchema>;
+export type ReadinessGate = z.infer<typeof ReadinessGateSchema>;
+export type ReadinessCheck = z.infer<typeof ReadinessCheckSchema>;
+export type ReadinessTargetResult = z.infer<typeof ReadinessTargetResultSchema>;
+export type ReadinessState = z.infer<typeof ReadinessStateSchema>;
+export type RuntimeExecutorInfo = z.infer<typeof RuntimeExecutorInfoSchema>;
+export type TestCaseExpect = z.infer<typeof TestCaseExpectSchema>;

package/dist/packages/contracts/lib/schema.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+export const InterfIdPattern = /^[a-z0-9][a-z0-9-]{0,79}$/;
+export const PreparationNamePattern = /^[a-z0-9][a-z0-9-]*$/;
+const RESERVED_PREPARATION_NAMES = new Set(["tests", "methods"]);
+export const PreparationNameSchema = z
+    .string()
+    .regex(PreparationNamePattern, "Preparation names must use lowercase letters, numbers, and dashes only.")
+    .refine((value) => !RESERVED_PREPARATION_NAMES.has(value), "Preparation name is reserved.");
+export const MethodIdSchema = z.string().regex(InterfIdPattern);
+export const RuntimeStageSchema = z.string().regex(InterfIdPattern);
+export const RuntimeContractTypeSchema = z.string().regex(InterfIdPattern);
+export const RuntimeTargetTypeSchema = z.enum(["compiled"]);
+export const TestTargetTypeSchema = z.enum(["compiled", "raw"]);
+export const SourceCompiledMaxAttemptsSchema = z.number().int().min(1).max(5);
+export const SourceCompiledMaxLoopsSchema = z.number().int().min(1).max(3);
+export const ReadinessStatusSchema = z.enum([
+    "not-configured",
+    "not-built",
+    "building",
+    "built",
+    "checking",
+    "ready",
+    "not-ready",
+    "stale",
+    "failed",
+]);
+export const ReadinessGateSchema = z.enum([
+    "preparation-config",
+    "portable-context",
+    "compile-run",
+    "readiness-checks",
+    "source-baseline",
+    "portable-context-check",
+    "checks-current",
+]);
+export const ReadinessCheckSchema = z.object({
+    gate: ReadinessGateSchema,
+    ok: z.boolean(),
+    status: ReadinessStatusSchema.optional(),
+    summary: z.string().min(1),
+    detail: z.string().min(1).optional(),
+    run_id: z.string().min(1).nullable().optional(),
+    artifact_path: z.string().min(1).nullable().optional(),
+}).strict();
+export const ReadinessTargetResultSchema = z.object({
+    passed: z.number().int().min(0),
+    total: z.number().int().min(0),
+    pass_rate: z.number().min(0).max(100).nullable(),
+    checks_fingerprint: z.string().min(1).nullable().optional(),
+    stale: z.boolean().default(false),
+    run_id: z.string().min(1).nullable().optional(),
+    run_path: z.string().min(1).nullable().optional(),
+}).strict();
+export const ReadinessStateSchema = z.object({
+    kind: z.literal("interf-readiness-state"),
+    version: z.literal(1),
+    generated_at: z.string().min(1),
+    preparation: z.string().min(1),
+    status: ReadinessStatusSchema,
+    ready: z.boolean(),
+    summary: z.string().min(1),
+    portable_context_path: z.string().min(1).nullable(),
+    latest_compile_run_id: z.string().min(1).nullable().optional(),
+    latest_test_run_id: z.string().min(1).nullable().optional(),
+    compile: ReadinessCheckSchema.nullable(),
+    check_results: z.object({
+        configured: z.number().int().min(0),
+        fingerprint: z.string().min(1).nullable(),
+        source_files: ReadinessTargetResultSchema.nullable(),
+        portable_context: ReadinessTargetResultSchema.nullable(),
+        delta: z.number().nullable(),
+    }).strict(),
+    checks: z.array(ReadinessCheckSchema).default([]),
+}).strict();
+export const RuntimeExecutorInfoSchema = z.object({
+    kind: z.enum(["local-agent", "connected-provider", "managed"]),
+    name: z.string(),
+    display_name: z.string(),
+    command: z.string().nullable(),
+    model: z.string().nullable().optional(),
+    effort: z.string().nullable().optional(),
+    profile: z.string().nullable().optional(),
+    timeout_ms: z.number().nullable().optional(),
+});
+export const TestCaseExpectSchema = z.object({
+    must_include: z.array(z.string().min(1)).optional(),
+    must_include_one_of: z.array(z.array(z.string().min(1)).min(1)).optional(),
+    must_not_include: z.array(z.string().min(1)).optional(),
+    min_words: z.number().int().nonnegative().optional(),
+    max_words: z.number().int().nonnegative().optional(),
+}).refine((value) => value.min_words === undefined ||
+    value.max_words === undefined ||
+    value.max_words >= value.min_words, {
+    message: "max_words must be greater than or equal to min_words",
+}).refine((value) => (value.must_include?.length ?? 0) > 0 ||
+    (value.must_include_one_of?.length ?? 0) > 0 ||
+    (value.must_not_include?.length ?? 0) > 0 ||
+    value.min_words !== undefined ||
+    value.max_words !== undefined, {
+    message: "Test expectations must include at least one check",
+});

package/dist/packages/execution/adapters.d.ts

@@ -0,0 +1,15 @@
+import type { ExecutionBackendKind, InterfRunEvent } from "./lib/schema.js";
+import type { RunEventSink } from "./events.js";
+export interface ExecutionAdapterContext {
+    runId: string;
+    backend: ExecutionBackendKind;
+    events?: RunEventSink;
+}
+export interface ExecutionAdapter<TInput, TResult> {
+    kind: ExecutionBackendKind;
+    run(input: TInput, context: ExecutionAdapterContext): Promise<TResult>;
+}
+export interface ExecutionEventRecorder {
+    record(event: InterfRunEvent): void | Promise<void>;
+}
+export declare const nativeExecutionBackendKind = "native";

package/dist/packages/execution/adapters.js

@@ -0,0 +1 @@
+export const nativeExecutionBackendKind = "native";

package/dist/packages/execution/events.d.ts

@@ -0,0 +1,8 @@
+import { type InterfRunEvent } from "./lib/schema.js";
+export interface RunEventSink {
+    emit(event: InterfRunEvent): void | Promise<void>;
+}
+export declare const nullRunEventSink: RunEventSink;
+export declare function parseInterfRunEvent(value: unknown): InterfRunEvent;
+export declare function createRunEventId(prefix?: string): string;
+export declare function createRunEventTimestamp(date?: Date): string;

package/dist/packages/execution/events.js

@@ -0,0 +1,16 @@
+import { InterfRunEventSchema, } from "./lib/schema.js";
+export const nullRunEventSink = {
+    emit() {
+        // Intentionally empty. Callers can depend on an event sink without
+        // requiring a service process.
+    },
+};
+export function parseInterfRunEvent(value) {
+    return InterfRunEventSchema.parse(value);
+}
+export function createRunEventId(prefix = "event") {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+export function createRunEventTimestamp(date = new Date()) {
+    return date.toISOString();
+}

package/dist/packages/execution/index.d.ts

@@ -0,0 +1,9 @@
+export * as schema from "./lib/schema.js";
+export * as events from "./events.js";
+export * as adapters from "./adapters.js";
+export type { ArtifactRef, ArtifactRole, CompileRun, CompileRunStatus, ExecutionBackendKind, InterfRunEvent, ObservableRunMetric, ObservableRunStatus, ObservableRunType, ProofCheck, ProofRecord, RunObservability, StageRun, StageRunContract, StageRunLogs, StageRunStatus, MethodTrace, MethodTraceEvent, MethodTraceEventType, MethodTraceRun, MethodTraceRunStatus, MethodTraceStreamChunk, MethodTraceStructuredError, } from "./lib/schema.js";
+export { ArtifactRefSchema, ArtifactRoleSchema, CompileRunSchema, CompileRunStatusSchema, ExecutionBackendKindSchema, InterfRunEventSchema, LogAppendedEventSchema, ObservableRunMetricSchema, ObservableRunStatusSchema, ObservableRunTypeSchema, ProofCheckSchema, ProofRecordSchema, RunObservabilitySchema, StageRunSchema, StageRunContractSchema, StageRunLogsSchema, StageRunStatusSchema, MethodTraceEventSchema, MethodTraceEventTypeSchema, MethodTraceRunSchema, MethodTraceRunStatusSchema, MethodTraceSchema, MethodTraceStreamChunkSchema, MethodTraceStructuredErrorSchema, } from "./lib/schema.js";
+export type { ExecutionAdapter, ExecutionAdapterContext, ExecutionEventRecorder, } from "./adapters.js";
+export { nativeExecutionBackendKind, } from "./adapters.js";
+export type { RunEventSink, } from "./events.js";
+export { createRunEventId, createRunEventTimestamp, nullRunEventSink, parseInterfRunEvent, } from "./events.js";

package/dist/packages/execution/index.js

@@ -0,0 +1,6 @@
+export * as schema from "./lib/schema.js";
+export * as events from "./events.js";
+export * as adapters from "./adapters.js";
+export { ArtifactRefSchema, ArtifactRoleSchema, CompileRunSchema, CompileRunStatusSchema, ExecutionBackendKindSchema, InterfRunEventSchema, LogAppendedEventSchema, ObservableRunMetricSchema, ObservableRunStatusSchema, ObservableRunTypeSchema, ProofCheckSchema, ProofRecordSchema, RunObservabilitySchema, StageRunSchema, StageRunContractSchema, StageRunLogsSchema, StageRunStatusSchema, MethodTraceEventSchema, MethodTraceEventTypeSchema, MethodTraceRunSchema, MethodTraceRunStatusSchema, MethodTraceSchema, MethodTraceStreamChunkSchema, MethodTraceStructuredErrorSchema, } from "./lib/schema.js";
+export { nativeExecutionBackendKind, } from "./adapters.js";
+export { createRunEventId, createRunEventTimestamp, nullRunEventSink, parseInterfRunEvent, } from "./events.js";