@xfey/tenso 0.1.130

package/dist/artifacts/candidate-validator.js

@@ -0,0 +1,472 @@
+import { lstatSync, readFileSync, realpathSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { ARTIFACT_MANIFEST_PATH, MAX_ARTIFACT_MANIFEST_BYTES, parseArtifactManifestContract, } from "./manifest-contract.js";
+import { allocateArtifactPreviewPort, ArtifactDiagnosticBuffer, cleanupArtifactProcessRuntime, createArtifactPreviewEnv, createArtifactProcessRuntime, spawnArtifactPreviewProcess, terminateArtifactProcessTree, } from "./process-boundary.js";
+const MAX_PACKAGE_JSON_BYTES = 1024 * 1024;
+const MAX_ENTRY_RESPONSE_BYTES = 1024 * 1024;
+const DEFAULT_READY_TIMEOUT_MS = 20_000;
+const DEFAULT_PROBE_INTERVAL_MS = 250;
+const DEFAULT_PROBE_REQUEST_TIMEOUT_MS = 2_000;
+const MAX_ENTRY_REDIRECTS = 3;
+function directDiagnostic(source, text, sensitive) {
+    const buffer = new ArtifactDiagnosticBuffer();
+    buffer.append("stderr", text);
+    const result = buffer.read([sensitive.repoRoot, ...(sensitive.extra ?? [])]);
+    return {
+        source,
+        text: result.text.replace(/^\[stderr\]\n/u, ""),
+        truncated: result.truncated,
+    };
+}
+function failure(options) {
+    return {
+        status: "invalid",
+        failure: {
+            reason_code: options.reasonCode,
+            summary: options.summary,
+            guidance: options.guidance,
+            diagnostic: directDiagnostic(options.source, options.detail, options.sensitive),
+        },
+    };
+}
+function isContainedPath(root, target) {
+    const relativePath = relative(root, target);
+    return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+function requireContainedRealPath(options) {
+    try {
+        const unresolved = resolve(options.repoRealPath, options.repoRelativePath);
+        const realPath = realpathSync.native(unresolved);
+        if (!isContainedPath(options.repoRealPath, realPath)) {
+            return { ok: false, detail: `${options.label} resolves outside the candidate repository` };
+        }
+        const stat = lstatSync(realPath);
+        const expected = options.expectedKind === "file" ? stat.isFile() : stat.isDirectory();
+        if (!expected) {
+            return { ok: false, detail: `${options.label} is not a ${options.expectedKind}` };
+        }
+        return { ok: true, path: realPath };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : `${options.label} is unavailable`;
+        return { ok: false, detail };
+    }
+}
+function readCandidateManifest(repoRealPath) {
+    const manifestPath = join(repoRealPath, ARTIFACT_MANIFEST_PATH);
+    let stat;
+    try {
+        stat = lstatSync(manifestPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { status: "not_declared" };
+        }
+        return {
+            status: "invalid",
+            detail: error instanceof Error ? error.message : "Artifact manifest cannot be read",
+        };
+    }
+    if (!stat.isFile()) {
+        return { status: "invalid", detail: "Artifact manifest path is not a regular file" };
+    }
+    if (stat.size > MAX_ARTIFACT_MANIFEST_BYTES) {
+        return { status: "invalid", detail: "Artifact manifest is too large" };
+    }
+    try {
+        const parsed = parseArtifactManifestContract(readFileSync(manifestPath));
+        return parsed.ok
+            ? { status: "declared", contract: parsed.declaration }
+            : { status: "invalid", detail: parsed.error.message };
+    }
+    catch (error) {
+        return {
+            status: "invalid",
+            detail: error instanceof Error ? error.message : "Artifact manifest cannot be read",
+        };
+    }
+}
+function validateStaticCandidate(repoRealPath, contract) {
+    const runtime = contract.runtime;
+    if (runtime.kind !== "static") {
+        throw new Error("Expected a static Artifact contract");
+    }
+    const root = requireContainedRealPath({
+        repoRealPath,
+        repoRelativePath: runtime.root_path,
+        expectedKind: "directory",
+        label: "Static artifact root",
+    });
+    if (!root.ok) {
+        return failure({
+            reasonCode: "artifact_static_entry_invalid",
+            summary: "The static Artifact root is not usable.",
+            guidance: "Point root at an existing candidate directory inside the repository.",
+            source: "manifest_parser",
+            detail: root.detail,
+            sensitive: { repoRoot: repoRealPath },
+        });
+    }
+    const entry = requireContainedRealPath({
+        repoRealPath: root.path,
+        repoRelativePath: runtime.entry_path,
+        expectedKind: "file",
+        label: "Static artifact entry",
+    });
+    if (!entry.ok) {
+        return failure({
+            reasonCode: "artifact_static_entry_invalid",
+            summary: "The static Artifact entry is not usable.",
+            guidance: "Point entry at an existing HTML file inside the declared static root.",
+            source: "manifest_parser",
+            detail: entry.detail,
+            sensitive: { repoRoot: repoRealPath, extra: [root.path] },
+        });
+    }
+    return { status: "valid", declaration: contract };
+}
+function readPreviewScript(options) {
+    const packageJson = requireContainedRealPath({
+        repoRealPath: options.repoRealPath,
+        repoRelativePath: relative(options.repoRealPath, join(options.cwdPath, "package.json")),
+        expectedKind: "file",
+        label: "Server artifact package.json",
+    });
+    if (!packageJson.ok) {
+        return packageJson;
+    }
+    try {
+        const stat = lstatSync(packageJson.path);
+        if (stat.size > MAX_PACKAGE_JSON_BYTES) {
+            return { ok: false, detail: "Server artifact package.json is too large" };
+        }
+        const parsed = JSON.parse(readFileSync(packageJson.path, "utf8"));
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return { ok: false, detail: "Server artifact package.json must contain a JSON object" };
+        }
+        const scripts = parsed.scripts;
+        if (scripts === null || typeof scripts !== "object" || Array.isArray(scripts)) {
+            return { ok: false, detail: "package.json scripts.artifact:preview is required" };
+        }
+        const preview = scripts["artifact:preview"];
+        if (typeof preview !== "string" || preview.trim().length === 0) {
+            return { ok: false, detail: "package.json scripts.artifact:preview is required" };
+        }
+        return { ok: true };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            detail: error instanceof Error ? error.message : "Server artifact package.json is invalid",
+        };
+    }
+}
+async function readBoundedResponseBody(response) {
+    const contentLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > MAX_ENTRY_RESPONSE_BYTES) {
+        throw new Error("Artifact entry response is too large");
+    }
+    if (response.body === null) {
+        return Buffer.alloc(0);
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const result = await reader.read();
+            if (result.done) {
+                break;
+            }
+            const chunk = Buffer.from(result.value);
+            total += chunk.byteLength;
+            if (total > MAX_ENTRY_RESPONSE_BYTES) {
+                await reader.cancel();
+                throw new Error("Artifact entry response is too large");
+            }
+            chunks.push(chunk);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks, total);
+}
+function looksLikeHtml(content) {
+    const prefix = content.subarray(0, 1024).toString("utf8").trimStart().toLowerCase();
+    return prefix.startsWith("<!doctype html") || prefix.startsWith("<html");
+}
+async function probeServerEntry(options) {
+    let current = options.entryUrl;
+    for (let redirects = 0; redirects <= MAX_ENTRY_REDIRECTS; redirects += 1) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), options.requestTimeoutMs);
+        let response;
+        try {
+            response = await options.fetchImpl(current, {
+                method: "GET",
+                redirect: "manual",
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            const text = error instanceof Error ? error.message : "Artifact entry request failed";
+            return { kind: "retry", text };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get("location");
+            if (location === null) {
+                return { kind: "invalid", text: `Artifact entry returned HTTP ${response.status}` };
+            }
+            if (redirects === MAX_ENTRY_REDIRECTS) {
+                return { kind: "invalid", text: "Artifact entry redirected too many times" };
+            }
+            const next = new URL(location, current);
+            if (next.origin !== options.entryUrl.origin) {
+                return { kind: "invalid", text: "Artifact entry redirected outside its preview instance" };
+            }
+            current = next;
+            continue;
+        }
+        if (response.status < 200 || response.status >= 300) {
+            return { kind: "invalid", text: `Artifact entry returned HTTP ${response.status}` };
+        }
+        try {
+            const content = await readBoundedResponseBody(response);
+            const mediaType = response.headers.get("content-type")?.toLowerCase() ?? "";
+            if (!mediaType.includes("text/html") && !looksLikeHtml(content)) {
+                return {
+                    kind: "invalid",
+                    text: `Artifact entry returned ${mediaType || "non-HTML content"}`,
+                };
+            }
+            return { kind: "valid" };
+        }
+        catch (error) {
+            return {
+                kind: "invalid",
+                text: error instanceof Error ? error.message : "Artifact entry response is invalid",
+            };
+        }
+    }
+    return { kind: "invalid", text: "Artifact entry redirected too many times" };
+}
+function delay(milliseconds) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+}
+async function validateServerCandidate(repoRealPath, contract, options) {
+    const runtime = contract.runtime;
+    if (runtime.kind !== "server") {
+        throw new Error("Expected a server Artifact contract");
+    }
+    const cwd = requireContainedRealPath({
+        repoRealPath,
+        repoRelativePath: runtime.cwd_path,
+        expectedKind: "directory",
+        label: "Server artifact cwd",
+    });
+    if (!cwd.ok) {
+        return failure({
+            reasonCode: "artifact_preview_script_missing",
+            summary: "The server Artifact package directory is not usable.",
+            guidance: "Point cwd at an npm package directory inside the candidate repository.",
+            source: "package_json",
+            detail: cwd.detail,
+            sensitive: { repoRoot: repoRealPath },
+        });
+    }
+    const script = readPreviewScript({ repoRealPath, cwdPath: cwd.path });
+    if (!script.ok) {
+        return failure({
+            reasonCode: "artifact_preview_script_missing",
+            summary: "The server Artifact preview script is missing or invalid.",
+            guidance: "Add a non-empty scripts.artifact:preview command to cwd/package.json.",
+            source: "package_json",
+            detail: script.detail,
+            sensitive: { repoRoot: repoRealPath, extra: [cwd.path] },
+        });
+    }
+    const processRuntime = createArtifactProcessRuntime();
+    const diagnostics = new ArtifactDiagnosticBuffer();
+    let child;
+    let port;
+    let result;
+    try {
+        try {
+            port = await (options.allocatePort ?? allocateArtifactPreviewPort)();
+            const plan = {
+                command: "npm",
+                args: ["run", "artifact:preview"],
+                cwd: cwd.path,
+                env: createArtifactPreviewEnv({
+                    sourceEnv: options.baseEnv ?? process.env,
+                    port,
+                    runtime: processRuntime,
+                }),
+                port,
+            };
+            child = (options.spawnProcess ?? spawnArtifactPreviewProcess)(plan);
+        }
+        catch (error) {
+            result = failure({
+                reasonCode: "artifact_preview_start_failed",
+                summary: "The server Artifact preview could not start.",
+                guidance: "Fix the artifact:preview script so npm can start it with the injected HOST and PORT.",
+                source: "preview_process",
+                detail: error instanceof Error ? error.message : "Preview process could not start",
+                sensitive: { repoRoot: repoRealPath, extra: [cwd.path, processRuntime.root] },
+            });
+        }
+        if (child !== undefined && port !== undefined) {
+            child.stdout.on("data", (chunk) => diagnostics.append("stdout", chunk));
+            child.stderr.on("data", (chunk) => diagnostics.append("stderr", chunk));
+            let processFailure;
+            child.once("error", (error) => {
+                processFailure = error.message;
+            });
+            child.once("close", (code, signal) => {
+                processFailure =
+                    code === null
+                        ? `Preview process exited with signal ${signal ?? "unknown"}`
+                        : `Preview process exited with code ${code}`;
+            });
+            const deadline = Date.now() + (options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS);
+            let lastRetryDetail = "Artifact entry did not accept a connection";
+            while (result === undefined && Date.now() < deadline) {
+                if (processFailure !== undefined) {
+                    const processOutput = diagnostics.read([
+                        repoRealPath,
+                        cwd.path,
+                        processRuntime.root,
+                        String(port),
+                    ]);
+                    const fallbackDiagnostic = directDiagnostic("preview_process", processFailure, {
+                        repoRoot: repoRealPath,
+                        extra: [cwd.path, processRuntime.root, String(port)],
+                    });
+                    result = {
+                        status: "invalid",
+                        failure: {
+                            reason_code: "artifact_preview_start_failed",
+                            summary: "The server Artifact preview exited before its entry became ready.",
+                            guidance: "Fix the artifact:preview script and make it keep listening on the injected HOST and PORT.",
+                            diagnostic: {
+                                source: "preview_process",
+                                text: processOutput.text.trim().length > 0
+                                    ? processOutput.text
+                                    : fallbackDiagnostic.text,
+                                truncated: processOutput.truncated || fallbackDiagnostic.truncated,
+                            },
+                        },
+                    };
+                    break;
+                }
+                const probe = await probeServerEntry({
+                    fetchImpl: options.fetchImpl ?? fetch,
+                    entryUrl: new URL(`http://127.0.0.1:${port}${runtime.entry_path}`),
+                    requestTimeoutMs: options.probeRequestTimeoutMs ?? DEFAULT_PROBE_REQUEST_TIMEOUT_MS,
+                });
+                if (probe.kind === "valid") {
+                    result = { status: "valid", declaration: contract };
+                    break;
+                }
+                if (probe.kind === "invalid") {
+                    result = failure({
+                        reasonCode: "artifact_preview_entry_invalid",
+                        summary: "The server Artifact entry is not a renderable HTML response.",
+                        guidance: "Make the declared entry return successful HTML from the preview server.",
+                        source: "ready_probe",
+                        detail: probe.text,
+                        sensitive: {
+                            repoRoot: repoRealPath,
+                            extra: [cwd.path, processRuntime.root, String(port)],
+                        },
+                    });
+                    break;
+                }
+                lastRetryDetail = probe.text;
+                await delay(options.probeIntervalMs ?? DEFAULT_PROBE_INTERVAL_MS);
+            }
+            if (result === undefined) {
+                const processOutput = diagnostics.read([
+                    repoRealPath,
+                    cwd.path,
+                    processRuntime.root,
+                    String(port),
+                ]);
+                const fallbackDiagnostic = directDiagnostic("ready_probe", lastRetryDetail, {
+                    repoRoot: repoRealPath,
+                    extra: [cwd.path, processRuntime.root, String(port)],
+                });
+                result = {
+                    status: "invalid",
+                    failure: {
+                        reason_code: "artifact_preview_not_ready",
+                        summary: "The server Artifact preview did not become ready in time.",
+                        guidance: "Make artifact:preview listen promptly on the injected HOST and PORT and serve the declared entry.",
+                        diagnostic: {
+                            source: processOutput.text.trim().length > 0 ? "preview_process" : "ready_probe",
+                            text: processOutput.text.trim().length > 0 ? processOutput.text : fallbackDiagnostic.text,
+                            truncated: processOutput.truncated || fallbackDiagnostic.truncated,
+                        },
+                    },
+                };
+            }
+        }
+    }
+    finally {
+        if (child !== undefined) {
+            await (options.terminateProcess ?? terminateArtifactProcessTree)(child);
+        }
+        cleanupArtifactProcessRuntime(processRuntime);
+    }
+    return (result ??
+        failure({
+            reasonCode: "artifact_preview_start_failed",
+            summary: "The server Artifact preview validation did not complete.",
+            guidance: "Fix the artifact:preview script and retry.",
+            source: "preview_process",
+            detail: "Preview validation ended without a result",
+            sensitive: { repoRoot: repoRealPath },
+        }));
+}
+export async function validateCandidateArtifact(options) {
+    let repoRealPath;
+    try {
+        repoRealPath = realpathSync.native(options.repoRoot);
+        if (!lstatSync(repoRealPath).isDirectory()) {
+            throw new Error("Candidate repository root is not a directory");
+        }
+    }
+    catch (error) {
+        return failure({
+            reasonCode: "artifact_manifest_invalid",
+            summary: "The candidate repository could not be inspected for an Artifact.",
+            guidance: "Retry with a valid candidate workspace.",
+            source: "manifest_parser",
+            detail: error instanceof Error ? error.message : "Candidate repository is unavailable",
+            sensitive: { repoRoot: options.repoRoot },
+        });
+    }
+    const candidate = readCandidateManifest(repoRealPath);
+    if (candidate.status === "not_declared") {
+        return { status: "not_declared" };
+    }
+    if (candidate.status === "invalid") {
+        return failure({
+            reasonCode: "artifact_manifest_invalid",
+            summary: "The candidate Artifact manifest is invalid.",
+            guidance: "Rewrite tutti.artifact.json using the complete strict manifest contract.",
+            source: "manifest_parser",
+            detail: candidate.detail,
+            sensitive: { repoRoot: repoRealPath },
+        });
+    }
+    return candidate.contract.runtime.kind === "static"
+        ? validateStaticCandidate(repoRealPath, candidate.contract)
+        : await validateServerCandidate(repoRealPath, candidate.contract, options);
+}
+//# sourceMappingURL=candidate-validator.js.map

package/dist/artifacts/index.d.ts

@@ -0,0 +1,6 @@
+export { readLiveArtifactDeclaration, type LiveArtifactDeclaration, } from "./live-manifest.js";
+export { validateCandidateArtifact, type ArtifactValidationDiagnostic, type ArtifactValidationDiagnosticSource, type ArtifactValidationReasonCode, type CandidateArtifactValidationFailure, type CandidateArtifactValidationResult, type ValidateCandidateArtifactOptions, } from "./candidate-validator.js";
+export { ARTIFACT_MANIFEST_PATH, parseArtifactManifestContract, type ArtifactContractError, type ArtifactContractResult, type ValidatedArtifactContract, type ValidatedArtifactRuntime, } from "./manifest-contract.js";
+export { ARTIFACT_PREVIEW_BASE_PATH, ARTIFACT_PREVIEW_REQUEST_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_RESPONSE_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_DEFAULT_BASE_PATH, ArtifactPreviewManager, isArtifactPreviewHttpMethod, type ArtifactPreviewLeaseOptions, type ArtifactPreviewHttpMethod, type ArtifactPreviewManagerOptions, type ArtifactPreviewProcessPlan, type ArtifactServerPreviewResponse, } from "./preview-runtime.js";
+export { ARTIFACT_PREVIEW_CSP, readArtifactStaticPreview, rewriteArtifactPreviewResourceUrls, type ArtifactStaticPreviewFile, type ReadArtifactStaticPreviewOptions, } from "./static-preview.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/artifacts/index.js

@@ -0,0 +1,6 @@
+export { readLiveArtifactDeclaration, } from "./live-manifest.js";
+export { validateCandidateArtifact, } from "./candidate-validator.js";
+export { ARTIFACT_MANIFEST_PATH, parseArtifactManifestContract, } from "./manifest-contract.js";
+export { ARTIFACT_PREVIEW_BASE_PATH, ARTIFACT_PREVIEW_REQUEST_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_RESPONSE_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_DEFAULT_BASE_PATH, ArtifactPreviewManager, isArtifactPreviewHttpMethod, } from "./preview-runtime.js";
+export { ARTIFACT_PREVIEW_CSP, readArtifactStaticPreview, rewriteArtifactPreviewResourceUrls, } from "./static-preview.js";
+//# sourceMappingURL=index.js.map

package/dist/artifacts/live-manifest.d.ts

@@ -0,0 +1,23 @@
+import type { ArtifactManifest, ArtifactProjection } from "@tutti/shared/schemas/api";
+import { type ValidatedArtifactRuntime } from "./manifest-contract.js";
+type ArtifactInvalidProjection = Extract<ArtifactProjection, {
+    status: "invalid";
+}>;
+export type LiveArtifactDeclaration = {
+    status: "not_declared";
+    projection: Extract<ArtifactProjection, {
+        status: "not_declared";
+    }>;
+} | {
+    status: "invalid";
+    projection: ArtifactInvalidProjection;
+} | {
+    status: "declared";
+    manifest: ArtifactManifest;
+    runtime: ValidatedArtifactRuntime;
+};
+export declare function readLiveArtifactDeclaration(options: {
+    workspaceRoot: string;
+}): LiveArtifactDeclaration;
+export {};
+//# sourceMappingURL=live-manifest.d.ts.map

package/dist/artifacts/live-manifest.js

@@ -0,0 +1,115 @@
+import { lstatSync, readFileSync, realpathSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { ARTIFACT_MANIFEST_PATH, MAX_ARTIFACT_MANIFEST_BYTES, parseArtifactManifestContract, } from "./manifest-contract.js";
+function truncateMessage(message) {
+    const normalized = message.replace(/\s+/gu, " ").trim();
+    return normalized.length <= 220 ? normalized : `${normalized.slice(0, 217)}...`;
+}
+function invalidArtifact(code, message) {
+    return {
+        status: "invalid",
+        projection: {
+            status: "invalid",
+            error: {
+                code,
+                message: truncateMessage(message),
+            },
+        },
+    };
+}
+function isContainedPath(root, target) {
+    const relativePath = relative(root, target);
+    return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+function requireContainedPath(options) {
+    try {
+        const target = realpathSync.native(resolve(options.workspaceRealPath, options.repoPath));
+        const stat = lstatSync(target);
+        const expectedKind = options.kind === "file" ? stat.isFile() : stat.isDirectory();
+        if (!isContainedPath(options.workspaceRealPath, target) || !expectedKind) {
+            return invalidArtifact("invalid_path", `${options.label} is not a contained ${options.kind}`);
+        }
+        return null;
+    }
+    catch {
+        return invalidArtifact("not_found", `${options.label} does not exist`);
+    }
+}
+export function readLiveArtifactDeclaration(options) {
+    let workspaceRealPath;
+    try {
+        workspaceRealPath = realpathSync.native(options.workspaceRoot);
+    }
+    catch {
+        return invalidArtifact("workspace_unavailable", "Project workspace is unavailable");
+    }
+    const manifestPath = join(workspaceRealPath, ARTIFACT_MANIFEST_PATH);
+    let manifestStat;
+    try {
+        manifestStat = lstatSync(manifestPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return {
+                status: "not_declared",
+                projection: { status: "not_declared" },
+            };
+        }
+        return invalidArtifact("manifest_unavailable", "Artifact manifest cannot be read");
+    }
+    if (!manifestStat.isFile()) {
+        return invalidArtifact("invalid_manifest", "Artifact manifest path is not a regular file");
+    }
+    if (manifestStat.size > MAX_ARTIFACT_MANIFEST_BYTES) {
+        return invalidArtifact("too_large", "Artifact manifest is too large");
+    }
+    let manifestContent;
+    try {
+        manifestContent = readFileSync(manifestPath);
+    }
+    catch {
+        return invalidArtifact("manifest_unavailable", "Artifact manifest cannot be read");
+    }
+    const parsed = parseArtifactManifestContract(manifestContent);
+    if (!parsed.ok) {
+        return invalidArtifact(parsed.error.code, parsed.error.message);
+    }
+    const runtime = parsed.declaration.runtime;
+    if (runtime.kind === "static") {
+        const rootError = requireContainedPath({
+            workspaceRealPath,
+            repoPath: runtime.root_path,
+            kind: "directory",
+            label: "Static artifact root",
+        });
+        if (rootError !== null) {
+            return rootError;
+        }
+        const entryError = requireContainedPath({
+            workspaceRealPath,
+            repoPath: runtime.entry_repo_path,
+            kind: "file",
+            label: "Static artifact entry",
+        });
+        if (entryError !== null) {
+            return entryError;
+        }
+    }
+    else {
+        const cwdError = requireContainedPath({
+            workspaceRealPath,
+            repoPath: runtime.cwd_path,
+            kind: "directory",
+            label: "Server artifact cwd",
+        });
+        if (cwdError !== null) {
+            return cwdError;
+        }
+    }
+    return {
+        status: "declared",
+        manifest: parsed.declaration.manifest,
+        runtime,
+    };
+}
+//# sourceMappingURL=live-manifest.js.map

package/dist/artifacts/manifest-contract.d.ts

@@ -0,0 +1,30 @@
+import type { ArtifactManifest } from "@tutti/shared/schemas/api";
+export declare const ARTIFACT_MANIFEST_PATH: "tutti.artifact.json";
+export declare const MAX_ARTIFACT_MANIFEST_BYTES: number;
+export type ArtifactContractError = {
+    code: "too_large" | "unsupported_encoding" | "invalid_json" | "invalid_schema" | "invalid_path" | "invalid_entry";
+    message: string;
+};
+export type ValidatedArtifactRuntime = {
+    kind: "static";
+    root_path: string;
+    entry_path: string;
+    entry_repo_path: string;
+} | {
+    kind: "server";
+    cwd_path: string;
+    entry_path: string;
+};
+export type ValidatedArtifactContract = {
+    manifest: ArtifactManifest;
+    runtime: ValidatedArtifactRuntime;
+};
+export type ArtifactContractResult = {
+    ok: true;
+    declaration: ValidatedArtifactContract;
+} | {
+    ok: false;
+    error: ArtifactContractError;
+};
+export declare function parseArtifactManifestContract(buffer: Buffer): ArtifactContractResult;
+//# sourceMappingURL=manifest-contract.d.ts.map