@moinulmoin/eden 0.1.0

package/dist/eve-runtime-config.d.ts

@@ -0,0 +1,126 @@
+export declare const EVE_RESERVED_HOST_VARIABLES: readonly ["HOST", "NITRO_HOST", "PORT", "NITRO_PORT", "NODE_ENV", "WORKFLOW_LOCAL_BASE_URL", "EDEN_EVE_DEPLOYMENT_ID", "EDEN_EVE_GENERATION_ID"];
+export type EveReservedHostVariable = (typeof EVE_RESERVED_HOST_VARIABLES)[number];
+export declare const EVE_START_COMMAND: readonly ["./node_modules/.bin/eve", "start", "--host", "0.0.0.0", "--port", "8080"];
+type EveRuntimeValueMap = Readonly<Record<string, string>>;
+export type EveRuntimeConfigErrorCode = "EVE_ENV_FILE_NOT_FOUND" | "EVE_ENV_FILE_INVALID" | "EVE_ENV_FILE_UNREADABLE" | "EVE_ENV_FILE_ENCODING" | "EVE_ENV_FILE_MALFORMED" | "EVE_ENV_FILE_DUPLICATE" | "EVE_ENV_RESERVED_VARIABLE" | "EVE_ENV_FILE_RACE" | "EVE_RUNTIME_INJECTION_INVALID" | "EVE_RUNTIME_PROTECTED_STORE_UNAVAILABLE" | "EVE_RUNTIME_PROTECTED_UPLOAD_FAILED" | "EVE_RUNTIME_LOCAL_INJECTION_UNSUPPORTED";
+export declare class EveRuntimeConfigError extends Error {
+    readonly code: EveRuntimeConfigErrorCode;
+    readonly source: string | undefined;
+    readonly variableName: string | undefined;
+    constructor(options: {
+        readonly code: EveRuntimeConfigErrorCode;
+        readonly message: string;
+        readonly source?: string;
+        readonly variableName?: string;
+    });
+}
+export interface EveRuntimeInputIdentity {
+    readonly token: string;
+    readonly byteLength: number;
+    readonly digest: string;
+}
+export interface RedactedRuntimeConfigSeam {
+    readonly supplied: true;
+    readonly inputIdentity: EveRuntimeInputIdentity;
+    readonly variableNames: readonly string[];
+    readonly reservedHostNames: readonly EveReservedHostVariable[];
+    readonly protectedRevision: string;
+    readonly redactionHandle: string;
+    readonly excludedFromBuildInputs: true;
+}
+interface EveRuntimeFileObservation {
+    readonly path: string;
+    readonly dev: number;
+    readonly ino: number;
+    readonly mode: number;
+    readonly size: number;
+    readonly bytes: Buffer;
+    readonly digest: string;
+}
+declare class EveRuntimeRedactionRegistry {
+    readonly handle: string;
+    private readonly values;
+    register(value: string): void;
+    redact(value: string): string;
+    dispose(): void;
+}
+export declare function redactEveRuntimeOutput(value: string): string;
+export interface EveStartProcessRequest {
+    readonly command: "./node_modules/.bin/eve";
+    readonly args: readonly [
+        "start",
+        "--host",
+        "0.0.0.0",
+        "--port",
+        "8080"
+    ];
+    readonly cwd: string;
+    /**
+     * This is a private startup environment. It is intentionally not inherited
+     * from the Eden process and never contains the control-plane environment.
+     */
+    readonly env: Readonly<Record<string, string>>;
+}
+export interface EveRuntimeProtectedPutRequest {
+    readonly targetId: string;
+    readonly revision: string;
+    readonly inputIdentity: EveRuntimeInputIdentity;
+    readonly variableNames: readonly string[];
+    readonly values: EveRuntimeValueMap;
+}
+export interface EveRuntimeProtectedPutResult {
+    readonly revision: string;
+    readonly handle: string;
+}
+export interface EveRuntimeProtectedStore {
+    /**
+     * Implementations must use a provider-protected value channel. This method
+     * must not serialize values into argv, URLs, source, records, or logs.
+     */
+    put(request: EveRuntimeProtectedPutRequest): Promise<EveRuntimeProtectedPutResult>;
+}
+export type EveRuntimeInjectionMode = "preflight" | "deploy";
+export interface EveRuntimeInjection {
+    readonly mode: EveRuntimeInjectionMode;
+    readonly seam: RedactedRuntimeConfigSeam;
+    readonly protectedRevision: string;
+    readonly protectedHandle: string | undefined;
+    readonly variableNames: readonly string[];
+    readonly startCommand: typeof EVE_START_COMMAND;
+    runLocal<T>(options: {
+        readonly cwd: string;
+        readonly hostEnvironment: Readonly<Record<string, string>>;
+        readonly run: (request: EveStartProcessRequest) => T | Promise<T>;
+    }): Promise<T>;
+}
+export interface EveRuntimeInjectionOptions {
+    readonly mode: EveRuntimeInjectionMode;
+    readonly targetId?: string;
+    readonly protectedStore?: EveRuntimeProtectedStore;
+}
+export declare class EveRuntimeConfig {
+    private readonly values;
+    private readonly observation;
+    private readonly redaction;
+    private disposed;
+    private readonly safeSeam;
+    private constructor();
+    static from(observation: EveRuntimeFileObservation, values: EveRuntimeValueMap, redaction: EveRuntimeRedactionRegistry): EveRuntimeConfig;
+    get seam(): RedactedRuntimeConfigSeam;
+    get inputPath(): string;
+    toJSON(): RedactedRuntimeConfigSeam;
+    revalidate(): Promise<void>;
+    readInputIdentity(): Promise<EveRuntimeInputIdentity>;
+    withProtectedValues<T>(callback: (values: EveRuntimeValueMap) => T): T;
+    createStartEnvironment(hostEnvironment: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
+    dispose(): void;
+    private assertUsable;
+}
+export declare function readEveRuntimeConfig(inputPath: string, options?: {
+    readonly cwd?: string;
+}): Promise<EveRuntimeConfig>;
+export declare const parseEveRuntimeConfig: typeof readEveRuntimeConfig;
+export declare const loadEveRuntimeConfig: typeof readEveRuntimeConfig;
+export declare function prepareEveRuntimeInjection(config: EveRuntimeConfig, options: EveRuntimeInjectionOptions): Promise<EveRuntimeInjection>;
+export {};
+//# sourceMappingURL=eve-runtime-config.d.ts.map

package/dist/eve-runtime-config.js

@@ -0,0 +1,446 @@
+import { createHash, randomUUID, } from "node:crypto";
+import { lstat, readFile, } from "node:fs/promises";
+import { resolve, } from "node:path";
+export const EVE_RESERVED_HOST_VARIABLES = Object.freeze([
+    "HOST",
+    "NITRO_HOST",
+    "PORT",
+    "NITRO_PORT",
+    "NODE_ENV",
+    "WORKFLOW_LOCAL_BASE_URL",
+    "EDEN_EVE_DEPLOYMENT_ID",
+    "EDEN_EVE_GENERATION_ID",
+]);
+export const EVE_START_COMMAND = Object.freeze([
+    "./node_modules/.bin/eve",
+    "start",
+    "--host",
+    "0.0.0.0",
+    "--port",
+    "8080",
+]);
+const EVE_ENVIRONMENT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+const EVE_RUNTIME_METADATA_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
+const EVE_ENV_FILE_SOURCE = "--env-file";
+export class EveRuntimeConfigError extends Error {
+    code;
+    source;
+    variableName;
+    constructor(options) {
+        super(options.message);
+        this.name = "EveRuntimeConfigError";
+        this.code = options.code;
+        this.source = options.source;
+        this.variableName = options.variableName;
+    }
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function isMissingError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+function isPermissionError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        ["EACCES", "EPERM", "EISDIR"].includes(String(error.code)));
+}
+function fileObservationMatches(left, right) {
+    return (left.dev === right.dev &&
+        left.ino === right.ino &&
+        left.mode === right.mode &&
+        left.size === right.size &&
+        left.digest === right.digest &&
+        left.bytes.equals(right.bytes));
+}
+function invalidPathError(reason) {
+    return new EveRuntimeConfigError({
+        code: "EVE_ENV_FILE_INVALID",
+        message: `The explicit Eve environment file is invalid: ${reason}.`,
+        source: EVE_ENV_FILE_SOURCE,
+    });
+}
+async function observeEnvironmentFile(path) {
+    const before = await lstat(path).catch((error) => {
+        if (isMissingError(error)) {
+            throw new EveRuntimeConfigError({
+                code: "EVE_ENV_FILE_NOT_FOUND",
+                message: "The explicit Eve environment file does not exist.",
+                source: EVE_ENV_FILE_SOURCE,
+            });
+        }
+        throw new EveRuntimeConfigError({
+            code: "EVE_ENV_FILE_UNREADABLE",
+            message: "The explicit Eve environment file could not be inspected safely.",
+            source: EVE_ENV_FILE_SOURCE,
+        });
+    });
+    if (!before.isFile() || before.isSymbolicLink()) {
+        throw invalidPathError("it must be a regular file and symbolic links are not accepted");
+    }
+    let bytes;
+    try {
+        bytes = await readFile(path);
+    }
+    catch (error) {
+        throw new EveRuntimeConfigError({
+            code: isPermissionError(error)
+                ? "EVE_ENV_FILE_UNREADABLE"
+                : "EVE_ENV_FILE_INVALID",
+            message: "The explicit Eve environment file could not be read safely.",
+            source: EVE_ENV_FILE_SOURCE,
+        });
+    }
+    const secondBytes = await readFile(path).catch(() => undefined);
+    const after = await lstat(path).catch((error) => {
+        if (isMissingError(error))
+            return undefined;
+        return undefined;
+    });
+    if (secondBytes === undefined ||
+        !bytes.equals(secondBytes) ||
+        after === undefined ||
+        !after.isFile() ||
+        after.isSymbolicLink() ||
+        after.dev !== before.dev ||
+        after.ino !== before.ino ||
+        after.mode !== before.mode ||
+        after.size !== before.size) {
+        throw new EveRuntimeConfigError({
+            code: "EVE_ENV_FILE_RACE",
+            message: "The explicit Eve environment file changed while it was being read.",
+            source: EVE_ENV_FILE_SOURCE,
+        });
+    }
+    return {
+        path,
+        dev: before.dev,
+        ino: before.ino,
+        mode: before.mode,
+        size: before.size,
+        bytes,
+        digest: sha256(bytes),
+    };
+}
+function decodeUtf8(bytes) {
+    try {
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        return text.startsWith("\uFEFF") ? text.slice(1) : text;
+    }
+    catch {
+        throw new EveRuntimeConfigError({
+            code: "EVE_ENV_FILE_ENCODING",
+            message: "The explicit Eve environment file must contain valid UTF-8 text.",
+            source: EVE_ENV_FILE_SOURCE,
+        });
+    }
+}
+function malformedLine(lineNumber) {
+    return new EveRuntimeConfigError({
+        code: "EVE_ENV_FILE_MALFORMED",
+        message: `The explicit Eve environment file contains a malformed assignment on line ${lineNumber}.`,
+        source: EVE_ENV_FILE_SOURCE,
+    });
+}
+function parseEnvironmentText(text) {
+    const values = Object.create(null);
+    const lines = text.split("\n");
+    for (const [index, rawLine] of lines.entries()) {
+        const lineNumber = index + 1;
+        const line = rawLine.endsWith("\r")
+            ? rawLine.slice(0, -1)
+            : rawLine;
+        const firstNonWhitespace = line.search(/\S/u);
+        if (firstNonWhitespace === -1 || line[firstNonWhitespace] === "#") {
+            continue;
+        }
+        const separator = line.indexOf("=");
+        if (separator <= 0) {
+            throw malformedLine(lineNumber);
+        }
+        const name = line.slice(0, separator);
+        const value = line.slice(separator + 1);
+        if (!EVE_ENVIRONMENT_NAME_PATTERN.test(name)) {
+            throw malformedLine(lineNumber);
+        }
+        if (Object.prototype.hasOwnProperty.call(values, name)) {
+            throw new EveRuntimeConfigError({
+                code: "EVE_ENV_FILE_DUPLICATE",
+                message: `The explicit Eve environment file defines ${name} more than once.`,
+                source: EVE_ENV_FILE_SOURCE,
+                variableName: name,
+            });
+        }
+        if (EVE_RESERVED_HOST_VARIABLES.includes(name)) {
+            throw new EveRuntimeConfigError({
+                code: "EVE_ENV_RESERVED_VARIABLE",
+                message: `The explicit Eve environment file attempts to override reserved host variable ${name}.`,
+                source: EVE_ENV_FILE_SOURCE,
+                variableName: name,
+            });
+        }
+        values[name] = value;
+    }
+    return Object.freeze(values);
+}
+class EveRuntimeRedactionRegistry {
+    handle = `eve-runtime-redaction-${randomUUID()}`;
+    values = new Set();
+    register(value) {
+        if (value.length > 0)
+            this.values.add(value);
+    }
+    redact(value) {
+        let redacted = value;
+        const registered = [...this.values].sort((left, right) => right.length - left.length);
+        for (const secret of registered) {
+            redacted = redacted.split(secret).join("[redacted]");
+        }
+        return redacted;
+    }
+    dispose() {
+        this.values.clear();
+    }
+}
+const activeRedactionRegistries = new Set();
+export function redactEveRuntimeOutput(value) {
+    let redacted = value;
+    for (const registry of activeRedactionRegistries) {
+        redacted = registry.redact(redacted);
+    }
+    return redacted;
+}
+export class EveRuntimeConfig {
+    values;
+    observation;
+    redaction;
+    disposed = false;
+    safeSeam;
+    constructor(observation, values, redaction) {
+        this.observation = observation;
+        this.values = values;
+        this.redaction = redaction;
+        const variableNames = Object.freeze(Object.keys(values).sort());
+        const protectedRevision = `eve-runtime-revision-${randomUUID()}`;
+        this.safeSeam = Object.freeze({
+            supplied: true,
+            inputIdentity: Object.freeze({
+                token: `eve-runtime-input-${randomUUID()}`,
+                byteLength: observation.bytes.byteLength,
+                digest: observation.digest,
+            }),
+            variableNames,
+            reservedHostNames: EVE_RESERVED_HOST_VARIABLES,
+            protectedRevision,
+            redactionHandle: redaction.handle,
+            excludedFromBuildInputs: true,
+        });
+    }
+    static from(observation, values, redaction) {
+        return new EveRuntimeConfig(observation, values, redaction);
+    }
+    get seam() {
+        return this.safeSeam;
+    }
+    get inputPath() {
+        return this.observation.path;
+    }
+    toJSON() {
+        return this.safeSeam;
+    }
+    async revalidate() {
+        this.assertUsable();
+        const latest = await observeEnvironmentFile(this.observation.path);
+        if (!fileObservationMatches(this.observation, latest)) {
+            throw new EveRuntimeConfigError({
+                code: "EVE_ENV_FILE_RACE",
+                message: "The explicit Eve environment file changed during Eve validation.",
+                source: EVE_ENV_FILE_SOURCE,
+            });
+        }
+    }
+    async readInputIdentity() {
+        await this.revalidate();
+        return this.safeSeam.inputIdentity;
+    }
+    withProtectedValues(callback) {
+        this.assertUsable();
+        return callback(this.values);
+    }
+    createStartEnvironment(hostEnvironment) {
+        this.assertUsable();
+        for (const name of Object.keys(hostEnvironment)) {
+            if (!EVE_RESERVED_HOST_VARIABLES.includes(name)) {
+                throw new EveRuntimeConfigError({
+                    code: "EVE_RUNTIME_INJECTION_INVALID",
+                    message: `The Eve start environment contains a non-host variable ${name}.`,
+                    variableName: name,
+                });
+            }
+        }
+        const environment = {
+            ...this.values,
+            ...hostEnvironment,
+        };
+        return Object.freeze(environment);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.redaction.dispose();
+        activeRedactionRegistries.delete(this.redaction);
+    }
+    assertUsable() {
+        if (this.disposed) {
+            throw new EveRuntimeConfigError({
+                code: "EVE_RUNTIME_INJECTION_INVALID",
+                message: "The Eve runtime configuration has already been released.",
+            });
+        }
+    }
+}
+export async function readEveRuntimeConfig(inputPath, options = {}) {
+    if (inputPath.length === 0) {
+        throw new EveRuntimeConfigError({
+            code: "EVE_ENV_FILE_INVALID",
+            message: "The explicit Eve environment file path must not be empty.",
+        });
+    }
+    const path = resolve(options.cwd ?? process.cwd(), inputPath);
+    const observation = await observeEnvironmentFile(path);
+    const values = parseEnvironmentText(decodeUtf8(observation.bytes));
+    const redaction = new EveRuntimeRedactionRegistry();
+    for (const value of Object.values(values))
+        redaction.register(value);
+    activeRedactionRegistries.add(redaction);
+    return EveRuntimeConfig.from(observation, values, redaction);
+}
+export const parseEveRuntimeConfig = readEveRuntimeConfig;
+export const loadEveRuntimeConfig = readEveRuntimeConfig;
+function validateProtectedPutResult(result) {
+    if (typeof result !== "object" ||
+        result === null ||
+        typeof result.revision !== "string" ||
+        typeof result.handle !== "string" ||
+        !EVE_RUNTIME_METADATA_PATTERN.test(result.revision) ||
+        !EVE_RUNTIME_METADATA_PATTERN.test(result.handle)) {
+        throw new EveRuntimeConfigError({
+            code: "EVE_RUNTIME_PROTECTED_UPLOAD_FAILED",
+            message: "The protected Eve runtime store returned an invalid revision handle.",
+        });
+    }
+}
+function assertProtectedMetadataDoesNotContainRuntimeValues(result) {
+    if (redactEveRuntimeOutput(result.revision) !== result.revision ||
+        redactEveRuntimeOutput(result.handle) !== result.handle) {
+        throw new EveRuntimeConfigError({
+            code: "EVE_RUNTIME_PROTECTED_UPLOAD_FAILED",
+            message: "The protected Eve runtime store returned value-bearing metadata.",
+        });
+    }
+}
+function redactRuntimeConfigError(error) {
+    return new EveRuntimeConfigError({
+        code: error.code,
+        message: redactEveRuntimeOutput(error.message),
+        ...(error.source === undefined
+            ? {}
+            : { source: redactEveRuntimeOutput(error.source) }),
+        ...(error.variableName === undefined
+            ? {}
+            : { variableName: redactEveRuntimeOutput(error.variableName) }),
+    });
+}
+export async function prepareEveRuntimeInjection(config, options) {
+    await config.revalidate();
+    const variableNames = config.seam.variableNames;
+    if (options.mode === "preflight") {
+        if (options.protectedStore !== undefined) {
+            throw new EveRuntimeConfigError({
+                code: "EVE_RUNTIME_PROTECTED_STORE_UNAVAILABLE",
+                message: "Preflight runtime configuration must use disposable local injection and cannot use a Cloudflare protected store.",
+            });
+        }
+        return {
+            mode: options.mode,
+            seam: config.seam,
+            protectedRevision: config.seam.protectedRevision,
+            protectedHandle: undefined,
+            variableNames,
+            startCommand: EVE_START_COMMAND,
+            async runLocal(runOptions) {
+                await config.revalidate();
+                const request = {
+                    command: EVE_START_COMMAND[0],
+                    args: [
+                        EVE_START_COMMAND[1],
+                        EVE_START_COMMAND[2],
+                        EVE_START_COMMAND[3],
+                        EVE_START_COMMAND[4],
+                        EVE_START_COMMAND[5],
+                    ],
+                    cwd: resolve(runOptions.cwd),
+                    env: config.createStartEnvironment(runOptions.hostEnvironment),
+                };
+                return runOptions.run(request);
+            },
+        };
+    }
+    if (options.targetId === undefined || options.targetId.length === 0) {
+        throw new EveRuntimeConfigError({
+            code: "EVE_RUNTIME_INJECTION_INVALID",
+            message: "Deploy runtime configuration requires an explicit exact target identity.",
+        });
+    }
+    if (options.protectedStore === undefined) {
+        throw new EveRuntimeConfigError({
+            code: "EVE_RUNTIME_PROTECTED_STORE_UNAVAILABLE",
+            message: "Deploy runtime configuration requires a protected runtime store.",
+        });
+    }
+    await config.revalidate();
+    const revision = config.seam.protectedRevision;
+    let stored;
+    try {
+        stored = await config.withProtectedValues((values) => options.protectedStore?.put({
+            targetId: options.targetId,
+            revision,
+            inputIdentity: config.seam.inputIdentity,
+            variableNames,
+            values,
+        }));
+    }
+    catch (error) {
+        if (error instanceof EveRuntimeConfigError) {
+            throw redactRuntimeConfigError(error);
+        }
+        throw new EveRuntimeConfigError({
+            code: "EVE_RUNTIME_PROTECTED_UPLOAD_FAILED",
+            message: "The protected Eve runtime configuration upload failed before publication.",
+        });
+    }
+    validateProtectedPutResult(stored);
+    assertProtectedMetadataDoesNotContainRuntimeValues(stored);
+    await config.revalidate();
+    const protectedRevision = stored.revision;
+    return {
+        mode: options.mode,
+        seam: config.seam,
+        protectedRevision,
+        protectedHandle: stored.handle,
+        variableNames,
+        startCommand: EVE_START_COMMAND,
+        async runLocal() {
+            throw new EveRuntimeConfigError({
+                code: "EVE_RUNTIME_LOCAL_INJECTION_UNSUPPORTED",
+                message: "Deploy runtime values are available only through the protected Container start seam.",
+            });
+        },
+    };
+}
+//# sourceMappingURL=eve-runtime-config.js.map

package/dist/eve-runtime-image.d.ts

@@ -0,0 +1,121 @@
+import { type EveNodeImage, type EvePackagingCheck, type EvePackagingCode, type EveProjectBuildCandidate, type EveProjectOutput } from "./eve-packaging.js";
+import type { EveRuntimeInjection } from "./eve-runtime-config.js";
+declare const START_COMMAND: readonly ["./node_modules/.bin/eve", "start", "--host", "0.0.0.0", "--port", "8080"];
+declare const HEALTH_PATH: "/eve/v1/health";
+declare const HOST_ENVIRONMENT: {
+    readonly HOST: "0.0.0.0";
+    readonly NITRO_HOST: "0.0.0.0";
+    readonly PORT: "8080";
+    readonly NITRO_PORT: "8080";
+    readonly NODE_ENV: "production";
+};
+export interface EveHostRequirements {
+    readonly architecture: string;
+    readonly world: "supported" | "unsupported" | "unknown";
+    readonly sandbox: "supported" | "unsupported" | "unknown";
+    readonly privileged: boolean;
+    readonly devices: "none" | "required" | "unknown";
+    readonly kernel: "supported" | "unsupported" | "unknown";
+    readonly network: "supported" | "unsupported" | "unknown";
+    readonly durableLocalFilesystem: boolean;
+}
+export interface EveRuntimeClosureFile {
+    readonly path: string;
+    readonly sha256: string;
+    readonly byteLength: number;
+    readonly symbolicLink: boolean;
+}
+export interface EveRuntimeNativeModule {
+    readonly path: string;
+    readonly sha256: string;
+    readonly platform: "linux/amd64";
+}
+export interface EveRuntimeClosure {
+    readonly root: "/workspace/node_modules";
+    readonly outputDigest: string;
+    readonly dependencyDigest: string;
+    readonly digest: string;
+    readonly files: readonly EveRuntimeClosureFile[];
+    readonly nativeModules: readonly EveRuntimeNativeModule[];
+    readonly eveStartClosureRetained: true;
+    readonly builderOnlyMaterialExcluded: true;
+}
+export interface EveRuntimeImage extends EveRuntimeImageMetadata {
+    readonly runtimeClosure: EveRuntimeClosure;
+}
+export interface EveRuntimeImageMetadata {
+    readonly dockerfilePath: string;
+    readonly runtimeContextPath: string;
+    readonly platform: "linux/amd64";
+    readonly builderImage: string;
+    readonly runtimeImage: string;
+    readonly imageId: string;
+    readonly imageReference: string;
+    readonly imageDigest: string;
+    readonly launchCommand: typeof START_COMMAND;
+    readonly workingDirectory: "/workspace";
+    readonly hostEnvironment: typeof HOST_ENVIRONMENT;
+    readonly publicOrigin?: string;
+    readonly generatedOutput: EveProjectOutput;
+}
+export interface EveRuntimeStatus {
+    readonly listenHost: "0.0.0.0";
+    readonly listenPort: 8080;
+    readonly healthMethod: "GET";
+    readonly healthPath: typeof HEALTH_PATH;
+    readonly healthStatus: "ready";
+    readonly healthVerified: true;
+    readonly healthVerifiedAt: string;
+    readonly durableLocalFilesystemClaim: false;
+}
+export interface EveRuntimeCleanup {
+    readonly bootContainerId: string | null;
+    readonly bootContainerRemoved: boolean;
+    readonly imageIdentity: "exact" | "indeterminate";
+    readonly imageRetained: boolean;
+    readonly verified: boolean;
+}
+export interface EveRuntimeImageRequest {
+    readonly candidate: EveProjectBuildCandidate;
+    readonly nodeImage: EveNodeImage;
+    readonly dockerCommand?: string;
+    readonly healthPort: number;
+    readonly healthTimeoutMs?: number;
+    readonly healthPollIntervalMs?: number;
+    readonly fetchHealth?: (url: string, init?: RequestInit) => Promise<Response>;
+    readonly hostRequirements?: EveHostRequirements;
+    readonly publicOrigin?: string;
+    readonly runtimeInjection?: EveRuntimeInjection;
+    /**
+     * Preflight must remove its disposable runtime image after health proof.
+     * Deploy may retain the exact image for the publication handoff.
+     */
+    readonly retainImage?: boolean;
+}
+export interface EveRuntimeImageResult {
+    readonly schemaVersion: 1;
+    readonly worker: "eve-packaging-worker";
+    readonly operation: "runtime-image";
+    readonly status: "ready" | "blocked";
+    readonly returnCode: EvePackagingCode | "EVE_PACKAGE_READY";
+    readonly deployable: boolean;
+    readonly candidate: EveProjectBuildCandidate;
+    readonly image: EveRuntimeImage | null;
+    readonly runtime: EveRuntimeStatus | null;
+    readonly cleanup: EveRuntimeCleanup;
+    readonly checks: readonly EvePackagingCheck[];
+    readonly candidateImageId: string | null;
+    readonly candidateImageRetainedLocally: boolean;
+    readonly writtenPaths: readonly string[];
+    readonly error: {
+        readonly code: EvePackagingCode;
+        readonly subject: string;
+        readonly reason: string;
+        readonly remediation: string;
+    } | null;
+}
+export declare function validateEveHostRequirements(requirements: EveHostRequirements): void;
+export declare function revalidateEveRuntimeCandidate(candidate: EveProjectBuildCandidate): Promise<EveRuntimeClosure>;
+export declare function buildEveRuntimeImage(request: EveRuntimeImageRequest): Promise<EveRuntimeImageResult>;
+export {};
+//# sourceMappingURL=eve-runtime-image.d.ts.map