@interf/compiler 0.22.2 → 0.50.0

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

@@ -0,0 +1,416 @@
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, extname, join, posix } from "node:path";
+import { parseJsonFrontmatter } from "../contracts/utils/parse.js";
+import { knowledgeNoteKind, layerForPath, normalizeLayerPath, } from "../contracts/lib/context-graph-layer.js";
+import { ContextGraphSemanticGraphSchema, } from "./schemas/index.js";
+// Upper bound on markdown notes rendered into the semantic graph. This is a
+// pathological-input guard, NOT a display budget: it must comfortably exceed a
+// realistic Context Graph's note count so the canvas renders the WHOLE graph and
+// agrees with the GraphManifest node count, instead of truncating to the first
+// N alphabetical notes and showing a different, smaller graph than readiness
+// counted. The old value (180) silently dropped the bulk of a ~500-note graph —
+// turning real, connected content into off-canvas "islands". A real Context
+// Graph stays well under this ceiling; only a runaway build approaches it.
+const MAX_MARKDOWN_NOTES = 5000;
+const WIKILINK_PATTERN = /\[\[([^\]\n]+)\]\]/g;
+const MARKDOWN_LINK_PATTERN = /!?\[[^\]\n]*\]\(([^)\n]+)\)/g;
+function shortHash(value, length = 16) {
+    return createHash("sha256")
+        .update(value)
+        .digest("hex")
+        .slice(0, length);
+}
+function noteKey(value) {
+    return normalizeLayerPath(value)
+        .replace(/\.md$/i, "")
+        .trim()
+        .toLowerCase();
+}
+function slugKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/['"]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function withoutMarkdownExtension(path) {
+    return path.replace(/\.md$/i, "");
+}
+function markdownBasename(path) {
+    return basename(path, extname(path));
+}
+function addGraphFile(files, contextGraphPath, relativePath) {
+    const absolutePath = join(contextGraphPath, relativePath);
+    if (!existsSync(absolutePath) || !statSync(absolutePath).isFile())
+        return;
+    if (!relativePath.toLowerCase().endsWith(".md"))
+        return;
+    files.push(normalizeLayerPath(relativePath));
+}
+function collectMarkdownFiles(files, contextGraphPath, relativeDir) {
+    const absoluteDir = join(contextGraphPath, relativeDir);
+    if (!existsSync(absoluteDir) || !statSync(absoluteDir).isDirectory())
+        return;
+    const entries = readdirSync(absoluteDir, { withFileTypes: true })
+        .sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        const relativePath = normalizeLayerPath(join(relativeDir, entry.name));
+        if (entry.isDirectory()) {
+            collectMarkdownFiles(files, contextGraphPath, relativePath);
+            continue;
+        }
+        if (entry.isFile())
+            addGraphFile(files, contextGraphPath, relativePath);
+    }
+}
+function listMarkdownFiles(contextGraphPath) {
+    const files = [];
+    collectMarkdownFiles(files, contextGraphPath, ".");
+    return Array.from(new Set(files)).slice(0, MAX_MARKDOWN_NOTES);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringValues(value) {
+    if (Array.isArray(value))
+        return value.flatMap((item) => stringValues(item));
+    if (typeof value === "string")
+        return value.trim().length > 0 ? [value.trim()] : [];
+    if (value && typeof value === "object") {
+        const record = value;
+        return [
+            stringValue(record.path),
+            stringValue(record.locator),
+            stringValue(record.source_path),
+            stringValue(record.ref),
+            stringValue(record.summary),
+        ].filter((item) => Boolean(item));
+    }
+    return [];
+}
+function sourceRefsFromFrontmatter(frontmatter) {
+    return Array.from(new Set([
+        ...stringValues(frontmatter.source_refs),
+        ...stringValues(frontmatter.source_ref),
+        ...stringValues(frontmatter.source_path),
+    ]));
+}
+function aliasesFromFrontmatter(frontmatter) {
+    return Array.from(new Set([
+        stringValue(frontmatter.title),
+        stringValue(frontmatter.label),
+        stringValue(frontmatter.alias),
+        ...stringValues(frontmatter.aliases),
+    ].filter((item) => Boolean(item))));
+}
+function firstHeading(body) {
+    const heading = body.split("\n").find((line) => /^#{1,3}\s+\S/.test(line));
+    return heading ? heading.replace(/^#{1,3}\s+/, "").trim() : null;
+}
+function firstParagraph(body) {
+    const paragraph = body
+        .split(/\n\s*\n/)
+        .map((block) => block.replace(/\s+/g, " ").trim())
+        .find((block) => block.length > 0 && !block.startsWith("#"));
+    if (!paragraph)
+        return null;
+    return paragraph.length > 180 ? `${paragraph.slice(0, 177)}...` : paragraph;
+}
+function inferNoteKind(path) {
+    // Layer (home / artifact / summary / knowledge) and the knowledge
+    // claim·entity·index sub-kind come from the central `context-graph-layer`
+    // module, the single owner of the `knowledge/claims/` / `claim-` conventions,
+    // so this classifier and the StageManifest one can never drift. The only
+    // semantic-graph-specific refinement kept local is the loose "leaf merely
+    // contains `index`" nicety; the central module deliberately excludes it.
+    const layer = layerForPath(path);
+    if (layer === "home")
+        return "home";
+    if (layer === "artifacts")
+        return "artifact";
+    if (layer === "summaries")
+        return "summary";
+    const knowledgeKind = knowledgeNoteKind(path);
+    if (knowledgeKind === "claim")
+        return "claim";
+    if (knowledgeKind === "entity")
+        return "entity";
+    if (knowledgeKind === "index" || markdownBasename(normalizeLayerPath(path)).includes("index"))
+        return "index";
+    if (layer === "knowledge")
+        return "knowledge";
+    return "note";
+}
+function noteLabel(path, frontmatter, body) {
+    const leaf = markdownBasename(path);
+    const title = stringValue(frontmatter.title) ?? stringValue(frontmatter.label) ?? firstHeading(body);
+    return title && title.length <= 48 ? title : leaf;
+}
+function noteSummary(label, frontmatter, body) {
+    const explicit = stringValue(frontmatter.summary) ?? stringValue(frontmatter.abstract) ?? stringValue(frontmatter.description);
+    if (explicit)
+        return explicit.length > 220 ? `${explicit.slice(0, 217)}...` : explicit;
+    const title = stringValue(frontmatter.title) ?? firstHeading(body);
+    if (title && title !== label)
+        return title;
+    return firstParagraph(body);
+}
+function parseWikilinks(content) {
+    const links = [];
+    for (const match of content.matchAll(WIKILINK_PATTERN)) {
+        const raw = match[1]?.split("|")[0]?.split("#")[0]?.trim();
+        if (raw)
+            links.push(raw);
+    }
+    return Array.from(new Set(links));
+}
+function parseMarkdownLinks(content) {
+    const links = [];
+    for (const match of content.matchAll(MARKDOWN_LINK_PATTERN)) {
+        const raw = match[1]?.split("#")[0]?.trim();
+        if (!raw || /^https?:\/\//i.test(raw))
+            continue;
+        if (!raw.toLowerCase().endsWith(".md"))
+            continue;
+        try {
+            links.push(decodeURIComponent(raw));
+        }
+        catch {
+            links.push(raw);
+        }
+    }
+    return Array.from(new Set(links));
+}
+function parseNote(contextGraphPath, path) {
+    const content = readFileSync(join(contextGraphPath, path), "utf8");
+    const parsed = parseJsonFrontmatter(content);
+    const frontmatter = parsed?.frontmatter ?? {};
+    const body = parsed?.body ?? content;
+    const label = noteLabel(path, frontmatter, body);
+    return {
+        body,
+        id: `note:${path}`,
+        kind: inferNoteKind(path),
+        label,
+        path,
+        sourceRefs: sourceRefsFromFrontmatter(frontmatter),
+        summary: noteSummary(label, frontmatter, body),
+        aliases: aliasesFromFrontmatter(frontmatter),
+        wikilinks: Array.from(new Set([
+            ...parseWikilinks(content),
+            ...parseMarkdownLinks(content),
+        ])),
+    };
+}
+function addIndexTarget(index, key, nodeId) {
+    const normalized = noteKey(key);
+    if (normalized.length > 0 && !index.has(normalized))
+        index.set(normalized, nodeId);
+    const slug = slugKey(key);
+    if (slug.length > 0 && !index.has(slug))
+        index.set(slug, nodeId);
+}
+function buildNoteIndex(notes) {
+    const index = new Map();
+    for (const note of notes) {
+        addIndexTarget(index, note.path, note.id);
+        addIndexTarget(index, withoutMarkdownExtension(note.path), note.id);
+        addIndexTarget(index, markdownBasename(note.path), note.id);
+        if (note.path.endsWith("/summary.md")) {
+            addIndexTarget(index, withoutMarkdownExtension(note.path), note.id);
+        }
+        for (const alias of note.aliases)
+            addIndexTarget(index, alias, note.id);
+    }
+    return index;
+}
+function resolveWikilink(sourcePath, rawTarget, index) {
+    const clean = normalizeLayerPath(rawTarget);
+    const sourceDir = normalizeLayerPath(posix.dirname(sourcePath));
+    const relativeCandidate = normalizeLayerPath(posix.normalize(posix.join(sourceDir, clean)));
+    const candidates = [
+        clean,
+        withoutMarkdownExtension(clean),
+        relativeCandidate,
+        withoutMarkdownExtension(relativeCandidate),
+        markdownBasename(clean),
+    ];
+    for (const candidate of candidates) {
+        const match = index.get(noteKey(candidate)) ?? index.get(slugKey(candidate));
+        if (match)
+            return match;
+    }
+    return null;
+}
+function sourceLabel(ref, matchedFile) {
+    if (matchedFile)
+        return matchedFile.path;
+    const firstSegment = ref.split("›")[0]?.split("#")[0]?.trim() ?? ref;
+    if (/^https?:\/\//i.test(firstSegment)) {
+        try {
+            return new URL(firstSegment).hostname;
+        }
+        catch {
+            return firstSegment;
+        }
+    }
+    return firstSegment.length > 64 ? `${firstSegment.slice(0, 61)}...` : firstSegment;
+}
+function findSourceFile(ref, sourceManifest) {
+    const files = sourceManifest?.files ?? [];
+    const lowerRef = ref.toLowerCase();
+    return files.find((file) => {
+        const path = file.path.toLowerCase();
+        const leaf = basename(file.path).toLowerCase();
+        return lowerRef === path || lowerRef.startsWith(path) || lowerRef.includes(path) || lowerRef.includes(leaf);
+    }) ?? null;
+}
+function addNode(nodes, node) {
+    if (!nodes.has(node.id))
+        nodes.set(node.id, node);
+}
+function addEdge(edges, edge) {
+    if (!edges.has(edge.id))
+        edges.set(edge.id, edge);
+}
+function sourceNodeId(ref, matchedFile) {
+    return `source:${shortHash(matchedFile?.path ?? ref)}`;
+}
+function degreeCounts(edges) {
+    const links = new Map();
+    const backlinks = new Map();
+    for (const edge of edges) {
+        links.set(edge.source, (links.get(edge.source) ?? 0) + 1);
+        backlinks.set(edge.target, (backlinks.get(edge.target) ?? 0) + 1);
+    }
+    return { backlinks, links };
+}
+export function buildContextGraphSemanticGraph(options) {
+    const generatedAt = options.generatedAt ?? new Date().toISOString();
+    if (!existsSync(options.contextGraphPath)) {
+        return ContextGraphSemanticGraphSchema.parse({
+            kind: "interf-context-graph-semantic-graph",
+            version: 1,
+            generated_at: generatedAt,
+            nodes: [],
+            edges: [],
+            stats: { notes: 0, links: 0, source_refs: 0, unresolved_links: 0 },
+        });
+    }
+    const notes = listMarkdownFiles(options.contextGraphPath).map((path) => parseNote(options.contextGraphPath, path));
+    const noteIndex = buildNoteIndex(notes);
+    const nodes = new Map();
+    const edges = new Map();
+    const projectNodeId = `project:${options.projectId}`;
+    addNode(nodes, {
+        id: projectNodeId,
+        kind: "project",
+        label: options.projectId,
+        path: options.contextGraphPath,
+        summary: "Latest Context Graph root.",
+        source_refs: [],
+        link_count: 0,
+        backlink_count: 0,
+    });
+    for (const note of notes) {
+        addNode(nodes, {
+            id: note.id,
+            kind: note.kind,
+            label: note.label,
+            path: note.path,
+            summary: note.summary,
+            source_refs: note.sourceRefs,
+            link_count: 0,
+            backlink_count: 0,
+        });
+    }
+    const home = notes.find((note) => note.kind === "home");
+    if (home) {
+        addEdge(edges, {
+            id: `${projectNodeId}->${home.id}:contains`,
+            kind: "contains",
+            source: projectNodeId,
+            target: home.id,
+            label: "contains",
+            detail: `${options.projectId} starts at ${home.path}.`,
+        });
+    }
+    if (options.entrypointPath) {
+        const entrypointId = noteIndex.get(noteKey(options.entrypointPath)) ?? noteIndex.get(noteKey(withoutMarkdownExtension(options.entrypointPath)));
+        if (entrypointId) {
+            addEdge(edges, {
+                id: `${projectNodeId}->${entrypointId}:handoff`,
+                kind: "handoff",
+                source: projectNodeId,
+                target: entrypointId,
+                label: "handoff",
+                detail: `${options.entrypointPath} is the primary downstream agent entrypoint.`,
+            });
+        }
+    }
+    let unresolvedLinks = 0;
+    for (const note of notes) {
+        for (const rawTarget of note.wikilinks) {
+            const targetId = resolveWikilink(note.path, rawTarget, noteIndex);
+            if (!targetId) {
+                unresolvedLinks += 1;
+                continue;
+            }
+            addEdge(edges, {
+                id: `${note.id}->${targetId}:links-to`,
+                kind: "links-to",
+                source: note.id,
+                target: targetId,
+                label: "links to",
+                detail: `${note.path} links to ${rawTarget}.`,
+            });
+        }
+        for (const ref of note.sourceRefs) {
+            const matchedFile = findSourceFile(ref, options.sourceManifest);
+            const id = sourceNodeId(ref, matchedFile);
+            const label = sourceLabel(ref, matchedFile);
+            addNode(nodes, {
+                id,
+                kind: "source",
+                label,
+                path: matchedFile?.locator ?? matchedFile?.path ?? null,
+                summary: ref,
+                source_refs: [ref],
+                link_count: 0,
+                backlink_count: 0,
+            });
+            addEdge(edges, {
+                id: `${note.id}->${id}:source-ref:${shortHash(ref, 10)}`,
+                kind: "source-ref",
+                source: note.id,
+                target: id,
+                label: "source ref",
+                detail: `${note.path} cites ${label}.`,
+            });
+        }
+    }
+    const edgeList = [...edges.values()];
+    const counts = degreeCounts(edgeList);
+    const nodeList = [...nodes.values()].map((node) => ({
+        ...node,
+        link_count: counts.links.get(node.id) ?? 0,
+        backlink_count: counts.backlinks.get(node.id) ?? 0,
+    }));
+    return ContextGraphSemanticGraphSchema.parse({
+        kind: "interf-context-graph-semantic-graph",
+        version: 1,
+        generated_at: generatedAt,
+        nodes: nodeList,
+        edges: edgeList,
+        stats: {
+            notes: notes.length,
+            links: edgeList.filter((edge) => edge.kind === "links-to").length,
+            source_refs: edgeList.filter((edge) => edge.kind === "source-ref").length,
+            unresolved_links: unresolvedLinks,
+        },
+    });
+}

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";