@tomflow/proflow-platform-cli 0.1.0

package/dist/src/planner/steps.d.ts

@@ -0,0 +1,37 @@
+import type { HumanAction } from "@tomflow/proflow-module-contract";
+import type { DeploymentStep, ResolvedModule } from "../contracts.ts";
+import type { DependencyGraph } from "../graph/graph.ts";
+export declare const CheckStrategy: {
+    readonly packageInstalled: "package:installed";
+    readonly packageAbsent: "package:absent";
+    readonly configMaterialized: "config:materialized";
+    readonly lifecycleRunning: "lifecycle:running";
+    readonly lifecycleStopped: "lifecycle:stopped";
+    readonly externalResourceConfigured: "external-resource:configured";
+    readonly humanVerified: "human:verified";
+    readonly verifyChecksPass: "verify:checks-pass";
+    readonly migrateComplete: "migrate:complete";
+};
+export declare const ExecuteStrategy: {
+    readonly packageInstall: "package:install";
+    readonly packageUpgrade: "package:upgrade";
+    readonly packageRemove: "package:remove";
+    readonly configWrite: "config:write";
+    readonly lifecycleStart: "lifecycle:start";
+    readonly lifecycleStop: "lifecycle:stop";
+    readonly lifecycleRestart: "lifecycle:restart";
+    readonly lifecycleUninstall: "lifecycle:uninstall";
+    readonly lifecycleMigrate: "lifecycle:migrate";
+    readonly externalResourceConfigure: "external-resource:configure";
+};
+export interface StepSequencer {
+    next(kind: string, moduleRef: string): string;
+}
+export declare function createSequencer(): StepSequencer;
+export declare function upstreamDependencies(graph: DependencyGraph): Map<string, string[]>;
+export declare function packageStep(seq: StepSequencer, module: ResolvedModule, verb: "install" | "upgrade" | "remove", dependencies: readonly string[]): DeploymentStep;
+export declare function configStep(seq: StepSequencer, module: ResolvedModule): DeploymentStep;
+export declare function externalResourceStep(seq: StepSequencer, module: ResolvedModule): DeploymentStep | undefined;
+export declare function humanStep(seq: StepSequencer, module: ResolvedModule, action: string): DeploymentStep;
+export declare function lifecycleStep(seq: StepSequencer, module: ResolvedModule, action: "start" | "stop" | "restart" | "migrate" | "uninstall"): DeploymentStep;
+export declare function humanActionsFromModules(modules: readonly ResolvedModule[]): HumanAction[];

package/dist/src/planner/steps.js

@@ -0,0 +1,165 @@
+export const CheckStrategy = {
+    packageInstalled: "package:installed",
+    packageAbsent: "package:absent",
+    configMaterialized: "config:materialized",
+    lifecycleRunning: "lifecycle:running",
+    lifecycleStopped: "lifecycle:stopped",
+    externalResourceConfigured: "external-resource:configured",
+    humanVerified: "human:verified",
+    verifyChecksPass: "verify:checks-pass",
+    migrateComplete: "migrate:complete",
+};
+export const ExecuteStrategy = {
+    packageInstall: "package:install",
+    packageUpgrade: "package:upgrade",
+    packageRemove: "package:remove",
+    configWrite: "config:write",
+    lifecycleStart: "lifecycle:start",
+    lifecycleStop: "lifecycle:stop",
+    lifecycleRestart: "lifecycle:restart",
+    lifecycleUninstall: "lifecycle:uninstall",
+    lifecycleMigrate: "lifecycle:migrate",
+    externalResourceConfigure: "external-resource:configure",
+};
+export function createSequencer() {
+    let counter = 0;
+    return {
+        next(kind, moduleRef) {
+            counter += 1;
+            return `step-${String(counter).padStart(3, "0")}-${kind}-${moduleRef}`;
+        },
+    };
+}
+function compareRef(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+export function upstreamDependencies(graph) {
+    const map = new Map();
+    for (const edge of graph.edges) {
+        const list = map.get(edge.from) ?? [];
+        list.push(edge.to);
+        map.set(edge.from, list);
+    }
+    for (const list of map.values())
+        list.sort(compareRef);
+    return map;
+}
+export function packageStep(seq, module, verb, dependencies) {
+    const removing = verb === "remove";
+    return {
+        stepRef: seq.next("package", module.moduleRef),
+        moduleRef: module.moduleRef,
+        kind: "package",
+        preconditions: removing
+            ? []
+            : dependencies.map((dependency) => `dependency ${dependency} installed and verified`),
+        expectedEffect: removing
+            ? `module package ${module.packageName}@${module.moduleVersion} removed`
+            : `module package ${module.packageName}@${module.moduleVersion} ${verb === "install" ? "installed" : "upgraded"}`,
+        checkStrategy: removing
+            ? CheckStrategy.packageAbsent
+            : CheckStrategy.packageInstalled,
+        executeStrategy: removing
+            ? ExecuteStrategy.packageRemove
+            : verb === "install"
+                ? ExecuteStrategy.packageInstall
+                : ExecuteStrategy.packageUpgrade,
+        postcondition: removing
+            ? `package ${module.packageName} is absent from the Workspace installation`
+            : `installed version ${module.moduleVersion} satisfies ${module.moduleRef}`,
+    };
+}
+export function configStep(seq, module) {
+    return {
+        stepRef: seq.next("config", module.moduleRef),
+        moduleRef: module.moduleRef,
+        kind: "config",
+        preconditions: [`module package ${module.packageName} installed`],
+        expectedEffect: `configuration materialized for ${module.moduleRef}`,
+        checkStrategy: CheckStrategy.configMaterialized,
+        executeStrategy: ExecuteStrategy.configWrite,
+        postcondition: `all required config slots materialized for ${module.moduleRef}`,
+    };
+}
+export function externalResourceStep(seq, module) {
+    if (!module.lifecycle.includes("start")) {
+        // Status/verify-only external resources (e.g. chatgpt-carrier,
+        // chrome-runtime, model-provider-api) have no activation primitive.
+        // Their configuration is satisfied by config + human prerequisite +
+        // verification steps, never by a forged `start` mutation.
+        return undefined;
+    }
+    return {
+        stepRef: seq.next("external-resource", module.moduleRef),
+        moduleRef: module.moduleRef,
+        kind: "external-resource",
+        preconditions: [
+            `module package ${module.packageName} installed`,
+            `configuration materialized for ${module.moduleRef}`,
+        ],
+        expectedEffect: `external resource ${module.moduleRef} configured`,
+        checkStrategy: CheckStrategy.externalResourceConfigured,
+        executeStrategy: ExecuteStrategy.externalResourceConfigure,
+        postcondition: `external resource ${module.moduleRef} configured and reachable`,
+    };
+}
+export function humanStep(seq, module, action) {
+    return {
+        stepRef: seq.next("human", module.moduleRef),
+        moduleRef: module.moduleRef,
+        kind: "human",
+        preconditions: [],
+        expectedEffect: `human action completed: ${action}`,
+        checkStrategy: CheckStrategy.humanVerified,
+        postcondition: `human action "${action}" verified`,
+    };
+}
+export function lifecycleStep(seq, module, action) {
+    const executeStrategy = action === "start"
+        ? ExecuteStrategy.lifecycleStart
+        : action === "stop"
+            ? ExecuteStrategy.lifecycleStop
+            : action === "restart"
+                ? ExecuteStrategy.lifecycleRestart
+                : action === "uninstall"
+                    ? ExecuteStrategy.lifecycleUninstall
+                    : ExecuteStrategy.lifecycleMigrate;
+    const checkStrategy = action === "migrate"
+        ? CheckStrategy.migrateComplete
+        : action === "stop" || action === "uninstall"
+            ? CheckStrategy.lifecycleStopped
+            : CheckStrategy.lifecycleRunning;
+    const settled = action === "start" || action === "restart"
+        ? "running"
+        : action === "stop" || action === "uninstall"
+            ? "stopped"
+            : "migrated";
+    return {
+        stepRef: seq.next("lifecycle", module.moduleRef),
+        moduleRef: module.moduleRef,
+        kind: "lifecycle",
+        preconditions: [],
+        expectedEffect: `lifecycle ${action} completed for ${module.moduleRef}`,
+        checkStrategy,
+        executeStrategy,
+        postcondition: `module ${module.moduleRef} is ${settled}`,
+    };
+}
+export function humanActionsFromModules(modules) {
+    const actions = [];
+    const seen = new Set();
+    for (const module of modules) {
+        for (const requirement of module.requirements) {
+            if (requirement.kind !== "human")
+                continue;
+            if (seen.has(requirement.action))
+                continue;
+            seen.add(requirement.action);
+            actions.push({
+                action: requirement.action,
+                description: `human requirement for ${module.moduleRef}`,
+            });
+        }
+    }
+    return actions;
+}

package/dist/src/planner/target-catalog.d.ts

@@ -0,0 +1,13 @@
+import { type ModuleDescriptor } from "@tomflow/proflow-module-contract";
+/**
+ * A local target catalog resolved from a real target workspace on disk. Every
+ * descriptor is loaded from that workspace's actual `deployment/descriptor`
+ * artifacts (workspace packages win over declared installed dependencies). It
+ * never performs registry/npm "world" discovery and never fabricates a
+ * descriptor from a bare targetVersion string.
+ */
+export interface TargetCatalog {
+    root: string;
+    descriptors: ModuleDescriptor[];
+}
+export declare function resolveTargetCatalog(targetWorkspace: string): Promise<TargetCatalog>;

package/dist/src/planner/target-catalog.js

@@ -0,0 +1,48 @@
+import { parseModuleDescriptor, } from "@tomflow/proflow-module-contract";
+import { AutoModuleCatalog } from "../discovery/discover.js";
+import { readPackageJson } from "../discovery/workspace.js";
+import { PlatformError } from "../errors.js";
+export async function resolveTargetCatalog(targetWorkspace) {
+    const catalog = new AutoModuleCatalog(targetWorkspace);
+    const sources = await catalog.sources();
+    const descriptors = [];
+    const seen = new Set();
+    for (const source of sources) {
+        const descriptor = await loadTargetDescriptor(catalog, source);
+        if (seen.has(descriptor.moduleRef)) {
+            throw new PlatformError("DUPLICATE_IDENTITY", `duplicate moduleRef "${descriptor.moduleRef}" in target workspace ${targetWorkspace}`);
+        }
+        seen.add(descriptor.moduleRef);
+        descriptors.push(descriptor);
+    }
+    return { root: targetWorkspace, descriptors };
+}
+async function loadTargetDescriptor(catalog, source) {
+    let raw;
+    try {
+        raw = await catalog.loadDescriptor(source);
+    }
+    catch (error) {
+        if (error instanceof PlatformError)
+            throw error;
+        throw new PlatformError("DESCRIPTOR_INVALID", `failed to load target descriptor for ${source.packageName}: ${errorMessage(error)}`);
+    }
+    let descriptor;
+    try {
+        descriptor = parseModuleDescriptor(raw);
+    }
+    catch (error) {
+        throw new PlatformError("DESCRIPTOR_INVALID", `invalid target descriptor for ${source.packageName}: ${errorMessage(error)}`);
+    }
+    if (source.type === "workspace" && source.path !== undefined) {
+        const packageJson = await readPackageJson(source.path);
+        if (packageJson.version !== undefined &&
+            packageJson.version !== descriptor.moduleVersion) {
+            throw new PlatformError("DESCRIPTOR_INVALID", `moduleVersion ${descriptor.moduleVersion} does not match package.json version ${packageJson.version} for ${descriptor.moduleRef}`);
+        }
+    }
+    return descriptor;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/planner/upgrade.d.ts

@@ -0,0 +1,18 @@
+import { type ModuleDescriptor } from "@tomflow/proflow-module-contract";
+import type { DeploymentPlan } from "../contracts.ts";
+import type { PlanInput } from "./plan.ts";
+export interface UpgradeAssessment {
+    compatible: boolean;
+    breakingChanges: string[];
+    templateVersionChanged: boolean;
+    migrationDeclared: boolean;
+    migrationRequired: boolean;
+}
+export declare function assessUpgrade(current: ModuleDescriptor, target: ModuleDescriptor): UpgradeAssessment;
+/**
+ * Deterministic descriptor equality (key-order independent). Used to detect
+ * an already-satisfied upgrade target so we never emit a pretend
+ * `package:upgrade` mutation for an unchanged module.
+ */
+export declare function descriptorsEqual(current: ModuleDescriptor, target: ModuleDescriptor): boolean;
+export declare function planUpgrade(input: PlanInput): DeploymentPlan;

package/dist/src/planner/upgrade.js

@@ -0,0 +1,105 @@
+import { assessModuleCompatibility, } from "@tomflow/proflow-module-contract";
+import { PlatformError } from "../errors.js";
+import { buildDependencyGraph } from "../graph/graph.js";
+import { assemblePlan, toResolvedModule } from "./assemble.js";
+import { configStep, createSequencer, humanActionsFromModules, humanStep, lifecycleStep, packageStep, upstreamDependencies, } from "./steps.js";
+export function assessUpgrade(current, target) {
+    const assessment = assessModuleCompatibility(current, target);
+    const migrationDeclared = target.lifecycle.supported.includes("migrate");
+    return {
+        compatible: assessment.compatible,
+        breakingChanges: assessment.breakingChanges,
+        templateVersionChanged: current.templateVersion !== target.templateVersion,
+        migrationDeclared,
+        migrationRequired: migrationDeclared && assessment.breakingChanges.length > 0,
+    };
+}
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        const out = {};
+        for (const key of Object.keys(record).sort()) {
+            out[key] = canonicalize(record[key]);
+        }
+        return out;
+    }
+    return value;
+}
+/**
+ * Deterministic descriptor equality (key-order independent). Used to detect
+ * an already-satisfied upgrade target so we never emit a pretend
+ * `package:upgrade` mutation for an unchanged module.
+ */
+export function descriptorsEqual(current, target) {
+    return (JSON.stringify(canonicalize(current)) ===
+        JSON.stringify(canonicalize(target)));
+}
+export function planUpgrade(input) {
+    const currentDescriptors = input.currentDescriptors;
+    const targetDescriptors = input.targetDescriptors;
+    if (currentDescriptors === undefined || targetDescriptors === undefined) {
+        throw new PlatformError("INVALID_REQUEST", "upgrade requires currentDescriptors and targetDescriptors");
+    }
+    const modules = targetDescriptors.map(toResolvedModule);
+    const graph = buildDependencyGraph(modules);
+    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
+    const currentByRef = new Map(currentDescriptors.map((descriptor) => [descriptor.moduleRef, descriptor]));
+    const targetByRef = new Map(targetDescriptors.map((descriptor) => [descriptor.moduleRef, descriptor]));
+    const seq = createSequencer();
+    const deps = upstreamDependencies(graph);
+    const steps = [];
+    for (const ref of graph.order) {
+        const module = byRef.get(ref);
+        if (module === undefined)
+            continue;
+        const current = currentByRef.get(ref);
+        const target = targetByRef.get(ref);
+        if (current !== undefined &&
+            target !== undefined &&
+            descriptorsEqual(current, target)) {
+            // already satisfied: no pretend package/config/lifecycle mutation
+            continue;
+        }
+        const assessment = current !== undefined && target !== undefined
+            ? assessUpgrade(current, target)
+            : undefined;
+        if (assessment !== undefined &&
+            !assessment.compatible &&
+            !assessment.migrationDeclared) {
+            throw new PlatformError("UPGRADE_FAILED", `upgrade ${ref} has breaking changes but declares no migrate lifecycle: ${assessment.breakingChanges.join("; ")}`);
+        }
+        const dependencies = deps.get(ref) ?? [];
+        steps.push(packageStep(seq, module, "upgrade", dependencies));
+        if (module.configSlots.length > 0) {
+            steps.push(configStep(seq, module));
+        }
+        if (assessment?.migrationRequired === true) {
+            steps.push(lifecycleStep(seq, module, "migrate"));
+        }
+        if (module.kind === "service") {
+            if (module.lifecycle.includes("restart")) {
+                steps.push(lifecycleStep(seq, module, "restart"));
+            }
+            else if (module.lifecycle.includes("start")) {
+                steps.push(lifecycleStep(seq, module, "start"));
+            }
+        }
+        for (const requirement of module.requirements) {
+            if (requirement.kind === "human") {
+                steps.push(humanStep(seq, module, requirement.action));
+            }
+        }
+    }
+    return assemblePlan({
+        intent: "upgrade",
+        modules,
+        targets: input.targets ?? [],
+        config: input.config,
+        steps,
+        humanActions: humanActionsFromModules(modules),
+        now: input.now ?? new Date(),
+        targetDescriptors,
+    });
+}

package/dist/src/preflight/config.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedModule } from "../contracts.ts";
+import type { PreflightFinding } from "./findings.ts";
+export interface ResolvedModuleConfig {
+    moduleRef: string;
+    values: Record<string, string>;
+    secretRefs: string[];
+    missing: string[];
+}
+export declare function resolveModuleConfig(module: ResolvedModule, provided: Record<string, string> | undefined): ResolvedModuleConfig;
+export declare function checkConfigReadiness(modules: readonly ResolvedModule[], config: Record<string, Record<string, string>> | undefined): PreflightFinding[];

package/dist/src/preflight/config.js

@@ -0,0 +1,45 @@
+import { PlatformError } from "../errors.js";
+import { isValidSecretRef } from "../security/redact.js";
+function compareRef(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+export function resolveModuleConfig(module, provided) {
+    const values = {};
+    const secretRefs = [];
+    const missing = [];
+    for (const slot of module.configSlots) {
+        let value = provided?.[slot.key];
+        if (value === undefined && slot.default !== undefined) {
+            value = String(slot.default);
+        }
+        if (slot.required && value === undefined) {
+            missing.push(slot.key);
+            continue;
+        }
+        if (value === undefined)
+            continue;
+        values[slot.key] = value;
+        if (slot.type === "secretRef") {
+            if (!isValidSecretRef(value))
+                throw new PlatformError("SECRET_REF_INVALID", `secretRef config "${slot.key}" for ${module.moduleRef} must be an opaque reference identity (e.g. secret://provider/name)`);
+            secretRefs.push(slot.key);
+        }
+    }
+    return { moduleRef: module.moduleRef, values, secretRefs, missing };
+}
+export function checkConfigReadiness(modules, config) {
+    const findings = [];
+    const sorted = [...modules].sort((a, b) => compareRef(a.moduleRef, b.moduleRef));
+    for (const module of sorted) {
+        const resolved = resolveModuleConfig(module, config?.[module.moduleRef]);
+        for (const key of resolved.missing) {
+            findings.push({
+                code: "CONFIG_MISSING",
+                severity: "error",
+                moduleRef: module.moduleRef,
+                message: `missing required config "${key}" for ${module.moduleRef}`,
+            });
+        }
+    }
+    return findings;
+}

package/dist/src/preflight/findings.d.ts

@@ -0,0 +1,26 @@
+import type { PlatformState } from "../contracts.ts";
+import type { PlatformErrorCode } from "../errors.ts";
+import type { DependencyGraph } from "../graph/graph.ts";
+import type { RequirementProbe } from "./requirements.ts";
+export type FindingSeverity = "error" | "warning" | "action";
+export type PreflightFindingCode = PlatformErrorCode | "REQUIREMENT_FAIL" | "HUMAN_ACTION" | "MODULE_REF_UNRESOLVED" | "MODULE_PREFLIGHT_BLOCKED" | "MODULE_PREFLIGHT_FAILED" | "MODULE_PREFLIGHT_ACTION_REQUIRED";
+export interface PreflightFinding {
+    code: PreflightFindingCode;
+    severity: FindingSeverity;
+    moduleRef?: string;
+    message: string;
+}
+export type ModulePreflightStatus = "SUCCEEDED" | "ACTION_REQUIRED" | "BLOCKED" | "FAILED" | "UNBOUND";
+export interface ModulePreflightResult {
+    moduleRef: string;
+    status: ModulePreflightStatus;
+    message: string;
+}
+export interface PreflightResult {
+    ok: boolean;
+    status: PlatformState;
+    findings: PreflightFinding[];
+    requirementProbes: RequirementProbe[];
+    modulePreflight: ModulePreflightResult[];
+    dependency: DependencyGraph | undefined;
+}

package/dist/src/preflight/findings.js

@@ -0,0 +1 @@
+export {};

package/dist/src/preflight/index.d.ts

@@ -0,0 +1,7 @@
+export type { ResolvedModuleConfig } from "./config.ts";
+export { checkConfigReadiness, resolveModuleConfig } from "./config.ts";
+export type { FindingSeverity, ModulePreflightResult, ModulePreflightStatus, PreflightFinding, PreflightFindingCode, PreflightResult, } from "./findings.ts";
+export type { PreflightOptions } from "./preflight.ts";
+export { runPreflight } from "./preflight.ts";
+export type { ProbeStatus, RequirementProbe } from "./requirements.ts";
+export { probeAllRequirements, probeRequirement } from "./requirements.ts";

package/dist/src/preflight/index.js

@@ -0,0 +1,3 @@
+export { checkConfigReadiness, resolveModuleConfig } from "./config.js";
+export { runPreflight } from "./preflight.js";
+export { probeAllRequirements, probeRequirement } from "./requirements.js";

package/dist/src/preflight/preflight.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedModule } from "../contracts.ts";
+import type { ModuleCatalog } from "../modules.ts";
+import type { PreflightResult } from "./findings.ts";
+export interface PreflightOptions {
+    config?: Record<string, Record<string, string>>;
+    catalog?: ModuleCatalog;
+}
+export declare function runPreflight(modules: readonly ResolvedModule[], options?: PreflightOptions): Promise<PreflightResult>;

package/dist/src/preflight/preflight.js

@@ -0,0 +1,174 @@
+import { PlatformError } from "../errors.js";
+import { buildDependencyGraph, ModuleRefUnresolvedError, } from "../graph/graph.js";
+import { dispatchLifecycle } from "../lifecycle/index.js";
+import { checkConfigReadiness } from "./config.js";
+import { probeAllRequirements } from "./requirements.js";
+function compareRef(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+export async function runPreflight(modules, options = {}) {
+    const findings = [];
+    let dependency;
+    try {
+        dependency = buildDependencyGraph(modules, options.config === undefined ? {} : { config: options.config });
+    }
+    catch (error) {
+        if (error instanceof ModuleRefUnresolvedError) {
+            findings.push({
+                code: "MODULE_REF_UNRESOLVED",
+                severity: "error",
+                moduleRef: error.from,
+                message: error.message,
+            });
+        }
+        else if (error instanceof PlatformError) {
+            findings.push({
+                code: error.code,
+                severity: "error",
+                message: error.message,
+            });
+        }
+        else {
+            throw error;
+        }
+    }
+    findings.push(...checkConfigReadiness(modules, options.config));
+    const requirementProbes = await probeAllRequirements(modules);
+    for (const probe of requirementProbes) {
+        if (probe.status === "ACTION_REQUIRED") {
+            findings.push({
+                code: "HUMAN_ACTION",
+                severity: "action",
+                moduleRef: probe.moduleRef,
+                message: probe.message,
+            });
+        }
+        else if (probe.status === "FAIL") {
+            findings.push({
+                code: "REQUIREMENT_FAIL",
+                severity: "warning",
+                moduleRef: probe.moduleRef,
+                message: probe.message,
+            });
+        }
+    }
+    const modulePreflight = await runModulePreflight(modules, options.catalog);
+    for (const result of modulePreflight) {
+        findings.push(...toFindings(result));
+    }
+    const status = deriveStatus(findings);
+    return {
+        ok: status === "READY",
+        status,
+        findings,
+        requirementProbes,
+        modulePreflight,
+        dependency,
+    };
+}
+async function runModulePreflight(modules, catalog) {
+    if (catalog === undefined)
+        return [];
+    const sorted = [...modules].sort((a, b) => compareRef(a.moduleRef, b.moduleRef));
+    const results = [];
+    for (const module of sorted) {
+        if (!module.lifecycle.includes("preflight"))
+            continue;
+        results.push(await preflightOne(catalog, module));
+    }
+    return results;
+}
+async function preflightOne(catalog, module) {
+    try {
+        const dispatched = await dispatchLifecycle(catalog, module, "preflight");
+        const result = dispatched.result;
+        return {
+            moduleRef: module.moduleRef,
+            status: result.status,
+            message: modulePreflightMessage(module.moduleRef, result),
+        };
+    }
+    catch (error) {
+        return {
+            moduleRef: module.moduleRef,
+            status: "UNBOUND",
+            message: `module ${module.moduleRef} preflight unavailable: adapter is not bound to a runtime (${errorMessage(error)})`,
+        };
+    }
+}
+function modulePreflightMessage(moduleRef, result) {
+    switch (result.status) {
+        case "SUCCEEDED":
+            return `module ${moduleRef} preflight succeeded`;
+        case "ACTION_REQUIRED": {
+            const action = result.actionRequired;
+            return action !== undefined
+                ? `module ${moduleRef} preflight requires action "${action.action}"`
+                : `module ${moduleRef} preflight requires an unspecified human action`;
+        }
+        case "BLOCKED":
+        case "FAILED": {
+            const error = result.error;
+            return error !== undefined
+                ? `module ${moduleRef} preflight ${result.status.toLowerCase()}: ${error.code}: ${error.message}`
+                : `module ${moduleRef} preflight ${result.status.toLowerCase()}`;
+        }
+    }
+}
+function toFindings(result) {
+    switch (result.status) {
+        case "SUCCEEDED":
+            return [];
+        case "ACTION_REQUIRED":
+        case "UNBOUND":
+            return [
+                {
+                    code: "MODULE_PREFLIGHT_ACTION_REQUIRED",
+                    severity: "action",
+                    moduleRef: result.moduleRef,
+                    message: result.message,
+                },
+            ];
+        case "BLOCKED":
+            return [
+                {
+                    code: "MODULE_PREFLIGHT_BLOCKED",
+                    severity: "error",
+                    moduleRef: result.moduleRef,
+                    message: result.message,
+                },
+            ];
+        case "FAILED":
+            return [
+                {
+                    code: "MODULE_PREFLIGHT_FAILED",
+                    severity: "error",
+                    moduleRef: result.moduleRef,
+                    message: result.message,
+                },
+            ];
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function deriveStatus(findings) {
+    let hasError = false;
+    let hasAction = false;
+    let hasWarning = false;
+    for (const finding of findings) {
+        if (finding.severity === "error")
+            hasError = true;
+        else if (finding.severity === "action")
+            hasAction = true;
+        else if (finding.severity === "warning")
+            hasWarning = true;
+    }
+    if (hasError)
+        return "NOT_READY";
+    if (hasAction)
+        return "ACTION_REQUIRED";
+    if (hasWarning)
+        return "DEGRADED";
+    return "READY";
+}