@tomflow/proflow-platform-cli 0.1.14 → 0.1.16

package/dist/src/persistence/effective-config.js

@@ -1,20 +0,0 @@
-import { loadConfig } from "./config.js";
-export async function mergeEffectiveConfig(paths, modules, provided) {
-    const effective = {};
-    for (const module of modules) {
-        const stored = await loadConfig(paths, module.moduleRef);
-        if (stored === undefined)
-            continue;
-        effective[module.moduleRef] = {
-            ...stored.publicValues,
-            ...stored.secretValues,
-        };
-    }
-    for (const [moduleRef, values] of Object.entries(provided)) {
-        effective[moduleRef] = {
-            ...(effective[moduleRef] ?? {}),
-            ...values,
-        };
-    }
-    return effective;
-}

package/dist/src/persistence/generated.d.ts

@@ -1,2 +0,0 @@
-import type { WorkspacePaths } from "../paths.ts";
-export declare function writeInstallDoc(paths: WorkspacePaths, content: string): Promise<void>;

package/dist/src/persistence/generated.js

@@ -1,4 +0,0 @@
-import { writeFileAtomic } from "./atomic.js";
-export async function writeInstallDoc(paths, content) {
-    await writeFileAtomic(paths.installMd, content, 0o644);
-}

package/dist/src/persistence/plans.d.ts

@@ -1,5 +0,0 @@
-import type { DeploymentPlan } from "../contracts.ts";
-import { type WorkspacePaths } from "../paths.ts";
-export declare function savePlan(paths: WorkspacePaths, plan: DeploymentPlan): Promise<void>;
-export declare function loadPlan(paths: WorkspacePaths, planRef: string): Promise<DeploymentPlan | undefined>;
-export declare function listPlans(paths: WorkspacePaths): Promise<string[]>;

package/dist/src/persistence/plans.js

@@ -1,34 +0,0 @@
-import { readdir } from "node:fs/promises";
-import { join } from "node:path";
-import { readJson } from "../paths.js";
-import { writeJsonAtomic } from "./atomic.js";
-import { assertSafeFileName, isDeploymentPlan } from "./guards.js";
-function planFilePath(paths, planRef) {
-    assertSafeFileName(planRef, "planRef");
-    return join(paths.plans, `${planRef}.json`);
-}
-// Plans are public DTOs: secretRef config values are opaque reference
-// identities (e.g. `secret://model-provider/default`), safe to persist verbatim.
-// No raw secret ever enters a plan, so no redaction is applied on save.
-export async function savePlan(paths, plan) {
-    await writeJsonAtomic(planFilePath(paths, plan.planRef), plan);
-}
-export async function loadPlan(paths, planRef) {
-    const value = await readJson(planFilePath(paths, planRef));
-    if (value === undefined)
-        return undefined;
-    return isDeploymentPlan(value) ? value : undefined;
-}
-export async function listPlans(paths) {
-    let entries;
-    try {
-        entries = await readdir(paths.plans);
-    }
-    catch {
-        return [];
-    }
-    return entries
-        .filter((entry) => entry.endsWith(".json"))
-        .map((entry) => entry.slice(0, -".json".length))
-        .sort();
-}

package/dist/src/persistence/state.d.ts

@@ -1,7 +0,0 @@
-import type { DeploymentState, PendingActionRecord } from "../contracts.ts";
-import { type WorkspacePaths } from "../paths.ts";
-export declare function emptyDeploymentState(): DeploymentState;
-export declare function clearPendingActions(state: DeploymentState, isResolved: (action: PendingActionRecord) => boolean): DeploymentState;
-export declare function clearCompletedPendingActions(state: DeploymentState): DeploymentState;
-export declare function loadDeploymentState(paths: WorkspacePaths): Promise<DeploymentState | undefined>;
-export declare function saveDeploymentState(paths: WorkspacePaths, state: DeploymentState): Promise<void>;

package/dist/src/persistence/state.js

@@ -1,34 +0,0 @@
-import { readJson } from "../paths.js";
-import { writeJsonAtomic } from "./atomic.js";
-import { DEPLOYMENT_STATE_CONTRACT, isDeploymentState } from "./guards.js";
-export function emptyDeploymentState() {
-    return {
-        contract: DEPLOYMENT_STATE_CONTRACT,
-        selectedModules: [],
-        lastAppliedPlans: [],
-        verificationIndex: [],
-        pendingActions: [],
-        updatedAt: new Date().toISOString(),
-    };
-}
-export function clearPendingActions(state, isResolved) {
-    return {
-        ...state,
-        pendingActions: state.pendingActions.filter((action) => !isResolved(action)),
-    };
-}
-export function clearCompletedPendingActions(state) {
-    const completed = new Set(state.lastAppliedPlans.map((entry) => entry.planRef));
-    return clearPendingActions(state, (action) => completed.has(action.planRef));
-}
-// Loaded state is validated at the boundary; a missing or corrupt file resolves
-// to undefined so stale persisted facts can never impersonate current reality.
-export async function loadDeploymentState(paths) {
-    const value = await readJson(paths.stateJson);
-    if (value === undefined)
-        return undefined;
-    return isDeploymentState(value) ? value : undefined;
-}
-export async function saveDeploymentState(paths, state) {
-    await writeJsonAtomic(paths.stateJson, state);
-}

package/dist/src/persistence/verification.d.ts

@@ -1,5 +0,0 @@
-import type { VerificationRecord } from "../contracts.ts";
-import type { WorkspacePaths } from "../paths.ts";
-export declare function appendVerification(paths: WorkspacePaths, record: VerificationRecord): Promise<void>;
-export declare function loadVerificationHistory(paths: WorkspacePaths, moduleRef: string): Promise<VerificationRecord[]>;
-export declare function loadLatestVerification(paths: WorkspacePaths, moduleRef: string): Promise<VerificationRecord | undefined>;

package/dist/src/persistence/verification.js

@@ -1,47 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { writeFileAtomic } from "./atomic.js";
-import { assertSafeFileName, isVerificationRecord } from "./guards.js";
-function verificationFilePath(paths, moduleRef) {
-    assertSafeFileName(moduleRef, "moduleRef");
-    return join(paths.verification, `${moduleRef}.jsonl`);
-}
-async function readJsonlLines(file) {
-    let raw;
-    try {
-        raw = await readFile(file, "utf8");
-    }
-    catch {
-        return [];
-    }
-    const lines = [];
-    for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
-        if (trimmed.length === 0)
-            continue;
-        try {
-            lines.push(JSON.parse(trimmed));
-        }
-        catch {
-            // skip a corrupt line rather than discarding otherwise valid history
-        }
-    }
-    return lines;
-}
-// Verification history is append-only: existing records are preserved and the
-// new record is appended, then the whole file is atomically replaced.
-export async function appendVerification(paths, record) {
-    const file = verificationFilePath(paths, record.moduleRef);
-    const records = (await readJsonlLines(file)).filter(isVerificationRecord);
-    records.push(record);
-    const content = `${records.map((item) => JSON.stringify(item)).join("\n")}\n`;
-    await writeFileAtomic(file, content);
-}
-export async function loadVerificationHistory(paths, moduleRef) {
-    const lines = await readJsonlLines(verificationFilePath(paths, moduleRef));
-    return lines.filter(isVerificationRecord);
-}
-export async function loadLatestVerification(paths, moduleRef) {
-    const history = await loadVerificationHistory(paths, moduleRef);
-    return history[history.length - 1];
-}

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

@@ -1,16 +0,0 @@
-import type { HumanAction, ModuleDescriptor } from "@tomflow/proflow-module-contract";
-import type { DeploymentIntent, DeploymentPlan, DeploymentStep, ModuleTarget, ResolvedModule } from "../contracts.ts";
-export declare function toResolvedModule(descriptor: ModuleDescriptor): ResolvedModule;
-export declare function generatePlanRef(intent: DeploymentIntent, moduleTargets: readonly ModuleTarget[], now: Date): string;
-export declare function deepFreeze<T>(value: T): T;
-export interface AssembleArgs {
-    intent: DeploymentIntent;
-    modules: readonly ResolvedModule[];
-    targets: readonly ModuleTarget[];
-    config: Record<string, Record<string, string>> | undefined;
-    steps: DeploymentStep[];
-    humanActions: HumanAction[];
-    now: Date;
-    targetDescriptors?: readonly ModuleDescriptor[];
-}
-export declare function assemblePlan(args: AssembleArgs): DeploymentPlan;

package/dist/src/planner/assemble.js

@@ -1,107 +0,0 @@
-import { createHash } from "node:crypto";
-import { buildDependencyGraph } from "../graph/graph.js";
-import { computeFingerprint } from "./fingerprint.js";
-function compareRef(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-export function toResolvedModule(descriptor) {
-    return {
-        moduleRef: descriptor.moduleRef,
-        packageName: descriptor.packageName,
-        moduleVersion: descriptor.moduleVersion,
-        kind: descriptor.kind,
-        installClass: descriptor.installClass,
-        identity: descriptor.identity,
-        documentation: descriptor.documentation,
-        provides: descriptor.provides,
-        requires: descriptor.requires,
-        requirements: descriptor.requirements,
-        configSlots: descriptor.configSlots,
-        lifecycle: descriptor.lifecycle.supported,
-        verification: descriptor.verification,
-        effects: descriptor.effects,
-        source: { type: "installed" },
-    };
-}
-export function generatePlanRef(intent, moduleTargets, now) {
-    const key = JSON.stringify({
-        intent,
-        targets: [...moduleTargets]
-            .sort((a, b) => compareRef(a.moduleRef, b.moduleRef))
-            .map((target) => ({
-            moduleRef: target.moduleRef,
-            targetVersion: target.targetVersion ?? null,
-        })),
-    });
-    const hash = createHash("sha256").update(key).digest("hex").slice(0, 8);
-    return `plan-${intent}-${now.getTime()}-${hash}`;
-}
-export function deepFreeze(value) {
-    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
-        Object.freeze(value);
-        for (const key of Object.keys(value)) {
-            deepFreeze(value[key]);
-        }
-    }
-    return value;
-}
-export function assemblePlan(args) {
-    const graph = buildDependencyGraph(args.modules);
-    const byRef = new Map(args.modules.map((module) => [module.moduleRef, module]));
-    const targetByRef = new Map(args.targets.map((target) => [target.moduleRef, target]));
-    const moduleTargets = [];
-    for (const ref of graph.order) {
-        const explicit = targetByRef.get(ref);
-        const merged = {
-            ...(explicit?.config ?? {}),
-            ...(args.config?.[ref] ?? {}),
-        };
-        const target = { moduleRef: ref };
-        if (explicit?.targetVersion !== undefined) {
-            target.targetVersion = explicit.targetVersion;
-        }
-        if (Object.keys(merged).length > 0) {
-            target.config = merged;
-        }
-        moduleTargets.push(target);
-    }
-    const verification = graph.order.map((ref) => ({
-        moduleRef: ref,
-        checks: (byRef.get(ref)?.verification.checks ?? []).map((check) => check.id),
-    }));
-    const effectMap = new Map();
-    for (const module of args.modules) {
-        for (const effect of module.effects) {
-            const key = `${effect.kind}:${effect.description}`;
-            if (!effectMap.has(key))
-                effectMap.set(key, effect);
-        }
-    }
-    const effects = [...effectMap.values()].sort((a, b) => compareRef(`${a.kind}:${a.description}`, `${b.kind}:${b.description}`));
-    const humanByAction = new Map();
-    for (const action of args.humanActions) {
-        if (!humanByAction.has(action.action)) {
-            humanByAction.set(action.action, action);
-        }
-    }
-    const humanActions = [...humanByAction.values()].sort((a, b) => compareRef(a.action, b.action));
-    const resolvedModules = [...args.modules].sort((a, b) => compareRef(a.moduleRef, b.moduleRef));
-    const plan = {
-        planRef: "",
-        intent: args.intent,
-        moduleTargets,
-        resolvedModules,
-        ...(args.targetDescriptors !== undefined
-            ? { targetDescriptors: [...args.targetDescriptors] }
-            : {}),
-        steps: args.steps,
-        effects,
-        humanActions,
-        verification,
-        fingerprint: "",
-        createdAt: args.now.toISOString(),
-    };
-    plan.planRef = generatePlanRef(args.intent, moduleTargets, args.now);
-    plan.fingerprint = computeFingerprint(plan);
-    return deepFreeze(plan);
-}

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

@@ -1,20 +0,0 @@
-import type { DeploymentPlan, DeploymentStep } from "../contracts.ts";
-export interface VerificationCheckResult {
-    id: string;
-    status: "PASS" | "FAIL";
-}
-export interface StepReality {
-    installedVersion?: string;
-    configValues?: Record<string, string>;
-    processRunning?: boolean;
-    resourceConfigured?: boolean;
-    humanActionVerified?: boolean;
-    verificationChecks?: readonly VerificationCheckResult[];
-    migrated?: boolean;
-}
-export type StepCheckStatus = "SATISFIED" | "NOT_SATISFIED" | "UNKNOWN";
-export interface StepCheckResult {
-    status: StepCheckStatus;
-    reason: string;
-}
-export declare function evaluateStepCheck(step: DeploymentStep, plan: DeploymentPlan, reality: StepReality): StepCheckResult;

package/dist/src/planner/check.js

@@ -1,107 +0,0 @@
-import { CheckStrategy } from "./steps.js";
-function satisfied(reason) {
-    return { status: "SATISFIED", reason };
-}
-function notSatisfied(reason) {
-    return { status: "NOT_SATISFIED", reason };
-}
-function unknown(reason) {
-    return { status: "UNKNOWN", reason };
-}
-function moduleOf(plan, step) {
-    return plan.resolvedModules.find((module) => module.moduleRef === step.moduleRef);
-}
-export function evaluateStepCheck(step, plan, reality) {
-    switch (step.checkStrategy) {
-        case CheckStrategy.packageInstalled:
-            return checkPackage(step, plan, reality);
-        case CheckStrategy.packageAbsent:
-            return reality.installedVersion === undefined
-                ? satisfied(`${step.moduleRef} package is absent`)
-                : notSatisfied(`${step.moduleRef} package is still installed at ${reality.installedVersion}`);
-        case CheckStrategy.configMaterialized:
-            return checkConfig(step, plan, reality);
-        case CheckStrategy.lifecycleRunning:
-            return reality.processRunning === true
-                ? satisfied(`${step.moduleRef} is running`)
-                : notSatisfied(`${step.moduleRef} is not observed running`);
-        case CheckStrategy.lifecycleStopped:
-            return reality.processRunning === false
-                ? satisfied(`${step.moduleRef} is stopped`)
-                : notSatisfied(`${step.moduleRef} is not observed stopped`);
-        case CheckStrategy.externalResourceConfigured:
-            return reality.resourceConfigured === true
-                ? satisfied(`external resource ${step.moduleRef} configured`)
-                : notSatisfied(`external resource ${step.moduleRef} not observed configured`);
-        case CheckStrategy.humanVerified:
-            return reality.humanActionVerified === true
-                ? satisfied(`human action for ${step.moduleRef} verified`)
-                : notSatisfied(`human action for ${step.moduleRef} not observed verified`);
-        case CheckStrategy.migrateComplete:
-            return reality.migrated === true
-                ? satisfied(`${step.moduleRef} migrated`)
-                : notSatisfied(`${step.moduleRef} not observed migrated`);
-        case CheckStrategy.verifyChecksPass:
-            return checkVerify(step, plan, reality);
-        default:
-            return unknown(`unknown check strategy ${step.checkStrategy}`);
-    }
-}
-function checkPackage(step, plan, reality) {
-    const module = moduleOf(plan, step);
-    if (module === undefined) {
-        return unknown(`module ${step.moduleRef} is not in the plan`);
-    }
-    if (reality.installedVersion === undefined) {
-        return notSatisfied(`installed version for ${step.moduleRef} is not observed`);
-    }
-    if (reality.installedVersion !== module.moduleVersion) {
-        return notSatisfied(`installed ${reality.installedVersion} != expected ${module.moduleVersion}`);
-    }
-    return satisfied(`installed ${module.moduleVersion} matches target`);
-}
-function checkConfig(step, plan, reality) {
-    const module = moduleOf(plan, step);
-    if (module === undefined) {
-        return unknown(`module ${step.moduleRef} is not in the plan`);
-    }
-    if (reality.configValues === undefined) {
-        return notSatisfied(`config for ${step.moduleRef} is not materialized`);
-    }
-    for (const slot of module.configSlots) {
-        if (!slot.required)
-            continue;
-        const value = reality.configValues[slot.key];
-        if (value === undefined || value === "") {
-            return notSatisfied(`required config ${slot.key} is missing`);
-        }
-    }
-    // A configure step is satisfied only when current persisted reality matches
-    // the immutable target carried by this plan. Required-key presence alone is
-    // insufficient: a failed/partial prior apply can leave every key present but
-    // with values that the module-owned materializer rejected.
-    const target = plan.moduleTargets.find((entry) => entry.moduleRef === step.moduleRef)?.config;
-    for (const [key, expected] of Object.entries(target ?? {})) {
-        const observed = reality.configValues[key];
-        if (observed !== expected) {
-            return notSatisfied(`config ${key} for ${step.moduleRef} is ${observed === undefined ? "not observed" : "not at the planned target"}`);
-        }
-    }
-    return satisfied(`planned config materialized for ${step.moduleRef}`);
-}
-function checkVerify(step, plan, reality) {
-    const module = moduleOf(plan, step);
-    if (module === undefined) {
-        return unknown(`module ${step.moduleRef} is not in the plan`);
-    }
-    if (reality.verificationChecks === undefined) {
-        return notSatisfied(`verification for ${step.moduleRef} is not run`);
-    }
-    const byId = new Map(reality.verificationChecks.map((check) => [check.id, check.status]));
-    for (const check of module.verification.checks) {
-        if (byId.get(check.id) !== "PASS") {
-            return notSatisfied(`verification check ${check.id} is not passing`);
-        }
-    }
-    return satisfied(`verification checks pass for ${step.moduleRef}`);
-}

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

@@ -1,12 +0,0 @@
-import type { DeploymentPlan } from "../contracts.ts";
-export interface FingerprintSource {
-    intent: string;
-    targets: string;
-    modules: string;
-    steps: string;
-    effects: string;
-    humanActions: string;
-    verification: string;
-}
-export declare function buildFingerprintSource(plan: DeploymentPlan): FingerprintSource;
-export declare function computeFingerprint(plan: DeploymentPlan): string;

package/dist/src/planner/fingerprint.js

@@ -1,164 +0,0 @@
-import { createHash } from "node:crypto";
-function compareRef(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-function stableStringify(value) {
-    if (value === null || value === undefined)
-        return "null";
-    if (typeof value !== "object")
-        return JSON.stringify(value);
-    if (Array.isArray(value)) {
-        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-    }
-    const record = value;
-    const keys = Object.keys(record).sort();
-    return `{${keys
-        .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
-        .join(",")}}`;
-}
-function sha256(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
-// Maps each moduleRef to the config keys that hold RAW secret values and must
-// be redacted from the fingerprint. secretRef slots are explicitly excluded:
-// their values are opaque reference identities (e.g. `secret://…`), which are
-// fingerprinted verbatim so a reference change (A→B) changes the fingerprint.
-function rawSecretKeyMap(modules) {
-    const map = new Map();
-    for (const module of modules) {
-        const set = new Set();
-        for (const slot of module.configSlots) {
-            if (slot.type !== "secretRef" && slot.sensitive === true) {
-                set.add(slot.key);
-            }
-        }
-        map.set(module.moduleRef, set);
-    }
-    return map;
-}
-function canonicalModules(modules) {
-    return [...modules]
-        .sort((a, b) => compareRef(a.moduleRef, b.moduleRef))
-        .map((module) => ({
-        moduleRef: module.moduleRef,
-        packageName: module.packageName,
-        moduleVersion: module.moduleVersion,
-        kind: module.kind,
-        installClass: module.installClass,
-        identity: module.identity,
-        documentation: [...module.documentation]
-            .sort((a, b) => compareRef(a.id, b.id))
-            .map((entry) => ({
-            id: entry.id,
-            path: entry.path,
-            description: entry.description ?? null,
-        })),
-        provides: [...module.provides]
-            .sort((a, b) => compareRef(a.contractRef, b.contractRef))
-            .map((provide) => ({
-            contractRef: provide.contractRef,
-            version: provide.version,
-        })),
-        requires: [...module.requires]
-            .sort((a, b) => compareRef(a.contractRef, b.contractRef))
-            .map((require) => ({
-            contractRef: require.contractRef,
-            versionRange: require.versionRange,
-            optional: require.optional ?? false,
-        })),
-        requirements: [...module.requirements]
-            .sort((a, b) => compareRef(stableStringify(a), stableStringify(b)))
-            .map((requirement) => requirement),
-        configSlots: [...module.configSlots]
-            .sort((a, b) => compareRef(a.key, b.key))
-            .map((slot) => ({
-            key: slot.key,
-            type: slot.type,
-            required: slot.required,
-            sensitive: slot.sensitive ?? false,
-            default: slot.default === undefined ? null : stableStringify(slot.default),
-        })),
-        lifecycle: [...module.lifecycle].sort(compareRef),
-        verification: [...module.verification.checks]
-            .sort((a, b) => compareRef(a.id, b.id))
-            .map((check) => ({
-            id: check.id,
-            lifecycle: check.lifecycle,
-            description: check.description,
-        })),
-        effects: [...module.effects]
-            .sort((a, b) => compareRef(`${a.kind}:${a.description}`, `${b.kind}:${b.description}`))
-            .map((effect) => ({
-            kind: effect.kind,
-            description: effect.description,
-            path: effect.path ?? null,
-            retention: effect.retention,
-        })),
-    }));
-}
-function redactConfig(config, rawSecretKeys) {
-    const result = {};
-    for (const key of Object.keys(config).sort()) {
-        result[key] = rawSecretKeys.has(key) ? "<redacted>" : (config[key] ?? "");
-    }
-    return result;
-}
-function redactedTargets(targets, rawSecretByRef) {
-    return [...targets]
-        .sort((a, b) => compareRef(a.moduleRef, b.moduleRef))
-        .map((target) => {
-        const rawSecretKeys = rawSecretByRef.get(target.moduleRef) ?? new Set();
-        const config = target.config === undefined
-            ? null
-            : redactConfig(target.config, rawSecretKeys);
-        return {
-            moduleRef: target.moduleRef,
-            targetVersion: target.targetVersion ?? null,
-            config,
-        };
-    });
-}
-function canonicalSteps(steps) {
-    return steps.map((step) => ({
-        stepRef: step.stepRef,
-        moduleRef: step.moduleRef,
-        kind: step.kind,
-        preconditions: [...step.preconditions].sort(compareRef),
-        expectedEffect: step.expectedEffect,
-        checkStrategy: step.checkStrategy,
-        executeStrategy: step.executeStrategy ?? null,
-        postcondition: step.postcondition,
-    }));
-}
-export function buildFingerprintSource(plan) {
-    const rawSecretByRef = rawSecretKeyMap(plan.resolvedModules);
-    return {
-        intent: plan.intent,
-        targets: stableStringify(redactedTargets(plan.moduleTargets, rawSecretByRef)),
-        modules: stableStringify(canonicalModules(plan.resolvedModules)),
-        steps: stableStringify(canonicalSteps(plan.steps)),
-        effects: stableStringify([...plan.effects]
-            .sort((a, b) => compareRef(`${a.kind}:${a.description}`, `${b.kind}:${b.description}`))
-            .map((effect) => ({
-            kind: effect.kind,
-            description: effect.description,
-            path: effect.path ?? null,
-            retention: effect.retention,
-        }))),
-        humanActions: stableStringify([...plan.humanActions]
-            .sort((a, b) => compareRef(a.action, b.action))
-            .map((action) => ({
-            action: action.action,
-            description: action.description,
-        }))),
-        verification: stableStringify([...plan.verification]
-            .sort((a, b) => compareRef(a.moduleRef, b.moduleRef))
-            .map((verification) => ({
-            moduleRef: verification.moduleRef,
-            checks: [...verification.checks].sort(compareRef),
-        }))),
-    };
-}
-export function computeFingerprint(plan) {
-    return sha256(stableStringify(buildFingerprintSource(plan)));
-}

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

@@ -1,13 +0,0 @@
-export type { StepCheckResult, StepCheckStatus, StepReality, VerificationCheckResult, } from "./check.ts";
-export { evaluateStepCheck } from "./check.ts";
-export type { FingerprintSource } from "./fingerprint.ts";
-export { computeFingerprint } from "./fingerprint.ts";
-export type { PlanInput } from "./plan.ts";
-export { planDeployment } from "./plan.ts";
-export type { RepairFact, RepairFactCode, RepairPlanInput } from "./repair.ts";
-export { planRepair, repairFactCodes } from "./repair.ts";
-export type { StalenessResult } from "./stale.ts";
-export { checkPlanStale } from "./stale.ts";
-export { CheckStrategy, ExecuteStrategy } from "./steps.ts";
-export type { UpgradeAssessment } from "./upgrade.ts";
-export { assessUpgrade, planUpgrade } from "./upgrade.ts";

package/dist/src/planner/index.js

@@ -1,7 +0,0 @@
-export { evaluateStepCheck } from "./check.js";
-export { computeFingerprint } from "./fingerprint.js";
-export { planDeployment } from "./plan.js";
-export { planRepair, repairFactCodes } from "./repair.js";
-export { checkPlanStale } from "./stale.js";
-export { CheckStrategy, ExecuteStrategy } from "./steps.js";
-export { assessUpgrade, planUpgrade } from "./upgrade.js";

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

@@ -1,15 +0,0 @@
-import type { ModuleDescriptor } from "@tomflow/proflow-module-contract";
-import type { DeploymentIntent, DeploymentPlan, ModuleTarget, ResolvedModule } from "../contracts.ts";
-import type { RepairFact } from "./repair.ts";
-export interface PlanInput {
-    intent: DeploymentIntent;
-    modules?: readonly ResolvedModule[];
-    targets?: readonly ModuleTarget[];
-    config?: Record<string, Record<string, string>>;
-    currentDescriptors?: readonly ModuleDescriptor[];
-    targetDescriptors?: readonly ModuleDescriptor[];
-    facts?: readonly RepairFact[];
-    uninstallScope?: "module" | "platform-instance";
-    now?: Date;
-}
-export declare function planDeployment(input: PlanInput): DeploymentPlan;