@tomflow/proflow-platform-cli 0.1.14 → 0.1.15

package/dist/src/apply/reality.js

@@ -1,105 +0,0 @@
-import { dispatchLifecycle } from "../lifecycle/index.js";
-import { loadConfig, loadLatestVerification } from "../persistence/index.js";
-export function createRealityObserver(deps) {
-    return {
-        observe(step, plan) {
-            return observeStep(deps, step, plan);
-        },
-    };
-}
-function moduleOf(plan, step) {
-    return plan.resolvedModules.find((module) => module.moduleRef === step.moduleRef);
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isStringMap(value) {
-    if (!isRecord(value))
-        return false;
-    return Object.values(value).every((item) => typeof item === "string");
-}
-/**
- * Runtime-validates an adapter `status` data payload into a `StepReality` at the
- * boundary. Only recognized fields survive; anything else is ignored so an
- * arbitrary payload can never be mistaken for observed reality. A service
- * `status` payload carrying `state: "RUNNING" | "STOPPED"` maps onto the
- * boolean `processRunning` reality.
- */
-function parseStatusReality(value) {
-    if (!isRecord(value))
-        return {};
-    const reality = {};
-    if (typeof value.processRunning === "boolean") {
-        reality.processRunning = value.processRunning;
-    }
-    else if (value.state === "RUNNING") {
-        reality.processRunning = true;
-    }
-    else if (value.state === "STOPPED") {
-        reality.processRunning = false;
-    }
-    if (typeof value.resourceConfigured === "boolean") {
-        reality.resourceConfigured = value.resourceConfigured;
-    }
-    if (typeof value.humanActionVerified === "boolean") {
-        reality.humanActionVerified = value.humanActionVerified;
-    }
-    if (typeof value.migrated === "boolean") {
-        reality.migrated = value.migrated;
-    }
-    if (typeof value.installedVersion === "string") {
-        reality.installedVersion = value.installedVersion;
-    }
-    if (isStringMap(value.configValues)) {
-        reality.configValues = value.configValues;
-    }
-    return reality;
-}
-async function observeViaStatus(catalog, module) {
-    if (!module.lifecycle.includes("status"))
-        return {};
-    try {
-        const dispatched = await dispatchLifecycle(catalog, module, "status");
-        return parseStatusReality(dispatched.result.data);
-    }
-    catch {
-        // Observation failed (transport/timeout/malformed): UNKNOWN, never a
-        // fabricated NOT_SATISFIED that would replay a lifecycle/external effect.
-        return undefined;
-    }
-}
-async function observeStep(deps, step, plan) {
-    const module = moduleOf(plan, step);
-    if (module === undefined)
-        return {};
-    switch (step.kind) {
-        case "package": {
-            const installedVersion = await deps.driver.observeInstalledVersion(module);
-            return installedVersion === undefined ? {} : { installedVersion };
-        }
-        case "config": {
-            const config = await loadConfig(deps.paths, step.moduleRef);
-            if (config === undefined)
-                return {};
-            return {
-                configValues: { ...config.publicValues, ...config.secretValues },
-            };
-        }
-        case "lifecycle":
-        case "external-resource":
-            return observeViaStatus(deps.catalog, module);
-        case "human": {
-            const statusReality = await observeViaStatus(deps.catalog, module);
-            if (statusReality === undefined)
-                return undefined;
-            if (statusReality.humanActionVerified === true)
-                return statusReality;
-            const latest = await loadLatestVerification(deps.paths, module.moduleRef);
-            return {
-                ...statusReality,
-                humanActionVerified: latest?.result === "PASS" &&
-                    latest.moduleVersion === module.moduleVersion,
-            };
-        }
-    }
-}

package/dist/src/binding/global-binding.d.ts

@@ -1,69 +0,0 @@
-export declare const GLOBAL_BINDING_CONTRACT: "deployment.global-binding.v1";
-export declare const WORKSPACE_INSTANCE_CONTRACT: "deployment.workspace-instance.v1";
-export type GlobalBindingState = "INSTALLING" | "INSTALLED" | "UNINSTALLING" | "BROKEN";
-export interface GlobalWorkspaceBinding {
-    contract: typeof GLOBAL_BINDING_CONTRACT;
-    state: GlobalBindingState;
-    workspacePath: string;
-    workspaceRealPath: string;
-    workspaceInstanceId: string;
-    createdAt: string;
-    updatedAt: string;
-    failure?: {
-        code: string;
-        message: string;
-    };
-}
-export interface WorkspaceInstanceMarker {
-    contract: typeof WORKSPACE_INSTANCE_CONTRACT;
-    workspaceInstanceId: string;
-    workspaceRealPath: string;
-    createdAt: string;
-}
-export interface GlobalPlatformPaths {
-    root: string;
-    bindingJson: string;
-    bindingLock: string;
-    operationLock: string;
-}
-export interface BoundWorkspaceObservation {
-    binding: GlobalWorkspaceBinding;
-    workspaceExists: boolean;
-}
-export interface GlobalBindingLockHandle {
-    release(): Promise<void>;
-}
-export declare function globalPlatformPaths(globalRoot?: string): GlobalPlatformPaths;
-export declare function canonicalizeWorkspace(workspace: string): Promise<{
-    workspacePath: string;
-    workspaceRealPath: string;
-}>;
-export declare function loadGlobalBinding(globalRoot?: string): Promise<GlobalWorkspaceBinding | undefined>;
-export declare function observeBoundWorkspace(globalRoot?: string): Promise<BoundWorkspaceObservation | undefined>;
-export declare function requireBoundWorkspace(globalRoot?: string): Promise<GlobalWorkspaceBinding>;
-export declare function claimWorkspaceBinding(options: {
-    workspace: string;
-    globalRoot?: string | undefined;
-}): Promise<{
-    binding: GlobalWorkspaceBinding;
-    alreadyBound: boolean;
-}>;
-export declare function updateGlobalBindingState(options: {
-    workspaceInstanceId: string;
-    state: GlobalBindingState;
-    globalRoot?: string | undefined;
-    failure?: {
-        code: string;
-        message: string;
-    };
-}): Promise<GlobalWorkspaceBinding>;
-export declare function clearGlobalBinding(options: {
-    workspaceInstanceId: string;
-    globalRoot?: string | undefined;
-    removeWorkspaceMarker?: boolean;
-}): Promise<void>;
-export declare function forgetMissingWorkspaceBinding(options: {
-    globalRoot?: string | undefined;
-}): Promise<GlobalWorkspaceBinding>;
-export declare function acquireGlobalBindingLock(paths: GlobalPlatformPaths): Promise<GlobalBindingLockHandle>;
-export declare function acquireGlobalOperationLock(globalRoot?: string): Promise<GlobalBindingLockHandle>;

package/dist/src/binding/global-binding.js

@@ -1,349 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
-import { access, chmod, mkdir, open, readFile, realpath, rm, stat, unlink, } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { PlatformError } from "../errors.js";
-import { atomicWrite } from "../paths.js";
-export const GLOBAL_BINDING_CONTRACT = "deployment.global-binding.v1";
-export const WORKSPACE_INSTANCE_CONTRACT = "deployment.workspace-instance.v1";
-export function globalPlatformPaths(globalRoot) {
-    const root = globalRoot ??
-        process.env.PROFLOW_GLOBAL_HOME ??
-        join(homedir(), ".proflow", "platform");
-    return {
-        root,
-        bindingJson: join(root, "binding.json"),
-        bindingLock: join(root, "binding.lock"),
-        operationLock: join(root, "operation.lock"),
-    };
-}
-export async function canonicalizeWorkspace(workspace) {
-    const workspacePath = resolve(workspace);
-    let info;
-    try {
-        info = await stat(workspacePath);
-    }
-    catch {
-        throw new PlatformError("WORKSPACE_NOT_FOUND", `workspace does not exist: ${workspacePath}`);
-    }
-    if (!info.isDirectory()) {
-        throw new PlatformError("WORKSPACE_NOT_FOUND", `workspace is not a directory: ${workspacePath}`);
-    }
-    try {
-        await access(workspacePath, constants.R_OK | constants.W_OK);
-    }
-    catch {
-        throw new PlatformError("WORKSPACE_NOT_WRITABLE", `workspace is not readable and writable: ${workspacePath}`);
-    }
-    return { workspacePath, workspaceRealPath: await realpath(workspacePath) };
-}
-export async function loadGlobalBinding(globalRoot) {
-    const paths = globalPlatformPaths(globalRoot);
-    try {
-        const raw = await readFile(paths.bindingJson, "utf8");
-        const parsed = JSON.parse(raw);
-        if (!isGlobalWorkspaceBinding(parsed)) {
-            throw new PlatformError("GLOBAL_BINDING_INVALID", `global binding is invalid: ${paths.bindingJson}`);
-        }
-        return parsed;
-    }
-    catch (error) {
-        if (isMissingFile(error))
-            return undefined;
-        if (error instanceof PlatformError)
-            throw error;
-        throw new PlatformError("GLOBAL_BINDING_INVALID", `cannot read global binding ${paths.bindingJson}: ${errorMessage(error)}`);
-    }
-}
-export async function observeBoundWorkspace(globalRoot) {
-    const binding = await loadGlobalBinding(globalRoot);
-    if (binding === undefined)
-        return undefined;
-    return {
-        binding,
-        workspaceExists: await directoryExists(binding.workspaceRealPath),
-    };
-}
-export async function requireBoundWorkspace(globalRoot) {
-    const observation = await observeBoundWorkspace(globalRoot);
-    if (observation === undefined) {
-        throw new PlatformError("WORKSPACE_NOT_BOUND", "no ProFlow Workspace is currently installed/bound");
-    }
-    if (!observation.workspaceExists) {
-        throw new PlatformError("BOUND_WORKSPACE_MISSING", `bound Workspace no longer exists: ${observation.binding.workspaceRealPath}`);
-    }
-    return observation.binding;
-}
-export async function claimWorkspaceBinding(options) {
-    const requested = await canonicalizeWorkspace(options.workspace);
-    const paths = globalPlatformPaths(options.globalRoot);
-    const lock = await acquireGlobalBindingLock(paths);
-    try {
-        const current = await loadGlobalBinding(options.globalRoot);
-        if (current !== undefined) {
-            if (current.workspaceRealPath !== requested.workspaceRealPath) {
-                throw new PlatformError("WORKSPACE_ALREADY_BOUND", `ProFlow is already bound to ${current.workspaceRealPath}; uninstall it before installing ${requested.workspaceRealPath}`);
-            }
-            return { binding: current, alreadyBound: true };
-        }
-        const existingMarker = await loadWorkspaceInstanceMarker(requested.workspaceRealPath);
-        const now = new Date().toISOString();
-        const binding = {
-            contract: GLOBAL_BINDING_CONTRACT,
-            state: "INSTALLING",
-            workspacePath: requested.workspacePath,
-            workspaceRealPath: requested.workspaceRealPath,
-            workspaceInstanceId: existingMarker?.workspaceInstanceId ?? randomUUID(),
-            createdAt: existingMarker?.createdAt ?? now,
-            updatedAt: now,
-        };
-        await saveGlobalBinding(paths, binding);
-        if (existingMarker === undefined) {
-            try {
-                await writeWorkspaceInstanceMarker(binding);
-            }
-            catch (error) {
-                const broken = withBindingState(binding, "BROKEN", {
-                    code: "WORKSPACE_INSTANCE_WRITE_FAILED",
-                    message: errorMessage(error),
-                });
-                await saveGlobalBinding(paths, broken);
-                throw new PlatformError("GLOBAL_BINDING_INVALID", `failed to materialize Workspace instance identity: ${errorMessage(error)}`);
-            }
-        }
-        return { binding, alreadyBound: false };
-    }
-    finally {
-        await lock.release();
-    }
-}
-export async function updateGlobalBindingState(options) {
-    const paths = globalPlatformPaths(options.globalRoot);
-    const lock = await acquireGlobalBindingLock(paths);
-    try {
-        const current = await loadGlobalBinding(options.globalRoot);
-        if (current === undefined) {
-            throw new PlatformError("WORKSPACE_NOT_BOUND", "cannot update global binding because no Workspace is bound");
-        }
-        if (current.workspaceInstanceId !== options.workspaceInstanceId) {
-            throw new PlatformError("GLOBAL_BINDING_INVALID", "global binding instance identity changed during the operation");
-        }
-        const next = withBindingState(current, options.state, options.failure);
-        await saveGlobalBinding(paths, next);
-        return next;
-    }
-    finally {
-        await lock.release();
-    }
-}
-export async function clearGlobalBinding(options) {
-    const paths = globalPlatformPaths(options.globalRoot);
-    const lock = await acquireGlobalBindingLock(paths);
-    try {
-        const current = await loadGlobalBinding(options.globalRoot);
-        if (current === undefined)
-            return;
-        if (current.workspaceInstanceId !== options.workspaceInstanceId) {
-            throw new PlatformError("GLOBAL_BINDING_INVALID", "refusing to clear a different Workspace binding");
-        }
-        await rm(paths.bindingJson, { force: true });
-        if (options.removeWorkspaceMarker === true) {
-            await rm(workspaceInstanceMarkerPath(current.workspaceRealPath), {
-                force: true,
-            });
-        }
-    }
-    finally {
-        await lock.release();
-    }
-}
-export async function forgetMissingWorkspaceBinding(options) {
-    const paths = globalPlatformPaths(options.globalRoot);
-    const lock = await acquireGlobalBindingLock(paths);
-    try {
-        const current = await loadGlobalBinding(options.globalRoot);
-        if (current === undefined) {
-            throw new PlatformError("WORKSPACE_NOT_BOUND", "no ProFlow Workspace binding exists to forget");
-        }
-        if (await directoryExists(current.workspaceRealPath)) {
-            throw new PlatformError("INVALID_REQUEST", "bound Workspace still exists; use normal platform uninstall instead of forget");
-        }
-        await rm(paths.bindingJson, { force: true });
-        return current;
-    }
-    finally {
-        await lock.release();
-    }
-}
-export async function acquireGlobalBindingLock(paths) {
-    return acquireExclusiveGlobalLock(paths.root, paths.bindingLock, "GLOBAL_BINDING_LOCKED", "another process is mutating the global Workspace binding");
-}
-export async function acquireGlobalOperationLock(globalRoot) {
-    const paths = globalPlatformPaths(globalRoot);
-    return acquireExclusiveGlobalLock(paths.root, paths.operationLock, "GLOBAL_OPERATION_LOCKED", "another Platform install/uninstall operation is already running");
-}
-async function acquireExclusiveGlobalLock(root, file, code, message) {
-    await mkdir(root, { recursive: true });
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        try {
-            const handle = await open(file, "wx", 0o600);
-            try {
-                await handle.writeFile(`${JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() })}\n`, "utf8");
-            }
-            finally {
-                await handle.close();
-            }
-            return {
-                async release() {
-                    try {
-                        await unlink(file);
-                    }
-                    catch (error) {
-                        if (!isMissingFile(error))
-                            throw error;
-                    }
-                },
-            };
-        }
-        catch (error) {
-            if (!isAlreadyExists(error))
-                throw error;
-            const record = await readLockRecord(file);
-            if (record !== undefined && !pidIsAlive(record.pid)) {
-                await rm(file, { force: true });
-                continue;
-            }
-            throw new PlatformError(code, `${message}: ${file}`);
-        }
-    }
-    throw new PlatformError(code, `${message}: ${file}`);
-}
-function workspaceInstanceMarkerPath(workspaceRoot) {
-    return join(workspaceRoot, ".proflow", "deployment", "instance.json");
-}
-async function loadWorkspaceInstanceMarker(workspaceRoot) {
-    const path = workspaceInstanceMarkerPath(workspaceRoot);
-    try {
-        const parsed = JSON.parse(await readFile(path, "utf8"));
-        if (!isWorkspaceInstanceMarker(parsed)) {
-            throw new PlatformError("WORKSPACE_INSTANCE_INVALID", `Workspace instance marker is invalid: ${path}`);
-        }
-        if (parsed.workspaceRealPath !== workspaceRoot) {
-            throw new PlatformError("WORKSPACE_INSTANCE_INVALID", `Workspace instance marker belongs to ${parsed.workspaceRealPath}, not ${workspaceRoot}`);
-        }
-        return parsed;
-    }
-    catch (error) {
-        if (isMissingFile(error))
-            return undefined;
-        if (error instanceof PlatformError)
-            throw error;
-        throw new PlatformError("WORKSPACE_INSTANCE_INVALID", `cannot read Workspace instance marker ${path}: ${errorMessage(error)}`);
-    }
-}
-function isWorkspaceInstanceMarker(value) {
-    if (!isRecord(value))
-        return false;
-    return (value.contract === WORKSPACE_INSTANCE_CONTRACT &&
-        typeof value.workspaceInstanceId === "string" &&
-        value.workspaceInstanceId.length > 0 &&
-        typeof value.workspaceRealPath === "string" &&
-        typeof value.createdAt === "string");
-}
-async function writeWorkspaceInstanceMarker(binding) {
-    const path = workspaceInstanceMarkerPath(binding.workspaceRealPath);
-    const marker = {
-        contract: WORKSPACE_INSTANCE_CONTRACT,
-        workspaceInstanceId: binding.workspaceInstanceId,
-        workspaceRealPath: binding.workspaceRealPath,
-        createdAt: binding.createdAt,
-    };
-    await mkdir(dirname(path), { recursive: true });
-    await atomicWrite(path, `${JSON.stringify(marker, null, 2)}\n`);
-    await chmod(path, 0o600);
-}
-async function saveGlobalBinding(paths, binding) {
-    await mkdir(paths.root, { recursive: true });
-    await atomicWrite(paths.bindingJson, `${JSON.stringify(binding, null, 2)}\n`);
-    await chmod(paths.bindingJson, 0o600);
-}
-function withBindingState(binding, state, failure) {
-    const { failure: _previousFailure, ...base } = binding;
-    return {
-        ...base,
-        state,
-        updatedAt: new Date().toISOString(),
-        ...(failure === undefined ? {} : { failure }),
-    };
-}
-function isGlobalWorkspaceBinding(value) {
-    if (!isRecord(value))
-        return false;
-    if (value.contract !== GLOBAL_BINDING_CONTRACT)
-        return false;
-    if (!isBindingState(value.state))
-        return false;
-    return (typeof value.workspacePath === "string" &&
-        typeof value.workspaceRealPath === "string" &&
-        typeof value.workspaceInstanceId === "string" &&
-        typeof value.createdAt === "string" &&
-        typeof value.updatedAt === "string" &&
-        (value.failure === undefined ||
-            (isRecord(value.failure) &&
-                typeof value.failure.code === "string" &&
-                typeof value.failure.message === "string")));
-}
-function isBindingState(value) {
-    return (value === "INSTALLING" ||
-        value === "INSTALLED" ||
-        value === "UNINSTALLING" ||
-        value === "BROKEN");
-}
-async function directoryExists(path) {
-    try {
-        return (await stat(path)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-async function readLockRecord(path) {
-    try {
-        const parsed = JSON.parse(await readFile(path, "utf8"));
-        if (isRecord(parsed) &&
-            typeof parsed.pid === "number" &&
-            Number.isInteger(parsed.pid) &&
-            parsed.pid > 0) {
-            return { pid: parsed.pid };
-        }
-        return undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function pidIsAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return isPermissionError(error);
-    }
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isMissingFile(error) {
-    return isRecord(error) && error.code === "ENOENT";
-}
-function isAlreadyExists(error) {
-    return isRecord(error) && error.code === "EEXIST";
-}
-function isPermissionError(error) {
-    return isRecord(error) && error.code === "EPERM";
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/src/doctor/doctor.d.ts

@@ -1,41 +0,0 @@
-import type { DeploymentCheck, DeploymentError, ModuleOperationResult } from "@tomflow/proflow-module-contract";
-import type { ResolvedModule } from "../contracts.ts";
-import type { ModuleCatalog } from "../modules.ts";
-export type DoctorNextAction = {
-    kind: "none";
-} | {
-    kind: "human-action";
-    action: string;
-    description: string;
-} | {
-    kind: "repair-plan";
-    summary: string;
-};
-export interface DoctorReport {
-    moduleRef: string;
-    moduleVersion: string;
-    status: ModuleOperationResult["status"];
-    checks: DeploymentCheck[];
-    errors: DeploymentError[];
-    evidenceRefs: string[];
-    nextAction: DoctorNextAction;
-    observedEffects: string[];
-}
-/**
- * Maps a doctor result to the recommended next step. Doctor only recommends:
- * it never performs a repair. A failing or blocked module yields a `repair-plan`
- * recommendation (to be followed by `plan --intent repair` → confirm → apply);
- * an ACTION_REQUIRED result yields the recoverable human action as-is.
- */
-export declare function nextActionOf(result: ModuleOperationResult): DoctorNextAction;
-/**
- * Diagnoses a single module by dispatching its public `doctor` primitive. The
- * report carries live checks, typed errors, evidence refs, and a recommended
- * next action — but performs no side effects and never auto-repairs.
- */
-export declare function doctorModule(catalog: ModuleCatalog, module: ResolvedModule): Promise<DoctorReport>;
-/**
- * Diagnoses every module that declares the `doctor` primitive; modules without
- * it are skipped.
- */
-export declare function doctorModules(catalog: ModuleCatalog, modules: readonly ResolvedModule[]): Promise<DoctorReport[]>;

package/dist/src/doctor/doctor.js

@@ -1,80 +0,0 @@
-import { dispatchLifecycle } from "../lifecycle/index.js";
-/**
- * Maps a doctor result to the recommended next step. Doctor only recommends:
- * it never performs a repair. A failing or blocked module yields a `repair-plan`
- * recommendation (to be followed by `plan --intent repair` → confirm → apply);
- * an ACTION_REQUIRED result yields the recoverable human action as-is.
- */
-export function nextActionOf(result) {
-    switch (result.status) {
-        case "SUCCEEDED":
-            return { kind: "none" };
-        case "ACTION_REQUIRED": {
-            const action = result.actionRequired;
-            if (action !== undefined) {
-                return {
-                    kind: "human-action",
-                    action: action.action,
-                    description: action.description,
-                };
-            }
-            return {
-                kind: "repair-plan",
-                summary: "action required but unspecified",
-            };
-        }
-        case "BLOCKED":
-        case "FAILED": {
-            const summary = result.error !== undefined
-                ? `${result.error.code}: ${result.error.message}`
-                : `module ${result.moduleRef} is ${result.status.toLowerCase()}`;
-            return { kind: "repair-plan", summary };
-        }
-    }
-}
-/**
- * Diagnoses a single module by dispatching its public `doctor` primitive. The
- * report carries live checks, typed errors, evidence refs, and a recommended
- * next action — but performs no side effects and never auto-repairs.
- */
-export async function doctorModule(catalog, module) {
-    const primitives = ["status", "verify", "doctor"].filter((primitive) => module.lifecycle.includes(primitive));
-    const dispatched = [];
-    for (const primitive of primitives) {
-        dispatched.push(await dispatchLifecycle(catalog, module, primitive));
-    }
-    const severity = {
-        SUCCEEDED: 0,
-        ACTION_REQUIRED: 1,
-        BLOCKED: 2,
-        FAILED: 3,
-    };
-    const effective = dispatched
-        .map((item) => item.result)
-        .reduce((worst, current) => severity[current.status] > severity[worst.status] ? current : worst);
-    const checks = dispatched.flatMap((item) => item.result.checks ?? []);
-    const errors = dispatched.flatMap((item) => item.result.error === undefined ? [] : [item.result.error]);
-    return {
-        moduleRef: module.moduleRef,
-        moduleVersion: module.moduleVersion,
-        status: effective.status,
-        checks,
-        errors,
-        evidenceRefs: checks.map((check) => `check:${check.id}:${check.status}`),
-        nextAction: nextActionOf(effective),
-        observedEffects: dispatched.flatMap((item) => item.observedEffects),
-    };
-}
-/**
- * Diagnoses every module that declares the `doctor` primitive; modules without
- * it are skipped.
- */
-export async function doctorModules(catalog, modules) {
-    const reports = [];
-    for (const module of modules) {
-        if (!module.lifecycle.includes("doctor"))
-            continue;
-        reports.push(await doctorModule(catalog, module));
-    }
-    return reports;
-}

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

@@ -1,2 +0,0 @@
-export type { DoctorNextAction, DoctorReport } from "./doctor.ts";
-export { doctorModule, doctorModules, nextActionOf } from "./doctor.ts";

package/dist/src/doctor/index.js

@@ -1 +0,0 @@
-export { doctorModule, doctorModules, nextActionOf } from "./doctor.js";

package/dist/src/install/bootstrap.d.ts

@@ -1,10 +0,0 @@
-import type { ResolvedModule } from "../contracts.ts";
-import { type RegistryModuleCandidate } from "../registry/index.ts";
-/**
- * Registry bootstrap targets intentionally carry only facts available before
- * installation. They are package-plan placeholders, never substitutes for the
- * package-owned Module Descriptor that is loaded after installation.
- */
-export declare function registryCandidateToBootstrapModule(candidate: RegistryModuleCandidate): ResolvedModule;
-export declare function selectBootstrapModules(candidates: readonly RegistryModuleCandidate[], explicitPackageName?: string): ResolvedModule[];
-export declare function selectUpgradeBootstrapModules(currentModules: readonly ResolvedModule[], candidates: readonly RegistryModuleCandidate[]): ResolvedModule[];