@xfey/tenso 0.1.130

package/dist/approvals/projections.js

@@ -0,0 +1,443 @@
+import { isAbsolute, relative, resolve } from "node:path";
+import { createApprovalRequestId } from "@tutti/shared/ids";
+import { redactText } from "@tutti/shared/utils";
+const MAX_TEXT_LENGTH = 500;
+const MAX_DETAIL_LENGTH = 180;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function compactText(value, maxLength) {
+    const normalized = value.replace(/\s+/gu, " ").trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength)}...`;
+}
+function underRoot(path, root) {
+    const relativePath = relative(root, path);
+    return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+function runtimeRoots(context) {
+    return [
+        { value: context.workspaceRoot ?? "", label: "workspace" },
+        { value: context.codexHome ?? "", label: "codex home" },
+        { value: context.tuttiHome ?? "", label: "tutti home" },
+        { value: context.builtInSkillsRoot ?? "", label: "built-in skills" },
+    ].filter((entry) => entry.value !== "");
+}
+function labelPath(value, context) {
+    const redacted = redactKnownValues(value, context);
+    if (!isAbsolute(value)) {
+        return compactText(redacted, MAX_DETAIL_LENGTH);
+    }
+    const resolved = resolve(value);
+    for (const root of runtimeRoots(context)) {
+        const resolvedRoot = resolve(root.value);
+        if (!underRoot(resolved, resolvedRoot)) {
+            continue;
+        }
+        const relativePath = relative(resolvedRoot, resolved);
+        return relativePath === ""
+            ? root.label
+            : `${root.label}/${relativePath.split(/[\\/]+/u).join("/")}`;
+    }
+    return "[REDACTED_PATH]";
+}
+function redactKnownValues(value, context) {
+    let redacted = redactText(value);
+    for (const root of runtimeRoots(context)) {
+        redacted = redacted.split(root.value).join(root.label);
+    }
+    for (const sensitiveValue of context.sensitiveValues ?? []) {
+        if (sensitiveValue !== "") {
+            redacted = redacted.split(sensitiveValue).join("[REDACTED]");
+        }
+    }
+    return redacted;
+}
+function safeText(value, context, maxLength = MAX_TEXT_LENGTH) {
+    return compactText(redactKnownValues(value, context), maxLength) || "[redacted]";
+}
+function commandText(value, context) {
+    if (typeof value === "string") {
+        return safeText(value, context);
+    }
+    if (Array.isArray(value)) {
+        const parts = value.filter((part) => typeof part === "string");
+        if (parts.length > 0) {
+            return safeText(parts.join(" "), context);
+        }
+    }
+    return undefined;
+}
+function reasonText(params, context) {
+    const reason = nonEmptyString(params.reason);
+    return reason === undefined ? undefined : safeText(reason, context, MAX_DETAIL_LENGTH);
+}
+function decisionOption(input) {
+    return {
+        projection: {
+            decision_id: input.decisionId,
+            kind: input.kind,
+            label: input.label,
+            tone: input.tone,
+        },
+        runtime: {
+            decisionId: input.decisionId,
+            label: input.label,
+            outcome: input.outcome,
+            response: input.response,
+        },
+    };
+}
+function requestedSimpleDecision(params, decision) {
+    if (!Array.isArray(params.availableDecisions)) {
+        return true;
+    }
+    return params.availableDecisions.includes(decision);
+}
+function commandDecisionOptions(params, legacy) {
+    const options = [
+        ...(requestedSimpleDecision(params, legacy ? "approved" : "accept")
+            ? [
+                decisionOption({
+                    decisionId: "allow_once",
+                    kind: "allow_once",
+                    label: "Allow once",
+                    tone: "primary",
+                    outcome: "accepted",
+                    response: {
+                        kind: "result",
+                        result: { decision: legacy ? "approved" : "accept" },
+                    },
+                }),
+            ]
+            : []),
+        ...(requestedSimpleDecision(params, legacy ? "approved_for_session" : "acceptForSession")
+            ? [
+                decisionOption({
+                    decisionId: "allow_session",
+                    kind: "allow_session",
+                    label: "Allow for session",
+                    tone: "neutral",
+                    outcome: "accepted",
+                    response: {
+                        kind: "result",
+                        result: { decision: legacy ? "approved_for_session" : "acceptForSession" },
+                    },
+                }),
+            ]
+            : []),
+        ...(requestedSimpleDecision(params, legacy ? "denied" : "decline")
+            ? [
+                decisionOption({
+                    decisionId: "deny",
+                    kind: "deny",
+                    label: "Deny",
+                    tone: "danger",
+                    outcome: "declined",
+                    response: {
+                        kind: "result",
+                        result: { decision: legacy ? "denied" : "decline" },
+                    },
+                }),
+            ]
+            : []),
+        ...(requestedSimpleDecision(params, legacy ? "abort" : "cancel")
+            ? [
+                decisionOption({
+                    decisionId: "cancel",
+                    kind: "cancel",
+                    label: "Cancel run",
+                    tone: "danger",
+                    outcome: "cancelled",
+                    response: {
+                        kind: "result",
+                        result: { decision: legacy ? "abort" : "cancel" },
+                    },
+                }),
+            ]
+            : []),
+    ];
+    return options.length === 0
+        ? [
+            decisionOption({
+                decisionId: "cancel",
+                kind: "cancel",
+                label: "Cancel run",
+                tone: "danger",
+                outcome: "cancelled",
+                response: {
+                    kind: "error",
+                    error: {
+                        code: "approval_cancelled",
+                        message: "Approval request was cancelled.",
+                    },
+                },
+            }),
+        ]
+        : options;
+}
+function permissionsDecisionOptions(permissions) {
+    return [
+        decisionOption({
+            decisionId: "allow_once",
+            kind: "allow_once",
+            label: "Allow once",
+            tone: "primary",
+            outcome: "accepted",
+            response: {
+                kind: "result",
+                result: { permissions, scope: "turn" },
+            },
+        }),
+        decisionOption({
+            decisionId: "allow_session",
+            kind: "allow_session",
+            label: "Allow for session",
+            tone: "neutral",
+            outcome: "accepted",
+            response: {
+                kind: "result",
+                result: { permissions, scope: "session" },
+            },
+        }),
+        decisionOption({
+            decisionId: "deny",
+            kind: "deny",
+            label: "Deny",
+            tone: "danger",
+            outcome: "declined",
+            response: {
+                kind: "error",
+                error: {
+                    code: "approval_declined",
+                    message: "Approval request was declined.",
+                },
+            },
+        }),
+        decisionOption({
+            decisionId: "cancel",
+            kind: "cancel",
+            label: "Cancel run",
+            tone: "danger",
+            outcome: "cancelled",
+            response: {
+                kind: "error",
+                error: {
+                    code: "approval_cancelled",
+                    message: "Approval request was cancelled.",
+                },
+            },
+        }),
+    ];
+}
+function decisionMap(options) {
+    return {
+        projections: options.map((option) => option.projection),
+        runtimes: new Map(options.map((option) => [option.runtime.decisionId, option.runtime])),
+    };
+}
+function commandActions(value, context) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const actions = value
+        .filter(isRecord)
+        .map((action) => {
+        const rawCommand = nonEmptyString(action.command);
+        const label = nonEmptyString(action.name) ??
+            nonEmptyString(action.type) ??
+            (rawCommand === undefined ? "Command action" : safeText(rawCommand, context, 80));
+        const rawDetail = nonEmptyString(action.path) ??
+            nonEmptyString(action.query) ??
+            (rawCommand === undefined ? undefined : safeText(rawCommand, context, MAX_DETAIL_LENGTH));
+        const detail = rawDetail === undefined
+            ? undefined
+            : action.path === rawDetail
+                ? labelPath(rawDetail, context)
+                : safeText(rawDetail, context, MAX_DETAIL_LENGTH);
+        return {
+            label: safeText(label, context, 80),
+            ...(detail === undefined ? {} : { detail }),
+        };
+    })
+        .slice(0, 6);
+    return actions.length === 0 ? undefined : actions;
+}
+function networkProjection(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const host = nonEmptyString(value.host);
+    const protocol = nonEmptyString(value.protocol);
+    if (host === undefined || protocol === undefined) {
+        return undefined;
+    }
+    return { host: redactText(host), protocol: redactText(protocol) };
+}
+function permissionsProjection(value, context) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const projection = {};
+    if (isRecord(value.network) && typeof value.network.enabled === "boolean") {
+        projection.network = { enabled: value.network.enabled };
+    }
+    if (isRecord(value.fileSystem)) {
+        const filesystem = {};
+        if (Array.isArray(value.fileSystem.read)) {
+            filesystem.read = value.fileSystem.read
+                .filter((item) => typeof item === "string" && item.trim() !== "")
+                .map((item) => labelPath(item, context))
+                .slice(0, 20);
+        }
+        if (Array.isArray(value.fileSystem.write)) {
+            filesystem.write = value.fileSystem.write
+                .filter((item) => typeof item === "string" && item.trim() !== "")
+                .map((item) => labelPath(item, context))
+                .slice(0, 20);
+        }
+        if (filesystem.read !== undefined || filesystem.write !== undefined) {
+            projection.filesystem = filesystem;
+        }
+    }
+    return projection.network === undefined && projection.filesystem === undefined
+        ? undefined
+        : projection;
+}
+function fileChangeProjection(params, context) {
+    const grantRoot = nonEmptyString(params.grantRoot);
+    const fileChanges = isRecord(params.fileChanges) ? Object.keys(params.fileChanges) : [];
+    const paths = fileChanges.map((path) => labelPath(path, context)).slice(0, 20);
+    if (grantRoot === undefined && paths.length === 0) {
+        return undefined;
+    }
+    return {
+        ...(grantRoot === undefined ? {} : { grant_root_label: labelPath(grantRoot, context) }),
+        ...(paths.length === 0 ? {} : { paths }),
+    };
+}
+function baseRequest(input) {
+    const request = {
+        approval_id: createApprovalRequestId(),
+        request_kind: input.kind,
+        title: input.title,
+        summary: input.summary,
+        requested_at: input.context.requestedAt,
+        decisions: input.decisions.projections,
+    };
+    const reason = reasonText(input.params, input.context);
+    if (reason !== undefined) {
+        request.reason = reason;
+    }
+    if (input.context.expiresAt !== undefined) {
+        request.expires_at = input.context.expiresAt;
+    }
+    if (input.context.taskId !== undefined) {
+        request.task_id = input.context.taskId;
+    }
+    if (input.context.activityRef !== undefined) {
+        request.activity_ref = input.context.activityRef;
+    }
+    return request;
+}
+function buildCommandApproval(input) {
+    if (!isRecord(input.request.params)) {
+        return null;
+    }
+    const params = input.request.params;
+    const text = commandText(params.command, input.context);
+    const decisions = decisionMap(commandDecisionOptions(params, input.legacy));
+    const request = baseRequest({
+        context: input.context,
+        kind: input.legacy ? "legacy_exec_command" : "command_execution",
+        title: "Approve command",
+        summary: text === undefined ? "Codex wants to run a command." : `Codex wants to run: ${text}`,
+        params,
+        decisions,
+    });
+    const cwd = nonEmptyString(params.cwd);
+    const actions = commandActions(params.commandActions ?? params.parsedCmd, input.context);
+    const network = networkProjection(params.networkApprovalContext);
+    request.command = {
+        text: text ?? "[redacted command]",
+    };
+    if (cwd !== undefined) {
+        request.command.cwd_label = labelPath(cwd, input.context);
+    }
+    if (actions !== undefined) {
+        request.command.actions = actions;
+    }
+    if (network !== undefined) {
+        request.command.network = network;
+    }
+    return { request, decisions: decisions.runtimes };
+}
+function buildFileChangeApproval(input) {
+    if (!isRecord(input.request.params)) {
+        return null;
+    }
+    const params = input.request.params;
+    const decisions = decisionMap(commandDecisionOptions(params, input.legacy));
+    const request = baseRequest({
+        context: input.context,
+        kind: input.legacy ? "legacy_apply_patch" : "file_change",
+        title: "Approve file changes",
+        summary: "Codex wants permission to write files.",
+        params,
+        decisions,
+    });
+    const fileChange = fileChangeProjection(params, input.context);
+    if (fileChange !== undefined) {
+        request.file_change = fileChange;
+    }
+    return { request, decisions: decisions.runtimes };
+}
+function buildPermissionsApproval(request, context) {
+    if (!isRecord(request.params)) {
+        return null;
+    }
+    const params = request.params;
+    const permissions = params.permissions;
+    const decisions = decisionMap(permissionsDecisionOptions(permissions));
+    const projection = baseRequest({
+        context,
+        kind: "permissions",
+        title: "Approve permissions",
+        summary: "Codex wants additional runtime permissions.",
+        params,
+        decisions,
+    });
+    const permissionsDetails = permissionsProjection(permissions, context);
+    if (permissionsDetails !== undefined) {
+        projection.permissions = permissionsDetails;
+    }
+    if (nonEmptyString(params.cwd) !== undefined) {
+        projection.command = {
+            text: "request permissions",
+            cwd_label: labelPath(String(params.cwd), context),
+        };
+    }
+    return { request: projection, decisions: decisions.runtimes };
+}
+export function buildApprovalProjection(request, context) {
+    switch (request.method) {
+        case "item/commandExecution/requestApproval":
+            return buildCommandApproval({ request, context, legacy: false });
+        case "item/fileChange/requestApproval":
+            return buildFileChangeApproval({ request, context, legacy: false });
+        case "item/permissions/requestApproval":
+            return buildPermissionsApproval(request, context);
+        case "execCommandApproval":
+            return buildCommandApproval({ request, context, legacy: true });
+        case "applyPatchApproval":
+            return buildFileChangeApproval({ request, context, legacy: true });
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=projections.js.map

package/dist/artifact-feedback/index.d.ts

@@ -0,0 +1,17 @@
+import { type ArtifactFeedbackCommand, type ArtifactFeedbackRef, type ArtifactSemanticSnapshot } from "@tutti/shared/schemas/api";
+export declare class ArtifactFeedbackValidationError extends Error {
+    constructor(message: string);
+}
+export declare function normalizeArtifactFeedbackCommand(input: ArtifactFeedbackCommand): ArtifactFeedbackCommand;
+export declare function describeArtifactTarget(snapshot: ArtifactSemanticSnapshot): string;
+export declare function createArtifactFeedbackMessage(options: {
+    artifactTitle: string;
+    feedback: ArtifactFeedbackCommand;
+}): {
+    body: string;
+    ref: ArtifactFeedbackRef;
+};
+export declare function formatArtifactFeedbackForModel(ref: ArtifactFeedbackRef, options?: {
+    maxChars?: number;
+}): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/artifact-feedback/index.js

@@ -0,0 +1,182 @@
+import { Value } from "@sinclair/typebox/value";
+import { ARTIFACT_FEEDBACK_MAX_AUTHORED_TEXT_LENGTH, ARTIFACT_FEEDBACK_MAX_SERIALIZED_BYTES, ArtifactFeedbackCommandSchema, } from "@tutti/shared/schemas/api";
+import { redactText, redactValue } from "@tutti/shared/utils";
+export class ArtifactFeedbackValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ArtifactFeedbackValidationError";
+    }
+}
+function normalizedLine(value) {
+    return value.trim().replace(/\s+/gu, " ");
+}
+function validateDocumentUrl(value) {
+    const normalized = value.trim();
+    let parsed;
+    try {
+        parsed = new URL(normalized, "https://artifact.invalid");
+    }
+    catch {
+        throw new ArtifactFeedbackValidationError("Artifact feedback page URL is invalid");
+    }
+    if (parsed.origin !== "https://artifact.invalid" || !normalized.startsWith("/")) {
+        throw new ArtifactFeedbackValidationError("Artifact feedback page URL must be relative");
+    }
+    if (redactText(normalized) !== normalized) {
+        throw new ArtifactFeedbackValidationError("Artifact feedback page URL contains restricted data");
+    }
+    return normalized;
+}
+export function normalizeArtifactFeedbackCommand(input) {
+    for (const annotation of input.annotations) {
+        validateDocumentUrl(annotation.document_url);
+    }
+    const redacted = redactValue(input);
+    if (!Value.Check(ArtifactFeedbackCommandSchema, redacted)) {
+        throw new ArtifactFeedbackValidationError("Artifact feedback payload is invalid");
+    }
+    const candidate = redacted;
+    const summary = candidate.summary === undefined ? undefined : normalizedLine(candidate.summary);
+    if (candidate.summary !== undefined && summary === "") {
+        throw new ArtifactFeedbackValidationError("Artifact feedback summary cannot be empty");
+    }
+    const annotations = candidate.annotations.map((annotation) => {
+        const comment = annotation.comment.trim();
+        if (comment === "") {
+            throw new ArtifactFeedbackValidationError("Artifact feedback comment cannot be empty");
+        }
+        return {
+            document_url: validateDocumentUrl(annotation.document_url),
+            comment,
+            target: annotation.target,
+        };
+    });
+    const authoredLength = (summary?.length ?? 0) + annotations.reduce((total, item) => total + item.comment.length, 0);
+    if (authoredLength > ARTIFACT_FEEDBACK_MAX_AUTHORED_TEXT_LENGTH) {
+        throw new ArtifactFeedbackValidationError(`Artifact feedback text cannot exceed ${ARTIFACT_FEEDBACK_MAX_AUTHORED_TEXT_LENGTH} characters`);
+    }
+    const normalized = {
+        expected_preview_generation: candidate.expected_preview_generation.trim(),
+        ...(summary === undefined ? {} : { summary }),
+        annotations,
+    };
+    if (normalized.expected_preview_generation === "" ||
+        Buffer.byteLength(JSON.stringify(normalized), "utf8") > ARTIFACT_FEEDBACK_MAX_SERIALIZED_BYTES) {
+        throw new ArtifactFeedbackValidationError("Artifact feedback payload is too large");
+    }
+    return normalized;
+}
+function boundedMiddle(value, maxLength) {
+    const normalized = normalizedLine(value);
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    if (maxLength < 8) {
+        return normalized.slice(0, maxLength);
+    }
+    const head = Math.ceil((maxLength - 1) / 2);
+    const tail = Math.floor((maxLength - 1) / 2);
+    return `${normalized.slice(0, head)}…${normalized.slice(-tail)}`;
+}
+export function describeArtifactTarget(snapshot) {
+    const kind = snapshot.role ?? snapshot.tag_name;
+    const name = snapshot.accessible_name ?? snapshot.text_excerpt;
+    const direct = name === undefined ? kind : `${kind} “${boundedMiddle(name, 140)}”`;
+    const context = snapshot.context[0];
+    if (context === undefined) {
+        return direct;
+    }
+    const contextKind = context.role ?? context.tag_name;
+    const contextName = context.accessible_name;
+    return contextName === undefined
+        ? `${direct}, inside ${contextKind}`
+        : `${direct}, inside ${contextKind} “${boundedMiddle(contextName, 100)}”`;
+}
+function describeArtifactState(snapshot) {
+    if (snapshot.state === undefined) {
+        return undefined;
+    }
+    const labels = Object.entries(snapshot.state).map(([key, value]) => `${key}=${String(value)}`);
+    return labels.length === 0 ? undefined : labels.join(", ");
+}
+function buildMessageBody(ref, authoredBudget) {
+    const summaryBudget = Math.min(800, Math.floor(authoredBudget * 0.2));
+    const summary = ref.summary === undefined ? undefined : boundedMiddle(ref.summary, summaryBudget);
+    const remaining = authoredBudget - (summary?.length ?? 0);
+    const commentBudget = Math.max(120, Math.floor(remaining / ref.annotations.length));
+    const lines = [`Artifact feedback: ${normalizedLine(ref.artifact_title)}`];
+    if (summary !== undefined) {
+        lines.push(`Overall: ${summary}`);
+    }
+    for (const [index, annotation] of ref.annotations.entries()) {
+        lines.push("", `${index + 1}. Feedback: ${boundedMiddle(annotation.comment, commentBudget)}`, `   Target: ${boundedMiddle(describeArtifactTarget(annotation.target.snapshot), 220)}`, `   Page: ${boundedMiddle(annotation.document_url, 160)}`);
+        const state = describeArtifactState(annotation.target.snapshot);
+        if (state !== undefined) {
+            lines.push(`   State: ${boundedMiddle(state, 100)}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function createArtifactFeedbackMessage(options) {
+    const ref = {
+        kind: "artifact_feedback",
+        version: 1,
+        preview_generation: options.feedback.expected_preview_generation,
+        artifact_title: options.artifactTitle,
+        inspector_version: 1,
+        ...(options.feedback.summary === undefined ? {} : { summary: options.feedback.summary }),
+        annotations: options.feedback.annotations,
+    };
+    for (let budget = ARTIFACT_FEEDBACK_MAX_AUTHORED_TEXT_LENGTH; budget >= 2_000; budget -= 250) {
+        const body = buildMessageBody(ref, budget);
+        if (body.length <= 8_000) {
+            return { body, ref };
+        }
+    }
+    const body = buildMessageBody(ref, 1_500);
+    if (body.length > 8_000) {
+        throw new ArtifactFeedbackValidationError("Artifact feedback message is too large");
+    }
+    return { body, ref };
+}
+function semanticModelText(snapshot, maxLength) {
+    const fields = [
+        `Target: ${snapshot.element_kind}/${snapshot.tag_name}${snapshot.role === undefined ? "" : ` role=${snapshot.role}`}${snapshot.accessible_name === undefined
+            ? ""
+            : ` name=“${normalizedLine(snapshot.accessible_name)}”`}`,
+    ];
+    if (snapshot.text_excerpt !== undefined) {
+        fields.push(`Text: ${normalizedLine(snapshot.text_excerpt)}`);
+    }
+    if (snapshot.context.length > 0) {
+        fields.push(`Context: ${snapshot.context
+            .map((item) => [item.role ?? item.tag_name, item.accessible_name].filter(Boolean).join(" “") +
+            (item.accessible_name === undefined ? "" : "”"))
+            .join(" > ")}`);
+    }
+    const state = describeArtifactState(snapshot);
+    if (state !== undefined) {
+        fields.push(`State: ${state}`);
+    }
+    const perField = Math.max(16, Math.floor(maxLength / fields.length));
+    return fields.map((field) => boundedMiddle(field, perField)).join("; ");
+}
+export function formatArtifactFeedbackForModel(ref, options = {}) {
+    const maxChars = Math.max(800, options.maxChars ?? 2_000);
+    const header = `Artifact feedback: ${boundedMiddle(ref.artifact_title, 120)}`;
+    const overall = ref.summary === undefined
+        ? undefined
+        : `Overall: ${boundedMiddle(ref.summary, Math.min(320, Math.floor(maxChars * 0.16)))}`;
+    const fixedLength = header.length + (overall?.length ?? 0) + 2;
+    const perAnnotation = Math.max(80, Math.floor((maxChars - fixedLength - ref.annotations.length * 2) / ref.annotations.length));
+    const annotations = ref.annotations.map((annotation, index) => {
+        const routeBudget = Math.max(24, Math.floor(perAnnotation * 0.18));
+        const semanticBudget = Math.max(36, Math.floor(perAnnotation * 0.42));
+        const prefix = `${index + 1}. ${boundedMiddle(annotation.document_url, routeBudget)} | `;
+        const semantic = semanticModelText(annotation.target.snapshot, semanticBudget);
+        const commentBudget = Math.max(24, perAnnotation - prefix.length - semantic.length - 13);
+        return `${prefix}${semantic} | Feedback: ${boundedMiddle(annotation.comment, commentBudget)}`;
+    });
+    return [header, ...(overall === undefined ? [] : [overall]), ...annotations].join("\n");
+}
+//# sourceMappingURL=index.js.map

package/dist/artifacts/candidate-validator.d.ts

@@ -0,0 +1,38 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import { type ValidatedArtifactContract } from "./manifest-contract.js";
+import { type ArtifactPreviewProcessPlan } from "./process-boundary.js";
+export type ArtifactValidationReasonCode = "artifact_applicability_failed" | "artifact_manifest_missing" | "artifact_manifest_invalid" | "artifact_static_entry_invalid" | "artifact_preview_script_missing" | "artifact_preview_start_failed" | "artifact_preview_not_ready" | "artifact_preview_entry_invalid";
+export type ArtifactValidationDiagnosticSource = "applicability_judge" | "manifest_parser" | "package_json" | "preview_process" | "ready_probe";
+export type ArtifactValidationDiagnostic = {
+    source: ArtifactValidationDiagnosticSource;
+    text: string;
+    truncated: boolean;
+};
+export type CandidateArtifactValidationFailure = {
+    reason_code: ArtifactValidationReasonCode;
+    summary: string;
+    guidance: string;
+    diagnostic: ArtifactValidationDiagnostic;
+};
+export type CandidateArtifactValidationResult = {
+    status: "not_declared";
+} | {
+    status: "valid";
+    declaration: ValidatedArtifactContract;
+} | {
+    status: "invalid";
+    failure: CandidateArtifactValidationFailure;
+};
+export type ValidateCandidateArtifactOptions = {
+    repoRoot: string;
+    baseEnv?: NodeJS.ProcessEnv;
+    spawnProcess?: (plan: ArtifactPreviewProcessPlan) => ChildProcessWithoutNullStreams;
+    allocatePort?: () => Promise<number>;
+    fetchImpl?: typeof fetch;
+    terminateProcess?: (child: ChildProcessWithoutNullStreams) => Promise<void>;
+    readyTimeoutMs?: number;
+    probeIntervalMs?: number;
+    probeRequestTimeoutMs?: number;
+};
+export declare function validateCandidateArtifact(options: ValidateCandidateArtifactOptions): Promise<CandidateArtifactValidationResult>;
+//# sourceMappingURL=candidate-validator.d.ts.map