@tomflow/proflow-platform-cli 0.1.13 → 0.1.15

package/dist/src/planner/plan.js

@@ -1,144 +0,0 @@
-import { PlatformError } from "../errors.js";
-import { buildDependencyGraph } from "../graph/graph.js";
-import { assemblePlan } from "./assemble.js";
-import { planRepair } from "./repair.js";
-import { configStep, createSequencer, externalResourceStep, humanActionsFromModules, humanStep, lifecycleStep, packageStep, upstreamDependencies, } from "./steps.js";
-import { planUpgrade } from "./upgrade.js";
-export function planDeployment(input) {
-    switch (input.intent) {
-        case "upgrade":
-            return input.modules?.every((module) => module.source.type === "registry")
-                ? planRegistryPackageUpgrade(input)
-                : planUpgrade(input);
-        case "repair":
-            return planRepair(input);
-        case "uninstall":
-            return planUninstall(input);
-        case "install":
-        case "configure":
-            return planInstallOrConfigure(input);
-    }
-}
-function planRegistryPackageUpgrade(input) {
-    const modules = input.modules;
-    if (modules === undefined) {
-        throw new PlatformError("INVALID_REQUEST", "registry-backed upgrade requires modules");
-    }
-    const graph = buildDependencyGraph(modules);
-    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
-    const seq = createSequencer();
-    const steps = [];
-    for (const ref of graph.order) {
-        const module = byRef.get(ref);
-        if (module === undefined)
-            continue;
-        steps.push(packageStep(seq, module, "upgrade", []));
-    }
-    return assemblePlan({
-        intent: "upgrade",
-        modules,
-        targets: input.targets ?? [],
-        config: undefined,
-        steps,
-        humanActions: [],
-        now: input.now ?? new Date(),
-    });
-}
-function planInstallOrConfigure(input) {
-    const modules = input.modules;
-    if (modules === undefined) {
-        throw new PlatformError("INVALID_REQUEST", `${input.intent} requires modules`);
-    }
-    const graph = buildDependencyGraph(modules);
-    const steps = input.intent === "install"
-        ? installSteps(modules, graph)
-        : configureSteps(modules, graph, input.targets ?? [], input.config);
-    return assemblePlan({
-        intent: input.intent,
-        modules,
-        targets: input.targets ?? [],
-        config: input.config,
-        steps,
-        humanActions: input.intent === "install" ? humanActionsFromModules(modules) : [],
-        now: input.now ?? new Date(),
-    });
-}
-function installSteps(modules, graph) {
-    const seq = createSequencer();
-    const deps = upstreamDependencies(graph);
-    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
-    const steps = [];
-    for (const ref of graph.order) {
-        const module = byRef.get(ref);
-        if (module === undefined)
-            continue;
-        const dependencies = deps.get(ref) ?? [];
-        steps.push(packageStep(seq, module, "install", dependencies));
-        if (module.configSlots.length > 0) {
-            steps.push(configStep(seq, module));
-        }
-        if (module.kind === "external-resource") {
-            const step = externalResourceStep(seq, module);
-            if (step !== undefined)
-                steps.push(step);
-        }
-        for (const requirement of module.requirements) {
-            if (requirement.kind === "human") {
-                steps.push(humanStep(seq, module, requirement.action));
-            }
-        }
-    }
-    return steps;
-}
-function configureSteps(modules, graph, targets, config) {
-    const seq = createSequencer();
-    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
-    const targetByRef = new Map(targets.map((target) => [target.moduleRef, target]));
-    const steps = [];
-    for (const ref of graph.order) {
-        const module = byRef.get(ref);
-        if (module === undefined || module.configSlots.length === 0)
-            continue;
-        const explicitConfig = targetByRef.get(ref)?.config;
-        const providedConfig = config?.[ref];
-        const hasMaterializationTarget = (explicitConfig !== undefined &&
-            Object.keys(explicitConfig).length > 0) ||
-            (providedConfig !== undefined && Object.keys(providedConfig).length > 0);
-        if (!hasMaterializationTarget)
-            continue;
-        steps.push(configStep(seq, module));
-    }
-    return steps;
-}
-function planUninstall(input) {
-    const modules = input.modules;
-    if (modules === undefined || modules.length === 0) {
-        throw new PlatformError("INVALID_REQUEST", "uninstall requires modules");
-    }
-    const core = modules.find((module) => module.installClass === "core");
-    if (core !== undefined && input.uninstallScope !== "platform-instance") {
-        throw new PlatformError("CORE_PACKAGE_REQUIRED", `core module ${core.moduleRef} cannot be individually uninstalled`);
-    }
-    const graph = buildDependencyGraph(modules);
-    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
-    const seq = createSequencer();
-    const steps = [];
-    for (const ref of [...graph.order].reverse()) {
-        const module = byRef.get(ref);
-        if (module === undefined)
-            continue;
-        if (module.lifecycle.includes("uninstall")) {
-            steps.push(lifecycleStep(seq, module, "uninstall"));
-        }
-        steps.push(packageStep(seq, module, "remove", []));
-    }
-    return assemblePlan({
-        intent: "uninstall",
-        modules,
-        targets: input.targets ?? [],
-        config: undefined,
-        steps,
-        humanActions: [],
-        now: input.now ?? new Date(),
-    });
-}

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

@@ -1,28 +0,0 @@
-import type { DeploymentPlan, ModuleTarget, ResolvedModule } from "../contracts.ts";
-import type { DoctorReport } from "../doctor/doctor.ts";
-export declare const repairFactCodes: readonly ["CONFIG_MISSING", "LIFECYCLE_NOT_RUNNING", "VERIFY_FAILED", "EXTERNAL_RESOURCE_UNAVAILABLE", "ACTION_REQUIRED", "DEPENDENCY_UNRESOLVED"];
-export type RepairFactCode = (typeof repairFactCodes)[number];
-export interface RepairFact {
-    moduleRef: string;
-    code: RepairFactCode;
-    message: string;
-}
-export interface RepairPlanInput {
-    modules?: readonly ResolvedModule[];
-    targets?: readonly ModuleTarget[];
-    config?: Record<string, Record<string, string>>;
-    facts?: readonly RepairFact[];
-    now?: Date;
-}
-export interface RepairBlockedReason {
-    moduleRef: string;
-    code: string;
-    message: string;
-}
-export interface RepairDiagnosis {
-    facts: RepairFact[];
-    blocked: RepairBlockedReason[];
-}
-export declare function repairFactsFromDoctor(report: DoctorReport): RepairDiagnosis;
-export declare function diagnoseRepair(reports: readonly DoctorReport[]): RepairDiagnosis;
-export declare function planRepair(input: RepairPlanInput): DeploymentPlan;

package/dist/src/planner/repair.js

@@ -1,131 +0,0 @@
-import { PlatformError } from "../errors.js";
-import { assemblePlan } from "./assemble.js";
-import { configStep, createSequencer, externalResourceStep, humanStep, lifecycleStep, } from "./steps.js";
-export const repairFactCodes = [
-    "CONFIG_MISSING",
-    "LIFECYCLE_NOT_RUNNING",
-    "VERIFY_FAILED",
-    "EXTERNAL_RESOURCE_UNAVAILABLE",
-    "ACTION_REQUIRED",
-    "DEPENDENCY_UNRESOLVED",
-];
-// Frozen error codes that carry an automatic repair mapping. Everything else
-// is left BLOCKED for human review rather than inventing a mutation.
-const ERROR_CODE_TO_FACT = {
-    CONFIG_REQUIRED: "CONFIG_MISSING",
-    DEPENDENCY_UNRESOLVED: "DEPENDENCY_UNRESOLVED",
-    EXTERNAL_RESOURCE_UNAVAILABLE: "EXTERNAL_RESOURCE_UNAVAILABLE",
-    VERIFY_FAILED: "VERIFY_FAILED",
-};
-export function repairFactsFromDoctor(report) {
-    const facts = [];
-    const blocked = [];
-    if (report.nextAction.kind === "human-action") {
-        facts.push({
-            moduleRef: report.moduleRef,
-            code: "ACTION_REQUIRED",
-            message: report.nextAction.action,
-        });
-        return { facts, blocked };
-    }
-    if (report.status === "SUCCEEDED") {
-        return { facts, blocked };
-    }
-    if (report.errors.length === 0) {
-        blocked.push({
-            moduleRef: report.moduleRef,
-            code: report.status,
-            message: `module ${report.moduleRef} is ${report.status.toLowerCase()} with no typed error`,
-        });
-        return { facts, blocked };
-    }
-    for (const error of report.errors) {
-        const factCode = ERROR_CODE_TO_FACT[error.code];
-        if (factCode === undefined) {
-            blocked.push({
-                moduleRef: report.moduleRef,
-                code: error.code,
-                message: error.message,
-            });
-            continue;
-        }
-        facts.push({
-            moduleRef: report.moduleRef,
-            code: factCode,
-            message: error.message,
-        });
-    }
-    return { facts, blocked };
-}
-export function diagnoseRepair(reports) {
-    const facts = [];
-    const blocked = [];
-    for (const report of reports) {
-        const diagnosis = repairFactsFromDoctor(report);
-        facts.push(...diagnosis.facts);
-        blocked.push(...diagnosis.blocked);
-    }
-    return { facts, blocked };
-}
-export function planRepair(input) {
-    const modules = input.modules;
-    if (modules === undefined) {
-        throw new PlatformError("INVALID_REQUEST", "repair requires modules");
-    }
-    const facts = input.facts ?? [];
-    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
-    const seq = createSequencer();
-    const steps = [];
-    const humanActions = [];
-    const seen = new Set();
-    for (const fact of facts) {
-        const module = byRef.get(fact.moduleRef);
-        if (module === undefined)
-            continue;
-        const dedupeKey = `${fact.moduleRef}|${fact.code}`;
-        if (seen.has(dedupeKey))
-            continue;
-        seen.add(dedupeKey);
-        switch (fact.code) {
-            case "CONFIG_MISSING":
-                if (module.configSlots.length > 0) {
-                    steps.push(configStep(seq, module));
-                }
-                break;
-            case "LIFECYCLE_NOT_RUNNING":
-                if (module.lifecycle.includes("start")) {
-                    steps.push(lifecycleStep(seq, module, "start"));
-                }
-                break;
-            case "EXTERNAL_RESOURCE_UNAVAILABLE":
-                if (module.kind === "external-resource") {
-                    const step = externalResourceStep(seq, module);
-                    if (step !== undefined)
-                        steps.push(step);
-                }
-                break;
-            case "ACTION_REQUIRED":
-                steps.push(humanStep(seq, module, fact.message));
-                humanActions.push({
-                    action: fact.message,
-                    description: `action required for ${module.moduleRef}`,
-                });
-                break;
-            case "VERIFY_FAILED":
-                // Verification re-runs after repair; no mutation is invented here.
-                break;
-            case "DEPENDENCY_UNRESOLVED":
-                // Resolution requires a plan/human decision; no mutation is invented.
-                break;
-        }
-    }
-    return assemblePlan({
-        intent: "repair",
-        modules,
-        targets: input.targets ?? [],
-        config: input.config,
-        steps,
-        humanActions,
-        now: input.now ?? new Date(),
-    });
-}

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

@@ -1,7 +0,0 @@
-import type { DeploymentPlan } from "../contracts.ts";
-import { type PlanInput } from "./plan.ts";
-export interface StalenessResult {
-    stale: boolean;
-    reasons: string[];
-}
-export declare function checkPlanStale(plan: DeploymentPlan, current: PlanInput): StalenessResult;

package/dist/src/planner/stale.js

@@ -1,23 +0,0 @@
-import { buildFingerprintSource } from "./fingerprint.js";
-import { planDeployment } from "./plan.js";
-const COMPARED_FIELDS = [
-    "intent",
-    "targets",
-    "modules",
-    "steps",
-    "effects",
-    "humanActions",
-    "verification",
-];
-export function checkPlanStale(plan, current) {
-    const fresh = planDeployment(current);
-    const before = buildFingerprintSource(plan);
-    const after = buildFingerprintSource(fresh);
-    const reasons = [];
-    for (const field of COMPARED_FIELDS) {
-        if (before[field] !== after[field]) {
-            reasons.push(`${field} changed`);
-        }
-    }
-    return { stale: reasons.length > 0, reasons };
-}

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

@@ -1,37 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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;