@interf/compiler 0.22.0 → 0.33.0

package/dist/packages/{engine → runtime}/connection-config.js

@@ -2,18 +2,19 @@
  * 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.
+ * starting `interf runtime` (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";
+import { connectionConfigPath, interfHomeRoot } from "../contracts/lib/project-paths.js";
 export const ConnectionRecordSchema = z.object({
     url: z.string().url(),
-    /** Bearer token for non-loopback connections. Null for loopback. */
+    /** Bearer token for token-required local or remote instances. Null only for explicit tokenless dev/test instances. */
     auth_token: z.string().min(1).nullable().default(null),
 }).strict();
 export const INTERF_SERVICE_URL_ENV = "INTERF_SERVICE_URL";
@@ -57,8 +58,8 @@ export function readActiveConnection(options = {}) {
 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`);
+    mkdirSync(dirname(configPath), { recursive: true, mode: 0o700 });
+    writeFileSync(configPath, `${JSON.stringify(validated, null, 2)}\n`, { mode: 0o600 });
 }
 /** Clear the connection record. No-op if missing. */
 export function clearConnection() {
@@ -68,8 +69,8 @@ export function clearConnection() {
 }
 /** Ensure `~/.interf/` exists and is a directory. */
 export function ensureInterfHome() {
-    mkdirSync(interfHomeRoot(), { recursive: true });
+    mkdirSync(interfHomeRoot(), { recursive: true, mode: 0o700 });
 }
 /** 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 `interf web start`, or set --url / `interf login` for a remote one.";
+    "Start one with `interf runtime` or `interf runtime start`, or set --url / `interf login` for a remote one.";

package/dist/packages/runtime/context-checks.d.ts

@@ -0,0 +1,10 @@
+import { type Artifact, type ArtifactStatus, type ContextCheck } from "../contracts/lib/schema.js";
+import type { BuildPlanAuthoringBrief } from "../build-plans/authoring/brief.js";
+export declare function buildPlanContextChecks(input: {
+    brief?: BuildPlanAuthoringBrief | null;
+    artifacts: readonly Artifact[];
+}): ContextCheck[];
+export declare function projectContextChecksForRun(input: {
+    contextChecks: readonly ContextCheck[];
+    artifactStatuses: readonly ArtifactStatus[];
+}): ContextCheck[];

package/dist/packages/runtime/context-checks.js

@@ -0,0 +1,114 @@
+import { ContextCheckSchema, } from "../contracts/lib/schema.js";
+import { slugify } from "../contracts/utils/naming.js";
+function boundedContextCheckId(value, fallback) {
+    const normalized = slugify(value) || fallback;
+    if (normalized.length <= 80)
+        return normalized;
+    return normalized.slice(0, 80).replace(/-+$/g, "") || fallback;
+}
+function uniqueContextCheckId(value, used) {
+    const base = boundedContextCheckId(value, "context-check");
+    if (!used.has(base)) {
+        used.add(base);
+        return base;
+    }
+    for (let index = 2; index < 1000; index += 1) {
+        const suffix = `-${index}`;
+        const candidate = `${base.slice(0, 80 - suffix.length).replace(/-+$/g, "")}${suffix}`;
+        if (!used.has(candidate)) {
+            used.add(candidate);
+            return candidate;
+        }
+    }
+    throw new Error(`Could not allocate a unique Context Check id for ${value}.`);
+}
+function contextCheckId(check, index, used) {
+    return uniqueContextCheckId(check.id ?? check.label ?? `context-check-${index + 1}`, used);
+}
+function derivedContextCheckForArtifact(artifact, used) {
+    const firstCheck = artifact.checks.find((check) => check.required !== false) ?? artifact.checks[0] ?? null;
+    return ContextCheckSchema.parse({
+        id: uniqueContextCheckId(`artifact-${artifact.id}`, used),
+        label: firstCheck?.description ?? artifact.description,
+        backed_by_artifact_ids: [artifact.id],
+        required: firstCheck?.required ?? true,
+        evidence_expectation: artifact.description,
+    });
+}
+export function buildPlanContextChecks(input) {
+    const authoredChecks = input.brief?.checks ?? [];
+    const used = new Set();
+    if (authoredChecks.length > 0) {
+        return authoredChecks.map((check, index) => ContextCheckSchema.parse({
+            id: contextCheckId(check, index, used),
+            label: check.label,
+            ...(check.description ? { description: check.description } : {}),
+            backed_by_artifact_ids: check.backed_by_artifact_ids,
+            required: check.required,
+            ...(check.evidence_expectation ?? check.evidence
+                ? { evidence_expectation: check.evidence_expectation ?? check.evidence }
+                : {}),
+        }));
+    }
+    return input.artifacts.map((artifact) => derivedContextCheckForArtifact(artifact, used));
+}
+function artifactStatusMap(statuses) {
+    return new Map(statuses.map((status) => [status.artifact_id, status]));
+}
+function statusForBackedArtifacts(statuses) {
+    if (statuses.length === 0)
+        return "pending";
+    if (statuses.some((status) => status.status === "failed"))
+        return "failed";
+    if (statuses.some((status) => status.status === "not_ready"))
+        return "pending";
+    if (statuses.every((status) => status.status === "ready"))
+        return "passed";
+    if (statuses.every((status) => status.status === "skipped"))
+        return "skipped";
+    return "pending";
+}
+function firstIssue(statuses) {
+    for (const status of statuses) {
+        const failedCheck = status.check_results.find((result) => result.required !== false && !result.passed);
+        if (failedCheck)
+            return failedCheck.summary;
+        if (status.status === "failed" && status.summary)
+            return status.summary;
+    }
+    return null;
+}
+function evidenceSummary(check, statuses) {
+    const ready = statuses.filter((status) => status.status === "ready").length;
+    if (statuses.length > 0 && ready === statuses.length) {
+        return check.evidence_expectation ?? `${ready}/${statuses.length} backed Artifact${statuses.length === 1 ? "" : "s"} accepted.`;
+    }
+    return null;
+}
+export function projectContextChecksForRun(input) {
+    const statusesByArtifact = artifactStatusMap(input.artifactStatuses);
+    return input.contextChecks.map((check) => {
+        const missingArtifactIds = check.backed_by_artifact_ids
+            .filter((artifactId) => !statusesByArtifact.has(artifactId));
+        const backedStatuses = check.backed_by_artifact_ids
+            .map((artifactId) => statusesByArtifact.get(artifactId) ?? null)
+            .filter((status) => status !== null);
+        const checkStatuses = backedStatuses;
+        const status = statusForBackedArtifacts(checkStatuses);
+        const issue = check.backed_by_artifact_ids.length === 0
+            ? "Context Check is not backed by a requested Artifact."
+            : missingArtifactIds.length > 0
+                ? `Context Check references missing requested Artifact${missingArtifactIds.length === 1 ? "" : "s"}: ${missingArtifactIds.join(", ")}.`
+                : status === "failed" ? firstIssue(checkStatuses) : null;
+        const projectedStatus = issue && check.required !== false
+            ? "failed"
+            : status;
+        const evidence = projectedStatus === "passed" ? evidenceSummary(check, checkStatuses) : null;
+        return ContextCheckSchema.parse({
+            ...check,
+            status: projectedStatus,
+            ...(evidence ? { evidence } : {}),
+            ...(issue ? { issue } : {}),
+        });
+    });
+}

package/dist/packages/runtime/context-graph-scaffold.d.ts

@@ -0,0 +1,9 @@
+export declare function ensureContextGraphScaffold(projectDataDir: string, projectName: string, buildPlanId?: string): string;
+export declare function ensureContextGraphScaffoldAt(options: {
+    projectDataDir: string;
+    contextGraphPath: string;
+    projectName: string;
+    buildPlanId?: string;
+}): string;
+export declare function createContextGraph(name: string, projectDataDir: string, buildPlanId: string | undefined, sourceFolderPath: string): string;
+export declare function defaultContextGraphNameForSource(projectDataDir: string): string;

package/dist/packages/runtime/context-graph-scaffold.js

@@ -0,0 +1,134 @@
+import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
+import { basename, join, relative, sep } from "node:path";
+import { getBuildPlan } from "../build-plans/package/build-plan-definitions.js";
+import { loadBuildPlanDefinitionFromDir, seedLocalDefaultBuildPlan } from "../build-plans/package/local-build-plans.js";
+import { initializeBuildRuntimeState, } from "./build/state.js";
+import { refreshContextGraphBootstrapGuidance } from "./agents/lib/context-graph-bootstrap.js";
+import { assertContextGraphContainer, assertContextGraphName, } from "../projects/interf-detect.js";
+import { seedContextGraphBuildPlanPackage } from "../build-plans/package/interf-build-plan-package.js";
+import { asProjectDataDir, projectContextGraphPath, } from "../contracts/lib/project-paths.js";
+import { ensureBuildPlanArtifactTargets, listBuildPlanContextArtifacts, readBuildPlanContextFile } from "./build/context-graph-schema.js";
+import { findProjectConfig, loadSourceFolderConfig, buildPlanIdForProjectConfig, resolveProjectSourceBindingPath, saveContextGraphInterfConfig, } from "../projects/source-config.js";
+import { defaultControlPathForContextGraph, testRootForContextGraph, buildPlanPackagePathForContextGraph } from "./build/context-graph-paths.js";
+import { DEFAULT_BUILD_PLAN_ID } from "../build-plans/build-plan-resolution.js";
+const DEFAULT_INTERFIGNORE = [
+    ".claude/",
+    ".codex/",
+    ".agents/",
+    ".cursor/",
+    ".interf/tests/",
+    ".interf/tests/targets/sandboxes/",
+    ".interf/runtime/",
+    "",
+].join("\n");
+const UNBUILT_CONTEXT_GRAPH_PLACEHOLDER = "Not yet built. Run `interf build` to build this Context Graph.";
+function renderUnbuiltContextGraphFile(contextGraphName, relativePath) {
+    return [
+        `# ${contextGraphName} — ${relativePath}`,
+        "",
+        UNBUILT_CONTEXT_GRAPH_PLACEHOLDER,
+        "",
+    ].join("\n");
+}
+function contextGraphGitignoreEntries(contextGraphPath) {
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForContextGraph(contextGraphPath));
+    const artifactEntries = (schema ? listBuildPlanContextArtifacts(schema) : [])
+        .map((artifact) => artifact.kind === "file" ? artifact.path : `${artifact.path}/`);
+    return [
+        ...artifactEntries,
+        ".claude/",
+        ".codex/",
+        ".agents/",
+        ".cursor/",
+        ".interf/tests/",
+        ".interf/tests/targets/sandboxes/",
+        ".interf/runtime/",
+    ];
+}
+function scaffoldContextGraphOutputs(contextGraphPath, contextGraphName) {
+    const schema = readBuildPlanContextFile(buildPlanPackagePathForContextGraph(contextGraphPath));
+    if (!schema) {
+        throw new Error(`Missing Build Plan schema at ${buildPlanPackagePathForContextGraph(contextGraphPath)}.`);
+    }
+    ensureBuildPlanArtifactTargets(contextGraphPath, schema);
+    for (const artifact of listBuildPlanContextArtifacts(schema)) {
+        if (!artifact.required || artifact.kind !== "file")
+            continue;
+        const targetPath = join(contextGraphPath, artifact.path);
+        if (existsSync(targetPath))
+            continue;
+        writeFileSync(targetPath, renderUnbuiltContextGraphFile(contextGraphName, artifact.path));
+    }
+}
+function localBuildPlanMatches(contextGraphPath, buildPlanId) {
+    const localBuildPlan = loadBuildPlanDefinitionFromDir(buildPlanPackagePathForContextGraph(contextGraphPath));
+    return localBuildPlan?.id === buildPlanId;
+}
+export function ensureContextGraphScaffold(projectDataDir, projectName, buildPlanId = DEFAULT_BUILD_PLAN_ID) {
+    const contextGraphPath = projectContextGraphPath(asProjectDataDir(projectDataDir), projectName);
+    return ensureContextGraphScaffoldAt({
+        projectDataDir,
+        contextGraphPath,
+        projectName,
+        buildPlanId,
+    });
+}
+export function ensureContextGraphScaffoldAt(options) {
+    const { projectDataDir, contextGraphPath, projectName, buildPlanId = DEFAULT_BUILD_PLAN_ID, } = options;
+    assertContextGraphName(projectName, "Context Graph");
+    assertContextGraphContainer(projectDataDir);
+    mkdirSync(contextGraphPath, { recursive: true });
+    mkdirSync(testRootForContextGraph(contextGraphPath), { recursive: true });
+    if (buildPlanId === "interf-default") {
+        seedLocalDefaultBuildPlan({ projectDataDir });
+    }
+    const selectedBuildPlan = getBuildPlan(buildPlanId, { projectDataDir });
+    if (!localBuildPlanMatches(contextGraphPath, selectedBuildPlan.id)) {
+        seedContextGraphBuildPlanPackage({
+            contextGraphPath,
+            projectDataDir,
+            buildPlanId: selectedBuildPlan.id,
+        });
+    }
+    if (!existsSync(join(contextGraphPath, ".gitignore"))) {
+        writeFileSync(join(contextGraphPath, ".gitignore"), [...contextGraphGitignoreEntries(contextGraphPath), ""].join("\n"));
+    }
+    return contextGraphPath;
+}
+export function createContextGraph(name, projectDataDir, buildPlanId = DEFAULT_BUILD_PLAN_ID, sourceFolderPath) {
+    assertContextGraphName(name, "Context Graph");
+    if (!sourceFolderPath || typeof sourceFolderPath !== "string") {
+        throw new Error("createContextGraph requires an explicit sourceFolderPath. Pass the absolute Source Folder path the Context Graph binds to.");
+    }
+    const savedProject = findProjectConfig(loadSourceFolderConfig(projectDataDir), name);
+    const effectiveBuildPlanId = buildPlanIdForProjectConfig(savedProject) ?? buildPlanId;
+    const selectedBuildPlan = getBuildPlan(effectiveBuildPlanId, { projectDataDir });
+    const contextGraphPath = ensureContextGraphScaffold(projectDataDir, name, selectedBuildPlan.id);
+    const resolvedSourceFolderPath = savedProject
+        ? resolveProjectSourceBindingPath(projectDataDir, savedProject)
+        : sourceFolderPath;
+    const sourceRelativePath = relative(contextGraphPath, resolvedSourceFolderPath).split(sep).join("/") || ".";
+    saveContextGraphInterfConfig(contextGraphPath, {
+        type: "context-graph",
+        name,
+        build_plan: selectedBuildPlan.id,
+        build_plan_origin: {
+            selected: selectedBuildPlan.id,
+            local_draft: false,
+        },
+        source: {
+            path: sourceRelativePath,
+            control_path: defaultControlPathForContextGraph(contextGraphPath),
+            project_path: sourceRelativePath,
+        },
+    });
+    writeFileSync(join(contextGraphPath, ".interfignore"), DEFAULT_INTERFIGNORE);
+    scaffoldContextGraphOutputs(contextGraphPath, name);
+    refreshContextGraphBootstrapGuidance(contextGraphPath);
+    writeFileSync(join(contextGraphPath, ".gitignore"), [...contextGraphGitignoreEntries(contextGraphPath), ""].join("\n"));
+    initializeBuildRuntimeState(contextGraphPath);
+    return contextGraphPath;
+}
+export function defaultContextGraphNameForSource(projectDataDir) {
+    return basename(projectDataDir);
+}

package/dist/packages/runtime/entitlement-guard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Entitlement guard.
+ *
+ * Enforces Pro feature gates + Free-tier limits. The Free 10-Project cap is
+ * the conversion lever; per the locked strategy, hitting it returns 402
+ * with an upgrade hint (no soft-archive — honest UX).
+ *
+ * Gating uses the `CurrentAccount.entitlements` block. Anonymous / pre-auth
+ * sessions are treated as Free.
+ */
+import type { CurrentAccount } from "./auth/account-context.js";
+export declare class EntitlementError extends Error {
+    readonly httpStatus = 402;
+    readonly upgradeHint: string;
+    constructor(message: string, upgradeHint: string);
+}
+/**
+ * Hard-reject a Project create when the account has reached its cap. Throws
+ * `EntitlementError` (status 402) with an upgrade hint.
+ *
+ * `activeProjectCount` is the count the runtime sees *before* the new
+ * Project is created. Pass the count of existing active Projects on disk.
+ */
+export declare function assertCanCreateProject(account: CurrentAccount | null, activeProjectCount: number): void;
+/**
+ * Require a specific Pro feature. Throws `EntitlementError` if the current
+ * account does not have access. Use to gate Pro-only routes (multi-source
+ * per Project, scheduled resyncs, benchmarking-unlimited, etc.).
+ */
+export declare function requireEntitlement(account: CurrentAccount | null, feature: string): void;
+/** Boolean check — does the current account have the feature? */
+export declare function hasEntitlement(account: CurrentAccount | null, feature: string): boolean;
+/** Free-tier benchmark quota: one verify run per Project, ever. */
+export declare const FREE_BENCHMARK_RUN_LIMIT = 1;
+/**
+ * Gate a benchmark verify-run creation. Pro (`benchmarking-unlimited`) is
+ * unbounded. Free / anonymous are capped at `FREE_BENCHMARK_RUN_LIMIT` runs
+ * per Project, lifetime.
+ *
+ * `existingRunCount` is the count of verify runs on disk for this Project
+ * *before* the new run is created.
+ */
+export declare function assertCanRunBenchmark(account: CurrentAccount | null, existingRunCount: number): void;

package/dist/packages/runtime/entitlement-guard.js

@@ -0,0 +1,70 @@
+/**
+ * Entitlement guard.
+ *
+ * Enforces Pro feature gates + Free-tier limits. The Free 10-Project cap is
+ * the conversion lever; per the locked strategy, hitting it returns 402
+ * with an upgrade hint (no soft-archive — honest UX).
+ *
+ * Gating uses the `CurrentAccount.entitlements` block. Anonymous / pre-auth
+ * sessions are treated as Free.
+ */
+import { TIER_ENTITLEMENTS, } from "./auth/account-context.js";
+export class EntitlementError extends Error {
+    httpStatus = 402;
+    upgradeHint;
+    constructor(message, upgradeHint) {
+        super(message);
+        this.name = "EntitlementError";
+        this.upgradeHint = upgradeHint;
+    }
+}
+function entitlementsOf(account) {
+    if (!account)
+        return TIER_ENTITLEMENTS.anonymous;
+    return account.entitlements;
+}
+/**
+ * Hard-reject a Project create when the account has reached its cap. Throws
+ * `EntitlementError` (status 402) with an upgrade hint.
+ *
+ * `activeProjectCount` is the count the runtime sees *before* the new
+ * Project is created. Pass the count of existing active Projects on disk.
+ */
+export function assertCanCreateProject(account, activeProjectCount) {
+    const ent = entitlementsOf(account);
+    if (activeProjectCount < ent.max_active_projects)
+        return;
+    throw new EntitlementError(`Project cap reached (${activeProjectCount} of ${ent.max_active_projects}). Upgrade to Pro for unlimited Projects, or delete an existing Project first.`, "https://interf.com/pricing");
+}
+/**
+ * Require a specific Pro feature. Throws `EntitlementError` if the current
+ * account does not have access. Use to gate Pro-only routes (multi-source
+ * per Project, scheduled resyncs, benchmarking-unlimited, etc.).
+ */
+export function requireEntitlement(account, feature) {
+    const ent = entitlementsOf(account);
+    if (ent.pro_features.includes(feature))
+        return;
+    throw new EntitlementError(`Pro feature required: ${feature}. Upgrade your plan to unlock.`, "https://interf.com/pricing");
+}
+/** Boolean check — does the current account have the feature? */
+export function hasEntitlement(account, feature) {
+    return entitlementsOf(account).pro_features.includes(feature);
+}
+/** Free-tier benchmark quota: one verify run per Project, ever. */
+export const FREE_BENCHMARK_RUN_LIMIT = 1;
+/**
+ * Gate a benchmark verify-run creation. Pro (`benchmarking-unlimited`) is
+ * unbounded. Free / anonymous are capped at `FREE_BENCHMARK_RUN_LIMIT` runs
+ * per Project, lifetime.
+ *
+ * `existingRunCount` is the count of verify runs on disk for this Project
+ * *before* the new run is created.
+ */
+export function assertCanRunBenchmark(account, existingRunCount) {
+    if (hasEntitlement(account, "benchmarking-unlimited"))
+        return;
+    if (existingRunCount < FREE_BENCHMARK_RUN_LIMIT)
+        return;
+    throw new EntitlementError(`Free tier limit reached: ${existingRunCount} of ${FREE_BENCHMARK_RUN_LIMIT} benchmark${FREE_BENCHMARK_RUN_LIMIT === 1 ? "" : "s"} used for this Project. Upgrade to Pro for more Project activity history, benchmark/evaluation runs, and self-improving Build Plan loops.`, "https://interf.com/pricing");
+}

package/dist/packages/{engine → runtime}/execution/index.d.ts

@@ -1,8 +1,8 @@
 export * as schema from "./lib/schema.js";
 export * as events from "./events.js";
 export * as adapters from "./adapters.js";
-export type { ArtifactRef, ArtifactRole, BuildRun, BuildRunStatus, ExecutionBackendKind, InterfRunEvent, ObservableRunMetric, ObservableRunStatus, ObservableRunType, ProofCheck, ProofRecord, RunObservability, StageRun, StageRunContract, StageRunLogs, StageRunStatus, RunTrace, RunTraceEvent, RunTraceEventType, RunTraceRun, RunTraceRunStatus, RunTraceStreamChunk, RunTraceStructuredError, } from "./lib/schema.js";
-export { ArtifactRefSchema, ArtifactRoleSchema, BuildRunSchema, BuildRunStatusSchema, ExecutionBackendKindSchema, InterfRunEventSchema, LogAppendedEventSchema, ObservableRunMetricSchema, ObservableRunStatusSchema, ObservableRunTypeSchema, ProofCheckSchema, ProofRecordSchema, RunObservabilitySchema, StageRunSchema, StageRunContractSchema, StageRunLogsSchema, StageRunStatusSchema, RunTraceEventSchema, RunTraceEventTypeSchema, RunTraceRunSchema, RunTraceRunStatusSchema, RunTraceSchema, RunTraceStreamChunkSchema, RunTraceStructuredErrorSchema, } from "./lib/schema.js";
+export type { ArtifactRef, ArtifactRole, BuildRun, BuildRunStatus, ExecutionBackendKind, InterfRunEvent, ObservableRunMetric, ObservableRunStatus, ObservableRunType, RunCheck, EvidenceRecord, RunObservability, StageRun, StageRunContract, StageRunLogs, StageRunStatus, RunTrace, RunTraceEvent, RunTraceEventType, RunTraceRun, RunTraceRunStatus, RunTraceStreamChunk, RunTraceStructuredError, } from "./lib/schema.js";
+export { ArtifactRefSchema, ArtifactRoleSchema, BuildRunSchema, BuildRunStatusSchema, ExecutionBackendKindSchema, InterfRunEventSchema, LogAppendedEventSchema, ObservableRunMetricSchema, ObservableRunStatusSchema, ObservableRunTypeSchema, RunCheckSchema, EvidenceRecordSchema, RunObservabilitySchema, StageRunSchema, StageRunContractSchema, StageRunLogsSchema, StageRunStatusSchema, RunTraceEventSchema, RunTraceEventTypeSchema, RunTraceRunSchema, RunTraceRunStatusSchema, RunTraceSchema, RunTraceStreamChunkSchema, RunTraceStructuredErrorSchema, } from "./lib/schema.js";
 export type { ExecutionAdapter, ExecutionAdapterContext, ExecutionEventRecorder, } from "./adapters.js";
 export { nativeExecutionBackendKind, } from "./adapters.js";
 export type { RunEventSink, } from "./events.js";

package/dist/packages/{engine → runtime}/execution/index.js

@@ -1,6 +1,6 @@
 export * as schema from "./lib/schema.js";
 export * as events from "./events.js";
 export * as adapters from "./adapters.js";
-export { ArtifactRefSchema, ArtifactRoleSchema, BuildRunSchema, BuildRunStatusSchema, ExecutionBackendKindSchema, InterfRunEventSchema, LogAppendedEventSchema, ObservableRunMetricSchema, ObservableRunStatusSchema, ObservableRunTypeSchema, ProofCheckSchema, ProofRecordSchema, RunObservabilitySchema, StageRunSchema, StageRunContractSchema, StageRunLogsSchema, StageRunStatusSchema, RunTraceEventSchema, RunTraceEventTypeSchema, RunTraceRunSchema, RunTraceRunStatusSchema, RunTraceSchema, RunTraceStreamChunkSchema, RunTraceStructuredErrorSchema, } from "./lib/schema.js";
+export { ArtifactRefSchema, ArtifactRoleSchema, BuildRunSchema, BuildRunStatusSchema, ExecutionBackendKindSchema, InterfRunEventSchema, LogAppendedEventSchema, ObservableRunMetricSchema, ObservableRunStatusSchema, ObservableRunTypeSchema, RunCheckSchema, EvidenceRecordSchema, RunObservabilitySchema, StageRunSchema, StageRunContractSchema, StageRunLogsSchema, StageRunStatusSchema, RunTraceEventSchema, RunTraceEventTypeSchema, RunTraceRunSchema, RunTraceRunStatusSchema, RunTraceSchema, RunTraceStreamChunkSchema, RunTraceStructuredErrorSchema, } from "./lib/schema.js";
 export { nativeExecutionBackendKind, } from "./adapters.js";
 export { createRunEventId, createRunEventTimestamp, nullRunEventSink, parseInterfRunEvent, } from "./events.js";