@b00dea/cockpit 0.0.0-stage → 0.1.1

package/dist/environment/host-observation.d.ts

@@ -0,0 +1,56 @@
+import { type EnvironmentObservation } from './contract.js';
+import { type MachineFloorEvidence } from './runtime.js';
+export declare const observationDeclarations: readonly [{
+    readonly id: 'machine-memory';
+    readonly owner: "host-observation";
+    readonly postures: readonly ["machine-floor"];
+    readonly stages: readonly [{
+        readonly stage: 'bootstrap';
+        readonly disposition: 'required';
+    }, {
+        readonly stage: 'steady';
+        readonly disposition: 'required';
+    }];
+    readonly code: "MACHINE_MEMORY_BELOW_FLOOR";
+    readonly isIssued: typeof isHostObservation;
+    readonly issuedAt: typeof observationIssuedAt;
+}, {
+    readonly id: 'machine-cpu';
+    readonly owner: "host-observation";
+    readonly postures: readonly ["machine-floor"];
+    readonly stages: readonly [{
+        readonly stage: 'bootstrap';
+        readonly disposition: 'required';
+    }, {
+        readonly stage: 'steady';
+        readonly disposition: 'required';
+    }];
+    readonly code: "MACHINE_CPU_BELOW_FLOOR";
+    readonly isIssued: typeof isHostObservation;
+    readonly issuedAt: typeof observationIssuedAt;
+}, {
+    readonly id: 'machine-disk';
+    readonly owner: "host-observation";
+    readonly postures: readonly ["machine-floor"];
+    readonly stages: readonly [{
+        readonly stage: 'bootstrap';
+        readonly disposition: 'required';
+    }, {
+        readonly stage: 'steady';
+        readonly disposition: 'required';
+    }];
+    readonly code: "MACHINE_DISK_BELOW_FLOOR";
+    readonly isIssued: typeof isHostObservation;
+    readonly issuedAt: typeof observationIssuedAt;
+}];
+declare function isHostObservation(value: unknown): value is EnvironmentObservation;
+declare function observationIssuedAt(value: unknown): number | undefined;
+export interface HostCapacityFloor {
+    readonly memoryBytes: number;
+    readonly cpuMillis: number;
+    readonly freeDiskBytes: number;
+}
+export declare function observeHostCapacity(input: {
+    readonly evidence: MachineFloorEvidence;
+}): readonly EnvironmentObservation[];
+export {};

package/dist/environment/host-observation.js

@@ -0,0 +1,52 @@
+import { exactKeys } from '../exact-keys.js';
+import { RefusalError, ENVIRONMENT_CODES, snapshotEnvironmentObservation, snapshotJson, } from './contract.js';
+import { isMachineFloorEvidence } from './runtime.js';
+const OWNER = 'host-observation';
+export const observationDeclarations = Object.freeze([
+    { id: 'machine-memory', owner: OWNER, postures: ['machine-floor'], stages: [{ stage: 'bootstrap', disposition: 'required' }, { stage: 'steady', disposition: 'required' }], code: ENVIRONMENT_CODES.MACHINE_MEMORY_BELOW_FLOOR, isIssued: isHostObservation, issuedAt: observationIssuedAt },
+    { id: 'machine-cpu', owner: OWNER, postures: ['machine-floor'], stages: [{ stage: 'bootstrap', disposition: 'required' }, { stage: 'steady', disposition: 'required' }], code: ENVIRONMENT_CODES.MACHINE_CPU_BELOW_FLOOR, isIssued: isHostObservation, issuedAt: observationIssuedAt },
+    { id: 'machine-disk', owner: OWNER, postures: ['machine-floor'], stages: [{ stage: 'bootstrap', disposition: 'required' }, { stage: 'steady', disposition: 'required' }], code: ENVIRONMENT_CODES.MACHINE_DISK_BELOW_FLOOR, isIssued: isHostObservation, issuedAt: observationIssuedAt },
+]);
+const issuedObservations = new WeakMap();
+function issueObservation(value) {
+    const snapshot = snapshotEnvironmentObservation(value);
+    if (!snapshot || snapshot.owner !== OWNER)
+        throw new RefusalError('host observation is malformed');
+    issuedObservations.set(snapshot, Date.now());
+    return snapshot;
+}
+function isHostObservation(value) {
+    return value !== null && typeof value === 'object' && issuedObservations.has(value);
+}
+function observationIssuedAt(value) {
+    return value !== null && typeof value === 'object' ? issuedObservations.get(value) : undefined;
+}
+function metric(stackId, evidence, code, source, measured, expectation, remedy) {
+    return issueObservation({
+        code, owner: OWNER, stackId, source,
+        observed: { state: 'available', value: measured, observedAt: evidence.observedAt },
+        expectation,
+        applicability: { state: 'required', posture: 'machine-floor' },
+        freshness: { state: 'current' }, remedy,
+    });
+}
+export function observeHostCapacity(input) {
+    if (input === null || typeof input !== 'object' || Object.keys(input).length !== 1 || !isMachineFloorEvidence(input.evidence)) {
+        throw new RefusalError('machine-floor evidence is not authentic');
+    }
+    const evidence = input.evidence;
+    const stackId = evidence.stackId;
+    const floor = snapshotJson(evidence.floor);
+    if (typeof stackId !== 'string' || !/^stack:[a-f0-9]{64}$/.test(stackId)
+        || floor === null || typeof floor !== 'object' || Array.isArray(floor)
+        || !exactKeys(floor, ['cpuMillis', 'freeDiskBytes', 'memoryBytes'])
+        || Object.values(floor).some((value) => !Number.isSafeInteger(value) || value < 1)) {
+        throw new RefusalError('host capacity floor must use exact positive integer units');
+    }
+    const threshold = floor;
+    return [
+        metric(stackId, evidence, ENVIRONMENT_CODES.MACHINE_MEMORY_BELOW_FLOOR, 'runtime-memory-bytes', evidence.memoryBytes, { kind: 'minimum', value: threshold.memoryBytes }, 'make the declared runtime memory available'),
+        metric(stackId, evidence, ENVIRONMENT_CODES.MACHINE_CPU_BELOW_FLOOR, 'runtime-cpu-millis', evidence.cpuMillis, { kind: 'minimum', value: threshold.cpuMillis }, 'make the declared runtime CPU capacity available'),
+        metric(stackId, evidence, ENVIRONMENT_CODES.MACHINE_DISK_BELOW_FLOOR, 'free-disk-bytes', evidence.freeDiskBytes, { kind: 'minimum', value: threshold.freeDiskBytes }, 'free disk space or lower the declared floor deliberately'),
+    ];
+}

package/dist/environment/identity.d.ts

@@ -0,0 +1,48 @@
+import type { CheckoutId, CockpitId, HolderId, StackId } from './contract.js';
+declare const bootstrapLockOwnerBrand: unique symbol;
+export type BootstrapLockOwnerId = string & {
+    readonly [bootstrapLockOwnerBrand]: 'BootstrapLockOwnerId';
+};
+export type StackVariant = {
+    readonly kind: 'shared';
+} | {
+    readonly kind: 'named';
+    readonly name: string;
+};
+export interface CanonicalMainCheckoutEvidence {
+    readonly mainCheckoutPath: string;
+}
+export interface CanonicalCheckoutEvidence {
+    readonly checkoutPath: string;
+}
+export declare function cockpitId(input: {
+    readonly name: string;
+} & CanonicalMainCheckoutEvidence): CockpitId;
+export declare function publicationCockpitId(input: {
+    readonly name: string;
+}): CockpitId;
+export declare function checkoutId(input: CanonicalCheckoutEvidence): CheckoutId;
+export declare function stackId(input: {
+    readonly cockpitId: CockpitId;
+    readonly checkoutId: CheckoutId;
+    readonly variant: StackVariant;
+}): StackId;
+/**
+ * The Compose project a stack runs as. Named after the cockpit alone, two checkouts or two cockpits
+ * sharing a name became one project on one daemon and replaced each other's containers. The stack
+ * id is per checkout and never follows the configuration's bytes, so the name survives every edit.
+ */
+export declare function composeProjectName(input: {
+    readonly cockpitName: string;
+    readonly stackId: StackId;
+}): string;
+export declare function holderId(input: {
+    readonly stackId: StackId;
+    readonly checkoutId: CheckoutId;
+    readonly sessionId: string;
+}): HolderId;
+export declare function bootstrapHolderId(input: {
+    readonly checkoutId: CheckoutId;
+    readonly sessionId: string;
+}): BootstrapLockOwnerId;
+export {};

package/dist/environment/identity.js

@@ -0,0 +1,85 @@
+import { createHash } from 'node:crypto';
+import { isAbsolute, normalize } from 'node:path';
+import { RefusalError } from './contract.js';
+const COCKPIT_NAME = /^[a-z0-9][a-z0-9-]*$/;
+const STACK_NAME = /^[a-z0-9][a-z0-9-]*$/;
+const COCKPIT_ID = /^cockpit:[a-z0-9][a-z0-9-]*:[a-f0-9]{64}$/;
+const CHECKOUT_ID = /^checkout:[a-f0-9]{64}$/;
+const STACK_ID = /^stack:[a-f0-9]{64}$/;
+function digest(parts) {
+    const hash = createHash('sha256');
+    for (const part of parts) {
+        hash.update(String(Buffer.byteLength(part, 'utf8')));
+        hash.update(':');
+        hash.update(part);
+    }
+    return hash.digest('hex');
+}
+function canonicalPath(value, field) {
+    if (typeof value !== 'string' || value.includes('\0') || !isAbsolute(value) || normalize(value) !== value) {
+        throw new RefusalError(`identity: ${field} must be a canonical absolute path`);
+    }
+    return value;
+}
+function closedIdentity(value, pattern, field) {
+    if (typeof value !== 'string' || !pattern.test(value)) {
+        throw new RefusalError(`identity: ${field} is malformed`);
+    }
+    return value;
+}
+export function cockpitId(input) {
+    if (typeof input?.name !== 'string' || !COCKPIT_NAME.test(input.name)) {
+        throw new RefusalError('identity: cockpit name must use lowercase letters, digits, and hyphens');
+    }
+    const mainCheckoutPath = canonicalPath(input.mainCheckoutPath, 'mainCheckoutPath');
+    return `cockpit:${input.name}:${digest([mainCheckoutPath])}`;
+}
+export function publicationCockpitId(input) {
+    if (typeof input?.name !== 'string' || !COCKPIT_NAME.test(input.name)) {
+        throw new RefusalError('identity: cockpit name must use lowercase letters, digits, and hyphens');
+    }
+    return `cockpit:${input.name}:${digest(['publication', input.name])}`;
+}
+export function checkoutId(input) {
+    const checkoutPath = canonicalPath(input?.checkoutPath, 'checkoutPath');
+    return `checkout:${digest([checkoutPath])}`;
+}
+export function stackId(input) {
+    const cockpit = closedIdentity(input?.cockpitId, COCKPIT_ID, 'cockpitId');
+    const checkout = closedIdentity(input?.checkoutId, CHECKOUT_ID, 'checkoutId');
+    const variant = input?.variant;
+    if (variant?.kind === 'shared') {
+        return `stack:${digest([cockpit, checkout, 'shared'])}`;
+    }
+    if (variant?.kind === 'named' && STACK_NAME.test(variant.name)) {
+        return `stack:${digest([cockpit, checkout, 'named', variant.name])}`;
+    }
+    throw new RefusalError('identity: stack variant is malformed');
+}
+/**
+ * The Compose project a stack runs as. Named after the cockpit alone, two checkouts or two cockpits
+ * sharing a name became one project on one daemon and replaced each other's containers. The stack
+ * id is per checkout and never follows the configuration's bytes, so the name survives every edit.
+ */
+export function composeProjectName(input) {
+    if (typeof input?.cockpitName !== 'string' || !COCKPIT_NAME.test(input.cockpitName)) {
+        throw new RefusalError('identity: cockpit name must use lowercase letters, digits, and hyphens');
+    }
+    const stack = closedIdentity(input.stackId, STACK_ID, 'stackId');
+    return `${input.cockpitName}-${stack.slice('stack:'.length, 'stack:'.length + 12)}`;
+}
+export function holderId(input) {
+    const stack = closedIdentity(input?.stackId, STACK_ID, 'stackId');
+    const checkout = closedIdentity(input?.checkoutId, CHECKOUT_ID, 'checkoutId');
+    if (typeof input.sessionId !== 'string' || input.sessionId.length === 0 || input.sessionId.includes('\0')) {
+        throw new RefusalError('identity: sessionId must be a non-empty string without NUL bytes');
+    }
+    return `holder:${digest([stack, checkout, 'session', input.sessionId])}:session`;
+}
+export function bootstrapHolderId(input) {
+    const checkout = closedIdentity(input?.checkoutId, CHECKOUT_ID, 'checkoutId');
+    if (typeof input.sessionId !== 'string' || input.sessionId.length === 0 || input.sessionId.includes('\0')) {
+        throw new RefusalError('identity: sessionId must be a non-empty string without NUL bytes');
+    }
+    return `bootstrap-holder:${digest([checkout, 'session', input.sessionId])}:session`;
+}

package/dist/environment/init-application.d.ts

@@ -0,0 +1,333 @@
+import type { Diagnostic } from '../diagnostics.js';
+import { type ReadinessReport } from '../readiness.js';
+import { type AnswerProvenance, type DocumentCommandInput, type DocumentOutcome, type EstateClassificationOutcome, type EstateClassificationResult, type DerivedAnswer, type UnconfirmedAnswer, type EstateObservationInput } from '../init/draft.js';
+import { type SurfaceTarget } from '../surfaces/contract.js';
+import { type BootstrapStateAddress, type BootstrapStateRecord, type SelectBootstrapStateRootInput, type StateResult } from './state.js';
+export interface InitApplicationInput {
+    readonly root: string;
+    /** The tool whose setup skill init publishes before the interview; the first of tools. */
+    readonly target: SurfaceTarget;
+    /** Every tool the person chose, written as surfaces.tools; the final sync renders each one. */
+    readonly tools: readonly SurfaceTarget[];
+    readonly registry?: string;
+    readonly accepted: boolean;
+    readonly acceptedPreviewSha256?: string;
+    readonly sessionId: string;
+    readonly platform: SelectBootstrapStateRootInput['platform'];
+    readonly home: string | undefined;
+    readonly xdgStateHome?: string;
+    readonly uid?: number;
+    readonly greenfieldAnswer?: Readonly<{
+        questionId: string;
+        bytes: string;
+        provenance: AnswerProvenance;
+    }>;
+    readonly resetAnswer?: Readonly<{
+        field: string;
+        acceptedPreviewSha256?: string;
+    }>;
+    /**
+     * The operator's answer to where the cockpit lives, required when root is a product repository.
+     * For "dedicated", root is the new cockpit folder and firstSibling the product repository beside it.
+     */
+    readonly cockpitRoot?: Readonly<{
+        kind: 'in-repo';
+    }> | Readonly<{
+        kind: 'dedicated';
+        firstSibling: string;
+    }>;
+}
+type CockpitRootAnswer = 'dedicated' | 'in-repo';
+interface CockpitRootOption {
+    readonly answer: CockpitRootAnswer;
+    readonly root: string;
+    /** Directories init creates before it writes anything else; each is outside the directory init ran in. */
+    readonly creates: readonly string[];
+    readonly siblingsRoot: string;
+    readonly firstSibling: string;
+    readonly tradeOff: string;
+    /** Set when this option cannot be taken here; init refuses it before creating anything. */
+    readonly unavailable?: string;
+}
+/** Asked before anything is written, because the answer decides which directory init writes into. */
+export interface CockpitRootQuestion {
+    readonly field: 'cockpit.root';
+    readonly why: string;
+    readonly recommended: CockpitRootAnswer;
+    readonly options: readonly CockpitRootOption[];
+}
+interface DigestRow {
+    readonly path: string;
+    readonly sha256: string;
+}
+interface BootstrapProjection {
+    readonly root: string;
+    readonly target: SurfaceTarget;
+    readonly sources: readonly DigestRow[];
+    readonly files: readonly DigestRow[];
+    readonly previewSha256: string;
+}
+interface OwnerOutcome {
+    readonly kind: string;
+    readonly status: number;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly result: unknown;
+}
+export interface SelectedBootstrapPublicationAuthority {
+    readonly kind: 'selected-bootstrap-publication-authority';
+}
+type PreparedBootstrapOutcome = Readonly<{
+    kind: 'complete';
+    status: 0;
+    diagnostics: readonly Diagnostic[];
+    result: BootstrapProjection;
+    authority: SelectedBootstrapPublicationAuthority;
+}> | Readonly<{
+    kind: 'refusal';
+    status: 2;
+    diagnostics: readonly Diagnostic[];
+    result: null;
+}>;
+type AppliedBootstrapOutcome = Readonly<{
+    kind: 'complete';
+    status: 0;
+    diagnostics: readonly Diagnostic[];
+    result: BootstrapProjection;
+    authority: SelectedBootstrapPublicationAuthority;
+}> | Readonly<{
+    kind: 'refusal';
+    status: 2;
+    diagnostics: readonly Diagnostic[];
+    result: null;
+}>;
+type ResumedBootstrapOutcome = Readonly<{
+    kind: 'complete';
+    status: 0;
+    diagnostics: readonly Diagnostic[];
+    result: BootstrapProjection;
+    canonicalOwnership: true;
+}> | Readonly<{
+    kind: 'refresh';
+    status: 0;
+    diagnostics: readonly Diagnostic[];
+    result: BootstrapProjection;
+    authority: SelectedBootstrapPublicationAuthority;
+    canonicalOwnership: false;
+}> | Readonly<{
+    kind: 'pending';
+    status: 0;
+    diagnostics: readonly Diagnostic[];
+    result: null;
+    canonicalOwnership: false;
+}> | Readonly<{
+    kind: 'refusal';
+    status: 2;
+    diagnostics: readonly Diagnostic[];
+    result: null;
+}>;
+type DestinationObservation = Readonly<{
+    kind: 'absent';
+}> | Readonly<{
+    kind: 'available';
+    sha256: string;
+}> | Readonly<{
+    kind: 'refusal';
+    diagnostics: readonly Diagnostic[];
+}>;
+export interface InitApplicationAdapters {
+    readonly now: () => string;
+    readonly prepareBootstrap: (input: Readonly<{
+        root: string;
+        target: SurfaceTarget;
+        tools: readonly SurfaceTarget[];
+    }>) => Promise<PreparedBootstrapOutcome>;
+    readonly resumeBootstrap: (input: Readonly<{
+        root: string;
+        target: SurfaceTarget;
+        tools: readonly SurfaceTarget[];
+        address: BootstrapStateAddress;
+        expectedRevision?: number;
+        expectedCommandSha256?: string;
+    }>) => Promise<ResumedBootstrapOutcome>;
+    readonly applyBootstrap: (authority: SelectedBootstrapPublicationAuthority) => Promise<AppliedBootstrapOutcome>;
+    readonly document: (input: DocumentCommandInput) => Promise<DocumentOutcome>;
+    readonly observeDestination: (input: Readonly<{
+        path: string;
+        byteLimit: number;
+    }>) => Promise<DestinationObservation>;
+    readonly validateConfig: (path: string) => Promise<OwnerOutcome>;
+    readonly synchronize: (input: Readonly<{
+        configPath: string;
+        bootstrapState?: Readonly<{
+            publication: StateResult<BootstrapStateRecord>;
+            address: BootstrapStateAddress;
+        }>;
+    }>) => Promise<OwnerOutcome>;
+    readonly check: (input: Readonly<{
+        configPath: string;
+    }>) => Promise<OwnerOutcome>;
+    readonly preflight: (input: Readonly<{
+        configPath: string;
+    }>) => Promise<OwnerOutcome>;
+    readonly classifyEstate?: (input: EstateObservationInput) => Promise<EstateClassificationOutcome>;
+    /** Says whether root is a product repository, which makes init ask where the cockpit lives. */
+    readonly observeRoot?: (input: Readonly<{
+        root: string;
+    }>) => Promise<'product-repository' | 'cockpit-root'>;
+    /** Proposes answers from files the repositories already carry, each derived (exact and complete) or inferred. */
+    readonly infer?: (input: Readonly<{
+        root: string;
+        configurationRoot?: string;
+        repositories: readonly Readonly<{
+            slug: string;
+            path: string;
+        }>[];
+    }>) => Promise<Readonly<{
+        facts: readonly Readonly<{
+            fields: readonly string[];
+            target: string;
+            value: unknown;
+            provenance: Readonly<{
+                kind: 'derived' | 'inferred';
+                source: string;
+                reason: string;
+            }>;
+        }>[];
+        skipped: readonly Readonly<{
+            source: string;
+            reason: string;
+        }>[];
+    }>>;
+    /** What the container runtime on this machine offers, read when the interview will ask for the machine floor. */
+    readonly measureMachine?: (input: Readonly<{
+        root: string;
+    }>) => Promise<MachineMeasurement>;
+    /** What check would report about the Compose files a drafted cockpit.toml declares; init never edits them, so it shows the edit. */
+    readonly composeFindings?: (input: Readonly<{
+        root: string;
+        draft: string;
+    }>) => Promise<readonly Diagnostic[]>;
+    /**
+     * Findings about prerequisites no init stage checks (the root's Git working tree, the cockpit's
+     * own install, sibling remotes, committed secret files), and whether a runtime is declared.
+     */
+    readonly inspectReadiness?: (input: Readonly<{
+        root: string;
+        configPath?: string;
+        repositories: readonly Readonly<{
+            slug: string;
+            root: string;
+        }>[];
+        checkRoot: boolean;
+        tools: readonly string[];
+        classification?: string;
+    }>) => Promise<Readonly<{
+        state: ReadinessReport['state'];
+        findings: readonly Diagnostic[];
+    }>>;
+}
+interface GreenfieldQuestion {
+    readonly id: string;
+    readonly field: string;
+    readonly source: string;
+    readonly why: string;
+    readonly expectedSha256?: string;
+    /** Lines preserve the owner draft exactly when joined with a newline, within bounded human rendering. */
+    readonly document?: readonly string[];
+}
+interface GreenfieldResult extends EstateClassificationResult {
+    readonly sourceObservationSha256: string;
+    readonly answers: readonly Readonly<{
+        questionId: string;
+        bytes: string;
+        sha256: string;
+        provenance: AnswerProvenance;
+    }>[];
+}
+type MachineMeasurement = Readonly<{
+    kind: 'complete';
+    memoryMb: number;
+    cpus: number;
+    observedAt: string;
+}> | Readonly<{
+    kind: 'unavailable';
+    reason: string;
+}>;
+/**
+ * One proposed value for an unanswered field, and how it was established: "derived" is the complete
+ * answer read exactly from the named file and line, "measured" was observed on this machine, and
+ * "inferred" is a hint or partial value that needs judgement.
+ */
+interface Proposal {
+    readonly target: string;
+    readonly value: unknown;
+    readonly provenance: Readonly<{
+        kind: 'derived' | 'measured' | 'inferred';
+        source: string;
+        reason: string;
+    }>;
+}
+interface OutstandingField {
+    readonly field: string;
+    readonly why: string;
+    /**
+     * "agent" when a derived proposal answers the whole field: the setup agent may accept it with
+     * provenance "derived", and bring-up proves it. Everything else needs a person: security
+     * boundaries, and values that are inferred, measured or chosen.
+     */
+    readonly confirmedBy: 'agent' | 'person';
+    readonly proposals: readonly Proposal[];
+}
+/** Every field the interview will still ask, in order, so an unattended caller can answer them in one pass. */
+interface InterviewPlan {
+    /** Fields an earlier run already answered; their answers are kept. */
+    readonly answered: readonly string[];
+    readonly outstanding: readonly OutstandingField[];
+    readonly inferenceSkipped: readonly Readonly<{
+        source: string;
+        reason: string;
+    }>[];
+    /** Where the accepted cockpit lives, when init runs for a product repository; it is kept like any other answer. */
+    readonly cockpitRoot?: CockpitRootAnswer;
+}
+export interface InitResult {
+    readonly stage: BootstrapStateRecord['value']['stage'];
+    readonly root: string;
+    readonly target: SurfaceTarget;
+    readonly previewSha256: string;
+    readonly files: readonly DigestRow[];
+    readonly ownerOutcome?: OwnerOutcome;
+    readonly question?: GreenfieldQuestion;
+    readonly estate?: GreenfieldResult;
+    readonly interview?: InterviewPlan;
+    readonly cockpitRoot?: CockpitRootQuestion;
+    readonly resetAnswer?: Readonly<{
+        field: string;
+        revision: number;
+        invalidatedFields: readonly string[];
+        previewSha256: string;
+    }>;
+    /** Answers in cockpit.toml no person stated; each stays listed there, and doctor warns, until someone confirms it. */
+    readonly unconfirmed?: readonly UnconfirmedAnswer[];
+    /** Answers the setup agent accepted as read from exact sources, each with the file and line it came from. */
+    readonly derived?: readonly DerivedAnswer[];
+    /** This run's findings grouped under the prerequisites cockpit depends on: what to do next. */
+    readonly readiness?: ReadinessReport;
+}
+interface InitOutcomeBase {
+    readonly status: number;
+    readonly artifact: string | null;
+    readonly destination: string | null;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly result: InitResult | null;
+}
+export type InitApplicationOutcome = (InitOutcomeBase & Readonly<{
+    kind: 'pending' | 'artifact' | 'complete';
+    status: 0;
+}>) | (InitOutcomeBase & Readonly<{
+    kind: 'pending-dependency' | 'refusal';
+    status: 2;
+}>);
+export declare function unsupportedInitPlatformOutcome(platform: string): InitApplicationOutcome;
+export declare function runInitApplication(input: InitApplicationInput, adapters: InitApplicationAdapters): Promise<InitApplicationOutcome>;
+export {};