@tomflow/proflow-platform-cli 0.1.13 → 0.1.15

package/dist/src/lifecycle/dispatch.d.ts

@@ -7,14 +7,6 @@ export interface LifecycleDispatchResult {
     result: ModuleOperationResult;
     observedEffects: string[];
 }
-export type LifecycleRunStatus = "EXECUTED" | "SKIP_UNSUPPORTED";
-export interface LifecycleRunResult {
-    moduleRef: string;
-    primitive: LifecyclePrimitive;
-    status: LifecycleRunStatus;
-    result: ModuleOperationResult | undefined;
-    observedEffects: string[];
-}
 /**
  * Dispatches a single lifecycle primitive against one module through its
  * public deployment adapter. The descriptor is the source of truth for what is
@@ -23,25 +15,3 @@ export interface LifecycleRunResult {
  * runtime-validated against the Module Operation Result schema.
  */
 export declare function dispatchLifecycle(catalog: ModuleCatalog, module: ResolvedModule, primitive: LifecyclePrimitive): Promise<LifecycleDispatchResult>;
-/**
- * Starts a module set in forward dependency topological order, dispatching the
- * `start` primitive only to modules that declare it.
- */
-export declare function startModules(catalog: ModuleCatalog, modules: readonly ResolvedModule[]): Promise<LifecycleRunResult[]>;
-/**
- * Stops a module set in reverse dependency topological order, dispatching the
- * `stop` primitive only to modules that declare it.
- */
-export declare function stopModules(catalog: ModuleCatalog, modules: readonly ResolvedModule[]): Promise<LifecycleRunResult[]>;
-/**
- * Restarts a module set in forward dependency topological order, dispatching
- * `restart` only to modules that explicitly declare it. Dependencies are
- * settled before the modules that consume them.
- */
-export declare function restartModules(catalog: ModuleCatalog, modules: readonly ResolvedModule[]): Promise<LifecycleRunResult[]>;
-/**
- * Queries current reality by dispatching the `status` primitive to every
- * module that declares it. Status is always read live from the adapter; no
- * persisted or cached value is substituted for current reality.
- */
-export declare function statusModules(catalog: ModuleCatalog, modules: readonly ResolvedModule[]): Promise<LifecycleRunResult[]>;

package/dist/src/lifecycle/dispatch.js

@@ -1,6 +1,5 @@
 import { moduleOperationResultSchema, } from "@tomflow/proflow-module-contract";
 import { PlatformError } from "../errors.js";
-import { buildDependencyGraph } from "../graph/graph.js";
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
@@ -11,9 +10,6 @@ function isWrappedResult(value) {
     return isRecord(value) && "result" in value;
 }
 function moduleSource(module) {
-    if (module.source.type === "registry") {
-        throw new PlatformError("DESCRIPTOR_INVALID", `registry bootstrap target ${module.packageName} has no local lifecycle adapter`);
-    }
     const source = {
         type: module.source.type,
         packageName: module.packageName,
@@ -75,119 +71,3 @@ export async function dispatchLifecycle(catalog, module, primitive) {
         observedEffects,
     };
 }
-async function runOne(catalog, module, primitive) {
-    if (!module.lifecycle.includes(primitive)) {
-        return {
-            moduleRef: module.moduleRef,
-            primitive,
-            status: "SKIP_UNSUPPORTED",
-            result: undefined,
-            observedEffects: [],
-        };
-    }
-    const dispatched = await dispatchLifecycle(catalog, module, primitive);
-    return {
-        moduleRef: dispatched.moduleRef,
-        primitive,
-        status: "EXECUTED",
-        result: dispatched.result,
-        observedEffects: dispatched.observedEffects,
-    };
-}
-async function runInOrder(catalog, modules, order, primitive) {
-    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
-    const results = [];
-    for (const moduleRef of order) {
-        const module = byRef.get(moduleRef);
-        if (module === undefined)
-            continue;
-        results.push(await runOne(catalog, module, primitive));
-    }
-    return results;
-}
-/**
- * Starts a module set in forward dependency topological order, dispatching the
- * `start` primitive only to modules that declare it.
- */
-export async function startModules(catalog, modules) {
-    const graph = buildDependencyGraph(modules);
-    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
-    const resultByRef = new Map();
-    const results = [];
-    for (const moduleRef of graph.order) {
-        const module = byRef.get(moduleRef);
-        if (module === undefined)
-            continue;
-        if (!module.lifecycle.includes("start")) {
-            const skipped = await runOne(catalog, module, "start");
-            results.push(skipped);
-            resultByRef.set(moduleRef, skipped);
-            continue;
-        }
-        const blockingDependency = graph.edges
-            .filter((edge) => edge.from === moduleRef)
-            .map((edge) => edge.to)
-            .find((dependencyRef) => {
-            const dependencyModule = byRef.get(dependencyRef);
-            if (!dependencyModule?.lifecycle.includes("start"))
-                return false;
-            const dependencyResult = resultByRef.get(dependencyRef);
-            return dependencyResult?.result?.status !== "SUCCEEDED";
-        });
-        if (blockingDependency !== undefined) {
-            const blocked = {
-                moduleRef,
-                primitive: "start",
-                status: "EXECUTED",
-                result: {
-                    contract: "deployment.result.v1",
-                    ok: false,
-                    status: "BLOCKED",
-                    moduleRef: module.moduleRef,
-                    moduleVersion: module.moduleVersion,
-                    error: {
-                        code: "COMMAND_FAILED",
-                        message: `dependency ${blockingDependency} did not start successfully; ${moduleRef} was not started`,
-                        retryable: true,
-                    },
-                },
-                observedEffects: [],
-            };
-            results.push(blocked);
-            resultByRef.set(moduleRef, blocked);
-            continue;
-        }
-        const result = await runOne(catalog, module, "start");
-        results.push(result);
-        resultByRef.set(moduleRef, result);
-    }
-    return results;
-}
-/**
- * Stops a module set in reverse dependency topological order, dispatching the
- * `stop` primitive only to modules that declare it.
- */
-export async function stopModules(catalog, modules) {
-    const order = [...buildDependencyGraph(modules).order].reverse();
-    return runInOrder(catalog, modules, order, "stop");
-}
-/**
- * Restarts a module set in forward dependency topological order, dispatching
- * `restart` only to modules that explicitly declare it. Dependencies are
- * settled before the modules that consume them.
- */
-export async function restartModules(catalog, modules) {
-    return runInOrder(catalog, modules, buildDependencyGraph(modules).order, "restart");
-}
-/**
- * Queries current reality by dispatching the `status` primitive to every
- * module that declares it. Status is always read live from the adapter; no
- * persisted or cached value is substituted for current reality.
- */
-export async function statusModules(catalog, modules) {
-    const results = [];
-    for (const module of modules) {
-        results.push(await runOne(catalog, module, "status"));
-    }
-    return results;
-}

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

@@ -1,3 +1,4 @@
-export type { LifecycleDispatchResult, LifecycleRunResult, LifecycleRunStatus, } from "./dispatch.ts";
-export { dispatchLifecycle, restartModules, startModules, statusModules, stopModules, } from "./dispatch.ts";
-export { managedServiceStatus, restartManagedService, startManagedService, stopManagedService, } from "./service-process.ts";
+export type { LifecycleDispatchResult } from "./dispatch.ts";
+export { dispatchLifecycle } from "./dispatch.ts";
+export type { ThinLifecycleResult } from "./thin.ts";
+export { observeStatuses, preflightAndStartModules, stopModulesThin, } from "./thin.ts";

package/dist/src/lifecycle/index.js

@@ -1,2 +1,2 @@
-export { dispatchLifecycle, restartModules, startModules, statusModules, stopModules, } from "./dispatch.js";
-export { managedServiceStatus, restartManagedService, startManagedService, stopManagedService, } from "./service-process.js";
+export { dispatchLifecycle } from "./dispatch.js";
+export { observeStatuses, preflightAndStartModules, stopModulesThin, } from "./thin.js";

package/dist/src/lifecycle/thin.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedModule } from "../contracts.ts";
+import type { ModuleCatalog } from "../modules.ts";
+import { type LifecycleDispatchResult } from "./dispatch.ts";
+export interface ThinLifecycleResult {
+    phase: "preflight" | "start" | "stop";
+    results: LifecycleDispatchResult[];
+    completed: boolean;
+}
+export declare function observeStatuses(catalog: ModuleCatalog, modules: readonly ResolvedModule[]): Promise<LifecycleDispatchResult[]>;
+export declare function preflightAndStartModules(catalog: ModuleCatalog, modules: readonly ResolvedModule[]): Promise<ThinLifecycleResult>;
+export declare function stopModulesThin(catalog: ModuleCatalog, modules: readonly ResolvedModule[]): Promise<ThinLifecycleResult>;

package/dist/src/lifecycle/thin.js

@@ -0,0 +1,68 @@
+import { buildDependencyGraph } from "../graph/graph.js";
+import { dispatchLifecycle } from "./dispatch.js";
+function succeeded(result) {
+    return result.status === "SUCCEEDED";
+}
+async function dispatchIfSupported(catalog, module, primitive) {
+    if (!module.lifecycle.includes(primitive))
+        return undefined;
+    return dispatchLifecycle(catalog, module, primitive);
+}
+export async function observeStatuses(catalog, modules) {
+    const results = [];
+    for (const module of [...modules].sort((a, b) => a.moduleRef.localeCompare(b.moduleRef))) {
+        if (!module.lifecycle.includes("status"))
+            continue;
+        results.push(await dispatchLifecycle(catalog, module, "status"));
+    }
+    return results;
+}
+export async function preflightAndStartModules(catalog, modules) {
+    const graph = buildDependencyGraph(modules);
+    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
+    const preflight = [];
+    for (const moduleRef of graph.order) {
+        const module = byRef.get(moduleRef);
+        if (module === undefined)
+            continue;
+        const result = await dispatchIfSupported(catalog, module, "preflight");
+        if (result === undefined)
+            continue;
+        preflight.push(result);
+        if (!succeeded(result.result)) {
+            return { phase: "preflight", results: preflight, completed: false };
+        }
+    }
+    const started = [];
+    for (const moduleRef of graph.order) {
+        const module = byRef.get(moduleRef);
+        if (module === undefined)
+            continue;
+        const result = await dispatchIfSupported(catalog, module, "start");
+        if (result === undefined)
+            continue;
+        started.push(result);
+        if (!succeeded(result.result)) {
+            return { phase: "start", results: started, completed: false };
+        }
+    }
+    return { phase: "start", results: started, completed: true };
+}
+export async function stopModulesThin(catalog, modules) {
+    const order = [...buildDependencyGraph(modules).order].reverse();
+    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
+    const stopped = [];
+    for (const moduleRef of order) {
+        const module = byRef.get(moduleRef);
+        if (module === undefined)
+            continue;
+        const result = await dispatchIfSupported(catalog, module, "stop");
+        if (result === undefined)
+            continue;
+        stopped.push(result);
+        if (!succeeded(result.result)) {
+            return { phase: "stop", results: stopped, completed: false };
+        }
+    }
+    return { phase: "stop", results: stopped, completed: true };
+}

package/dist/src/paths.d.ts

@@ -2,20 +2,6 @@ export interface WorkspacePaths {
     root: string;
     proflow: string;
     config: string;
-    data: string;
-    logs: string;
-    logsDeployment: string;
-    runtime: string;
-    cache: string;
-    tmp: string;
-    deployment: string;
-    stateJson: string;
-    plans: string;
-    verification: string;
-    generated: string;
-    installMd: string;
 }
 export declare function workspacePaths(root: string): WorkspacePaths;
-export declare function ensureLayout(paths: WorkspacePaths): Promise<void>;
 export declare function atomicWrite(file: string, content: string): Promise<void>;
-export declare function readJson<T>(file: string): Promise<T | undefined>;

package/dist/src/paths.js

@@ -3,54 +3,15 @@ import { mkdir, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 export function workspacePaths(root) {
     const proflow = join(root, ".proflow");
-    const deployment = join(proflow, "deployment");
     return {
         root,
         proflow,
         config: join(proflow, "config"),
-        data: join(proflow, "data"),
-        logs: join(proflow, "logs"),
-        logsDeployment: join(proflow, "logs", "deployment"),
-        runtime: join(proflow, "runtime"),
-        cache: join(proflow, "cache"),
-        tmp: join(proflow, "tmp"),
-        deployment,
-        stateJson: join(deployment, "state.json"),
-        plans: join(deployment, "plans"),
-        verification: join(deployment, "verification"),
-        generated: join(deployment, "generated"),
-        installMd: join(deployment, "generated", "INSTALL.md"),
     };
 }
-export async function ensureLayout(paths) {
-    for (const dir of [
-        paths.config,
-        paths.data,
-        paths.logsDeployment,
-        paths.runtime,
-        paths.cache,
-        paths.tmp,
-        paths.plans,
-        paths.verification,
-        paths.generated,
-    ]) {
-        await mkdir(dir, { recursive: true });
-    }
-}
-// Atomic write: bounded write to a temp sibling then rename into place.
 export async function atomicWrite(file, content) {
     await mkdir(dirname(file), { recursive: true });
     const tmp = `${file}.tmp-${randomBytes(6).toString("hex")}`;
     await writeFile(tmp, content, "utf8");
     await rename(tmp, file);
 }
-export async function readJson(file) {
-    try {
-        const { readFile } = await import("node:fs/promises");
-        const raw = await readFile(file, "utf8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}

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

@@ -3,10 +3,4 @@ export interface MaterializedConfig {
     publicValues: Record<string, string>;
     secretValues: Record<string, string>;
 }
-export interface ModuleConfig {
-    moduleRef: string;
-    values: Record<string, string>;
-    secretRefs: readonly string[];
-}
-export declare function materializeConfig(paths: WorkspacePaths, config: ModuleConfig): Promise<void>;
 export declare function loadConfig(paths: WorkspacePaths, moduleRef: string): Promise<MaterializedConfig | undefined>;

package/dist/src/persistence/config.js

@@ -1,7 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { PlatformError } from "../errors.js";
-import { writeJsonAtomic } from "./atomic.js";
 import { assertSafeFileName } from "./guards.js";
 function configFilePath(paths, moduleRef) {
     assertSafeFileName(moduleRef, "moduleRef");
@@ -43,19 +42,6 @@ async function readConfigValues(file, moduleRef, kind) {
         throw new PlatformError("CONFIG_INVALID", `${kind} config for ${moduleRef} is invalid JSON/config: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-// secretRef config values are opaque reference identities (e.g.
-// `secret://model-provider/default`), not raw secrets, so they materialize to
-// the public config file verbatim. A raw secret would go to the separate 0o600
-// secrets file — but v1 planning produces no raw secrets, so it stays empty and
-// must never hold a secretRef reference.
-export async function materializeConfig(paths, config) {
-    const publicValues = {};
-    for (const [key, value] of Object.entries(config.values)) {
-        publicValues[key] = value;
-    }
-    await writeJsonAtomic(configFilePath(paths, config.moduleRef), publicValues, 0o644);
-    await writeJsonAtomic(secretsFilePath(paths, config.moduleRef), {}, 0o600);
-}
 export async function loadConfig(paths, moduleRef) {
     const publicValues = await readConfigValues(configFilePath(paths, moduleRef), moduleRef, "public");
     const secretValues = await readConfigValues(secretsFilePath(paths, moduleRef), moduleRef, "secret");

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

@@ -1,7 +1 @@
-import type { DeploymentPlan, DeploymentState, LockRecord, VerificationRecord } from "../contracts.ts";
-export declare const DEPLOYMENT_STATE_CONTRACT = "proflow.deployment-state.v1";
 export declare function assertSafeFileName(name: string, kind: string): void;
-export declare function isDeploymentState(value: unknown): value is DeploymentState;
-export declare function isVerificationRecord(value: unknown): value is VerificationRecord;
-export declare function isDeploymentPlan(value: unknown): value is DeploymentPlan;
-export declare function isLockRecord(value: unknown): value is LockRecord;

package/dist/src/persistence/guards.js

@@ -1,121 +1,7 @@
 import { PlatformError } from "../errors.js";
-export const DEPLOYMENT_STATE_CONTRACT = "proflow.deployment-state.v1";
 const SAFE_FILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 export function assertSafeFileName(name, kind) {
     if (!SAFE_FILE_NAME.test(name)) {
         throw new PlatformError("INVALID_REQUEST", `invalid ${kind} name: ${name}`);
     }
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isString(value) {
-    return typeof value === "string";
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every(isString);
-}
-function isDeploymentIntent(value) {
-    return (value === "install" ||
-        value === "configure" ||
-        value === "upgrade" ||
-        value === "uninstall" ||
-        value === "repair");
-}
-function isSelectedModuleFact(value) {
-    return (isRecord(value) &&
-        isString(value.moduleRef) &&
-        isString(value.moduleVersion));
-}
-function isLastAppliedPlan(value) {
-    return (isRecord(value) &&
-        isString(value.planRef) &&
-        isDeploymentIntent(value.intent) &&
-        isString(value.appliedAt));
-}
-function isVerificationIndexEntry(value) {
-    return (isRecord(value) && isString(value.moduleRef) && isString(value.latestRef));
-}
-function isPendingAction(value) {
-    return (isRecord(value) &&
-        isString(value.planRef) &&
-        isString(value.stepRef) &&
-        isString(value.moduleRef) &&
-        isString(value.action) &&
-        (value.description === undefined || isString(value.description)) &&
-        isString(value.createdAt));
-}
-export function isDeploymentState(value) {
-    if (!isRecord(value))
-        return false;
-    if (value.contract !== DEPLOYMENT_STATE_CONTRACT)
-        return false;
-    if (!Array.isArray(value.selectedModules))
-        return false;
-    if (!value.selectedModules.every(isSelectedModuleFact))
-        return false;
-    if (!Array.isArray(value.lastAppliedPlans))
-        return false;
-    if (!value.lastAppliedPlans.every(isLastAppliedPlan))
-        return false;
-    if (!Array.isArray(value.verificationIndex))
-        return false;
-    if (!value.verificationIndex.every(isVerificationIndexEntry))
-        return false;
-    if (!Array.isArray(value.pendingActions))
-        return false;
-    if (!value.pendingActions.every(isPendingAction))
-        return false;
-    return isString(value.updatedAt);
-}
-export function isVerificationRecord(value) {
-    if (!isRecord(value))
-        return false;
-    if (!isString(value.verificationRef))
-        return false;
-    if (!isString(value.moduleRef))
-        return false;
-    if (!isString(value.moduleVersion))
-        return false;
-    if (value.resourceIdentity !== undefined && !isString(value.resourceIdentity))
-        return false;
-    if (value.resourceVersion !== undefined && !isString(value.resourceVersion))
-        return false;
-    if (value.result !== "PASS" && value.result !== "FAIL")
-        return false;
-    if (!isString(value.summary))
-        return false;
-    if (!isStringArray(value.evidenceRefs))
-        return false;
-    return isString(value.verifiedAt);
-}
-export function isDeploymentPlan(value) {
-    if (!isRecord(value))
-        return false;
-    if (!isString(value.planRef))
-        return false;
-    if (!isDeploymentIntent(value.intent))
-        return false;
-    if (!Array.isArray(value.moduleTargets))
-        return false;
-    if (!Array.isArray(value.resolvedModules))
-        return false;
-    if (!Array.isArray(value.steps))
-        return false;
-    if (!Array.isArray(value.effects))
-        return false;
-    if (!Array.isArray(value.humanActions))
-        return false;
-    if (!Array.isArray(value.verification))
-        return false;
-    if (!isString(value.fingerprint))
-        return false;
-    return isString(value.createdAt);
-}
-export function isLockRecord(value) {
-    return (isRecord(value) &&
-        typeof value.pid === "number" &&
-        isString(value.createdAt) &&
-        isString(value.planRef) &&
-        isString(value.workspaceFingerprint));
-}

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

@@ -1,6 +1,4 @@
-export type { MaterializedConfig, ModuleConfig } from "./config.ts";
-export { loadConfig, materializeConfig } from "./config.ts";
-export { writeInstallDoc } from "./generated.ts";
-export { listPlans, loadPlan, savePlan } from "./plans.ts";
-export { emptyDeploymentState, loadDeploymentState, saveDeploymentState, } from "./state.ts";
-export { appendVerification, loadLatestVerification, loadVerificationHistory, } from "./verification.ts";
+export type { MaterializedConfig } from "./config.ts";
+export { loadConfig } from "./config.ts";
+export type { WorkspaceMetadata } from "./workspace-metadata.ts";
+export { ensureWorkspaceMetadata } from "./workspace-metadata.ts";

package/dist/src/persistence/index.js

@@ -1,5 +1,2 @@
-export { loadConfig, materializeConfig } from "./config.js";
-export { writeInstallDoc } from "./generated.js";
-export { listPlans, loadPlan, savePlan } from "./plans.js";
-export { emptyDeploymentState, loadDeploymentState, saveDeploymentState, } from "./state.js";
-export { appendVerification, loadLatestVerification, loadVerificationHistory, } from "./verification.js";
+export { loadConfig } from "./config.js";
+export { ensureWorkspaceMetadata } from "./workspace-metadata.js";

package/dist/src/persistence/workspace-metadata.d.ts

@@ -0,0 +1,7 @@
+export interface WorkspaceMetadata {
+    contract: "proflow.workspace.v1";
+    workspaceInstanceId: string;
+    workspaceRoot: string;
+    createdAt: string;
+}
+export declare function ensureWorkspaceMetadata(workspaceRoot: string): Promise<WorkspaceMetadata>;

package/dist/src/persistence/workspace-metadata.js

@@ -0,0 +1,39 @@
+import { randomUUID } from "node:crypto";
+import { readFile, realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { PlatformError } from "../errors.js";
+import { atomicWrite } from "../paths.js";
+export async function ensureWorkspaceMetadata(workspaceRoot) {
+    const canonicalRoot = await realpath(workspaceRoot);
+    const path = join(canonicalRoot, ".proflow", "workspace.json");
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        if (typeof parsed !== "object" ||
+            parsed === null ||
+            Array.isArray(parsed) ||
+            Reflect.get(parsed, "contract") !== "proflow.workspace.v1" ||
+            typeof Reflect.get(parsed, "workspaceInstanceId") !== "string" ||
+            Reflect.get(parsed, "workspaceRoot") !== canonicalRoot ||
+            typeof Reflect.get(parsed, "createdAt") !== "string") {
+            throw new PlatformError("WORKSPACE_INSTANCE_INVALID", "existing .proflow/workspace.json does not match this Workspace");
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof PlatformError)
+            throw error;
+        if (typeof error !== "object" ||
+            error === null ||
+            Reflect.get(error, "code") !== "ENOENT") {
+            throw new PlatformError("WORKSPACE_INSTANCE_INVALID", `cannot read Workspace metadata: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const metadata = {
+        contract: "proflow.workspace.v1",
+        workspaceInstanceId: randomUUID(),
+        workspaceRoot: canonicalRoot,
+        createdAt: new Date().toISOString(),
+    };
+    await atomicWrite(path, `${JSON.stringify(metadata, null, 2)}\n`);
+    return metadata;
+}

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

@@ -1,2 +1,2 @@
 export type { NpmCommandResult, NpmCommandRunner, RegistryDiscoveryResult, RegistryModuleCandidate, RegistryRejectedPackage, } from "./npm-registry.ts";
-export { discoverRegistryInstallClosure, discoverRegistryModules, loadRegistryModuleDescriptor, PRO_FLOW_PACKAGE_PREFIX, PRO_FLOW_SCOPE, resolveScopeRegistry, systemNpmRunner, } from "./npm-registry.ts";
+export { discoverRegistryModules, PRO_FLOW_PACKAGE_PREFIX, PRO_FLOW_SCOPE, resolveScopeRegistry, systemNpmRunner, } from "./npm-registry.ts";

package/dist/src/registry/index.js

@@ -1 +1 @@
-export { discoverRegistryInstallClosure, discoverRegistryModules, loadRegistryModuleDescriptor, PRO_FLOW_PACKAGE_PREFIX, PRO_FLOW_SCOPE, resolveScopeRegistry, systemNpmRunner, } from "./npm-registry.js";
+export { discoverRegistryModules, PRO_FLOW_PACKAGE_PREFIX, PRO_FLOW_SCOPE, resolveScopeRegistry, systemNpmRunner, } from "./npm-registry.js";

package/dist/src/registry/npm-registry.d.ts

@@ -1,4 +1,3 @@
-import { type ModuleDescriptor, type ModuleInstallClass } from "@tomflow/proflow-module-contract";
 export declare const PRO_FLOW_SCOPE = "@tomflow";
 export declare const PRO_FLOW_PACKAGE_PREFIX = "@tomflow/proflow-";
 export interface NpmCommandResult {
@@ -12,10 +11,8 @@ export interface RegistryModuleCandidate {
     packageName: string;
     moduleVersion: string;
     description?: string;
-    installClass: ModuleInstallClass;
     descriptor: string;
     manifest: "./proflow.module.json";
-    installRequires: string[];
     nodeVersionRange?: string;
     registry: string;
 }
@@ -38,14 +35,3 @@ export declare function discoverRegistryModules(options: {
     runner?: NpmCommandRunner;
     nodeVersion?: string;
 }): Promise<RegistryDiscoveryResult>;
-export declare function loadRegistryModuleDescriptor(options: {
-    workspaceRoot: string;
-    candidate: RegistryModuleCandidate;
-    runner?: NpmCommandRunner;
-}): Promise<ModuleDescriptor>;
-export declare function discoverRegistryInstallClosure(options: {
-    workspaceRoot: string;
-    packageName: string;
-    runner?: NpmCommandRunner;
-    nodeVersion?: string;
-}): Promise<RegistryDiscoveryResult>;