@tomflow/proflow-platform-cli 0.1.16 → 0.1.18

package/dist/src/lifecycle/dispatch.js

@@ -1,72 +1,44 @@
 import { moduleOperationResultSchema, } from "@tomflow/proflow-module-contract";
 import { PlatformError } from "../errors.js";
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function isPrimitiveFn(value) {
-    return typeof value === "function";
-}
-function isWrappedResult(value) {
-    return isRecord(value) && "result" in value;
-}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isCommandFn = (value) => typeof value === "function";
 function moduleSource(module) {
-    const source = {
-        type: module.source.type,
-        packageName: module.packageName,
-    };
-    if (module.source.path !== undefined)
-        source.path = module.source.path;
-    return source;
+    return module.source.path === undefined
+        ? { type: module.source.type, packageName: module.packageName }
+        : {
+            type: module.source.type,
+            packageName: module.packageName,
+            path: module.source.path,
+        };
 }
 function resolveBehaviorAdapter(namespace) {
-    if (!isRecord(namespace)) {
-        throw new PlatformError("COMMAND_FAILED", "lifecycle adapter namespace is not an object");
-    }
-    const behaviorAdapter = namespace.behaviorAdapter;
-    if (!isRecord(behaviorAdapter)) {
-        throw new PlatformError("COMMAND_FAILED", "lifecycle adapter exposes no behaviorAdapter object");
-    }
-    return behaviorAdapter;
-}
-function observedEffectsOf(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => typeof item === "string");
+    if (!isRecord(namespace) || !isRecord(namespace.behaviorAdapter))
+        throw new PlatformError("COMMAND_FAILED", "module adapter exposes no behaviorAdapter object");
+    return namespace.behaviorAdapter;
 }
 function normalizeInvocation(raw) {
-    if (isWrappedResult(raw)) {
-        return {
-            result: raw.result,
-            observedEffects: observedEffectsOf(raw.observedEffects),
-        };
-    }
-    return { result: raw, observedEffects: [] };
+    if (!isRecord(raw) || !("result" in raw))
+        return { result: raw, observedEffects: [] };
+    return {
+        result: raw.result,
+        observedEffects: Array.isArray(raw.observedEffects)
+            ? raw.observedEffects.filter((item) => typeof item === "string")
+            : [],
+    };
 }
-/**
- * Dispatches a single lifecycle primitive against one module through its
- * public deployment adapter. The descriptor is the source of truth for what is
- * supported: a primitive not declared in `lifecycle` is rejected with
- * `LIFECYCLE_UNSUPPORTED` rather than faked. The adapter result is always
- * runtime-validated against the Module Operation Result schema.
- */
-export async function dispatchLifecycle(catalog, module, primitive) {
-    if (!module.lifecycle.includes(primitive)) {
-        throw new PlatformError("LIFECYCLE_UNSUPPORTED", `module ${module.moduleRef} does not declare lifecycle primitive "${primitive}"`);
-    }
+export async function dispatchModuleCommand(catalog, module, command, context) {
     const namespace = await catalog.loadAdapter(moduleSource(module));
     const adapter = resolveBehaviorAdapter(namespace);
-    const invoke = adapter[primitive];
-    if (!isPrimitiveFn(invoke)) {
-        throw new PlatformError("COMMAND_FAILED", `module ${module.moduleRef} declares "${primitive}" but its adapter does not implement it`);
-    }
-    const { result, observedEffects } = normalizeInvocation(await invoke());
+    const invoke = adapter[command];
+    if (!isCommandFn(invoke))
+        throw new PlatformError("COMMAND_FAILED", `module ${module.moduleRef} does not implement standard command "${command}"`);
+    const { result, observedEffects } = normalizeInvocation(await invoke(context));
     const parsed = moduleOperationResultSchema.safeParse(result);
-    if (!parsed.success) {
-        throw new PlatformError("COMMAND_FAILED", `module ${module.moduleRef} "${primitive}" returned an invalid result: ${parsed.error.message}`);
-    }
+    if (!parsed.success)
+        throw new PlatformError("COMMAND_FAILED", `module ${module.moduleRef} "${command}" returned an invalid result: ${parsed.error.message}`);
     return {
         moduleRef: module.moduleRef,
-        primitive,
+        command,
         result: parsed.data,
         observedEffects,
     };

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

@@ -1,4 +1,4 @@
-export type { LifecycleDispatchResult } from "./dispatch.ts";
-export { dispatchLifecycle } from "./dispatch.ts";
-export type { ThinLifecycleResult } from "./thin.ts";
-export { observeStatuses, preflightAndStartModules, stopModulesThin, } from "./thin.ts";
+export type { ModuleDispatchResult } from "./dispatch.ts";
+export { dispatchModuleCommand } from "./dispatch.ts";
+export type { ModuleBatchResult } from "./thin.ts";
+export { installModulesThin, observeDocs, observeStatuses, setupModulesThin, startModulesThin, stopModulesThin, uninstallModulesThin, } from "./thin.ts";

package/dist/src/lifecycle/index.js

@@ -1,2 +1,2 @@
-export { dispatchLifecycle } from "./dispatch.js";
-export { observeStatuses, preflightAndStartModules, stopModulesThin, } from "./thin.js";
+export { dispatchModuleCommand } from "./dispatch.js";
+export { installModulesThin, observeDocs, observeStatuses, setupModulesThin, startModulesThin, stopModulesThin, uninstallModulesThin, } from "./thin.js";

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

@@ -1,11 +1,23 @@
+import { type ModuleSetupStatus } from "@tomflow/proflow-module-contract";
 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[];
+import { type ModuleDispatchResult } from "./dispatch.ts";
+export interface ModuleBatchResult {
+    phase: "install" | "uninstall" | "setup" | "start" | "stop";
+    results: ModuleDispatchResult[];
     completed: boolean;
+    blockedBy?: {
+        moduleRef: string;
+        setupStatus: ModuleSetupStatus;
+    };
 }
-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>;
+export declare function observeStatuses(catalog: ModuleCatalog, modules: readonly ResolvedModule[], workspaceRoot: string): Promise<ModuleDispatchResult[]>;
+export declare function observeDocs(catalog: ModuleCatalog, modules: readonly ResolvedModule[], workspaceRoot: string): Promise<ModuleDispatchResult[]>;
+export declare const installModulesThin: (catalog: ModuleCatalog, modules: readonly ResolvedModule[], workspaceRoot: string) => Promise<ModuleBatchResult>;
+export declare const uninstallModulesThin: (catalog: ModuleCatalog, modules: readonly ResolvedModule[], workspaceRoot: string) => Promise<ModuleBatchResult>;
+export declare const stopModulesThin: (catalog: ModuleCatalog, modules: readonly ResolvedModule[], workspaceRoot: string) => Promise<ModuleBatchResult>;
+export declare function setupModulesThin(catalog: ModuleCatalog, modules: readonly ResolvedModule[], workspaceRoot: string, target?: {
+    moduleRef: string;
+    input?: unknown;
+}): Promise<ModuleBatchResult>;
+export declare function startModulesThin(catalog: ModuleCatalog, modules: readonly ResolvedModule[], workspaceRoot: string): Promise<ModuleBatchResult>;

package/dist/src/lifecycle/thin.js

@@ -1,68 +1,98 @@
+import { moduleStatusObservationSchema, } from "@tomflow/proflow-module-contract";
+import { PlatformError } from "../errors.js";
 import { buildDependencyGraph } from "../graph/graph.js";
-import { dispatchLifecycle } from "./dispatch.js";
-function succeeded(result) {
-    return result.status === "SUCCEEDED";
+import { dispatchModuleCommand, } from "./dispatch.js";
+const succeeded = (result) => result.status === "SUCCEEDED";
+const context = (workspaceRoot, input) => input === undefined ? { workspaceRoot } : { workspaceRoot, input };
+function ordered(modules, reverse = false) {
+    const graph = buildDependencyGraph(modules);
+    const refs = reverse ? [...graph.order].reverse() : [...graph.order];
+    const byRef = new Map(modules.map((module) => [module.moduleRef, module]));
+    return refs
+        .map((ref) => byRef.get(ref))
+        .filter((item) => item !== undefined);
 }
-async function dispatchIfSupported(catalog, module, primitive) {
-    if (!module.lifecycle.includes(primitive))
-        return undefined;
-    return dispatchLifecycle(catalog, module, primitive);
+export async function observeStatuses(catalog, modules, workspaceRoot) {
+    const results = [];
+    for (const module of [...modules].sort((a, b) => a.moduleRef.localeCompare(b.moduleRef)))
+        results.push(await dispatchModuleCommand(catalog, module, "status", context(workspaceRoot)));
+    return results;
 }
-export async function observeStatuses(catalog, modules) {
+export async function observeDocs(catalog, modules, workspaceRoot) {
     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"));
-    }
+    for (const module of [...modules].sort((a, b) => a.moduleRef.localeCompare(b.moduleRef)))
+        results.push(await dispatchModuleCommand(catalog, module, "docs", context(workspaceRoot)));
     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)
+async function runOrdered(catalog, modules, workspaceRoot, command, reverse) {
+    const results = [];
+    for (const module of ordered(modules, reverse)) {
+        const result = await dispatchModuleCommand(catalog, module, command, context(workspaceRoot));
+        results.push(result);
+        if (!succeeded(result.result))
+            return { phase: command, results, completed: false };
+    }
+    return { phase: command, results, completed: true };
+}
+export const installModulesThin = (catalog, modules, workspaceRoot) => runOrdered(catalog, modules, workspaceRoot, "install", false);
+export const uninstallModulesThin = (catalog, modules, workspaceRoot) => runOrdered(catalog, modules, workspaceRoot, "uninstall", true);
+export const stopModulesThin = (catalog, modules, workspaceRoot) => runOrdered(catalog, modules, workspaceRoot, "stop", true);
+export async function setupModulesThin(catalog, modules, workspaceRoot, target) {
+    const results = [];
+    let matched = target === undefined;
+    let completed = true;
+    for (const module of ordered(modules)) {
+        if (target !== undefined && module.moduleRef !== target.moduleRef)
             continue;
-        const result = await dispatchIfSupported(catalog, module, "preflight");
-        if (result === undefined)
+        matched = true;
+        const status = await dispatchModuleCommand(catalog, module, "status", context(workspaceRoot));
+        if (!succeeded(status.result)) {
+            results.push(status);
+            completed = false;
+            if (target !== undefined)
+                break;
             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)
+        const observed = moduleStatusObservationSchema.parse(status.result.data);
+        if (observed.setupStatus === "READY" && target?.input === 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 };
+        const setup = await dispatchModuleCommand(catalog, module, "setup", context(workspaceRoot, target?.input));
+        results.push(setup);
+        if (!succeeded(setup.result)) {
+            completed = false;
+            if (target !== undefined)
+                break;
         }
     }
-    return { phase: "start", results: started, completed: true };
+    if (!matched)
+        throw new PlatformError("INVALID_REQUEST", `setup target module ${target?.moduleRef ?? ""} was not discovered`);
+    return { phase: "setup", results, completed };
 }
-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 };
-        }
+export async function startModulesThin(catalog, modules, workspaceRoot) {
+    const results = [];
+    for (const module of ordered(modules)) {
+        const status = await dispatchModuleCommand(catalog, module, "status", context(workspaceRoot));
+        if (!succeeded(status.result))
+            return {
+                phase: "start",
+                results: [...results, status],
+                completed: false,
+            };
+        const observed = moduleStatusObservationSchema.parse(status.result.data);
+        if (observed.setupStatus !== "READY")
+            return {
+                phase: "start",
+                results: [...results, status],
+                completed: false,
+                blockedBy: {
+                    moduleRef: module.moduleRef,
+                    setupStatus: observed.setupStatus,
+                },
+            };
+        const started = await dispatchModuleCommand(catalog, module, "start", context(workspaceRoot));
+        results.push(started);
+        if (!succeeded(started.result))
+            return { phase: "start", results, completed: false };
     }
-    return { phase: "stop", results: stopped, completed: true };
+    return { phase: "start", results, completed: true };
 }

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

@@ -1,4 +1,2 @@
-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,2 +1 @@
-export { loadConfig } from "./config.js";
 export { ensureWorkspaceMetadata } from "./workspace-metadata.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-platform-cli",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -18,14 +18,16 @@
     "dist",
     "proflow.module.json",
     "conformance.json",
-    "README.md"
+    "README.md",
+    "DOCS.md",
+    "SETUP.md"
   ],
   "dependencies": {
-    "@tomflow/proflow-module-contract": "^0.1.3"
+    "@tomflow/proflow-module-contract": "^0.1.5"
   },
   "devDependencies": {
-    "@tomflow/proflow-deployment-conformance": "^0.1.3",
-    "@tomflow/proflow-module-template": "^0.1.3"
+    "@tomflow/proflow-module-template": "^0.1.5",
+    "@tomflow/proflow-deployment-conformance": "^0.1.5"
   },
   "description": "Thin Platform CLI for Module discovery, documentation, package synchronization and lifecycle orchestration.",
   "keywords": [

package/proflow.module.json

@@ -3,7 +3,7 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "platform-cli",
 	"packageName": "@tomflow/proflow-platform-cli",
-	"moduleVersion": "0.1.16",
+	"moduleVersion": "0.1.18",
 	"kind": "cli",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",
@@ -21,24 +21,9 @@
 		}
 	],
 	"configSlots": [],
-	"lifecycle": {
-		"supported": ["describe", "preflight", "status", "verify", "doctor"]
-	},
-	"verification": {
-		"checks": [
-			{
-				"id": "cli-surface",
-				"description": "Deterministic command surface parses and dispatches",
-				"lifecycle": "verify"
-			}
-		]
-	},
 	"effects": [],
-	"documentation": [
-		{
-			"id": "overview",
-			"path": "./README.md",
-			"description": "Platform CLI package overview and command surface"
-		}
-	]
+	"documentation": {
+		"docs": "DOCS.md",
+		"setup": "SETUP.md"
+	}
 }

package/dist/src/binding/production-bindings.d.ts

@@ -1,37 +0,0 @@
-import type { ResolvedModule } from "../contracts.ts";
-type ResolvedSource = ResolvedModule["source"];
-export interface DeploymentAdapterBinding {
-    behaviorAdapter: Record<string, unknown>;
-}
-export type ProductionBindingFactory = (input: {
-    moduleRef: string;
-    config: Record<string, string>;
-    workspaceRoot: string;
-    modules: readonly ResolvedModule[];
-    configByModuleRef: ReadonlyMap<string, Record<string, string>>;
-}) => Promise<DeploymentAdapterBinding | undefined> | DeploymentAdapterBinding | undefined;
-export interface ProductionBindingOptions {
-    workspaceRoot: string;
-    modules: readonly ResolvedModule[];
-    configByModuleRef: ReadonlyMap<string, {
-        publicValues: Record<string, string>;
-        secretValues: Record<string, string>;
-    }>;
-    importAdapter: (packageName: string, source: ResolvedSource) => Promise<Record<string, unknown>>;
-}
-export declare function importRawAdapter(packageName: string, source: ResolvedSource, workspaceRoot: string): Promise<Record<string, unknown>>;
-/**
- * The shipped Platform CLI production binding factory. For every discovered
- * module it imports the module's own `deployment/adapter.ts` and, when that
- * adapter exposes a `createProductionBinding` factory, invokes it with the
- * module's materialized config to obtain a real bound adapter. A module without
- * a production factory, or whose materialized config the adapter does not accept,
- * is left out of the map. Import/factory exceptions are surfaced with module
- * identity instead of being mistaken for ordinary unconfigured state. The
- * catalog falls back to the module's unbound default only for explicit undefined
- * bindings, which must fail-closed
- * (ACTION_REQUIRED / NOT_READY). Platform CLI never invents a service or
- * resource reality: it only relays the adapter's own current reality.
- */
-export declare function buildProductionBindings(options: ProductionBindingOptions): Promise<ReadonlyMap<string, DeploymentAdapterBinding>>;
-export {};

package/dist/src/binding/production-bindings.js

@@ -1,75 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { createRequire } from "node:module";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { PlatformError } from "../errors.js";
-export async function importRawAdapter(packageName, source, workspaceRoot) {
-    if (source.type === "workspace") {
-        if (source.path === undefined)
-            return {};
-        const url = pathToFileURL(join(source.path, "deployment", "adapter.ts"));
-        return (await /* architecture-allow-local-file-url-import */ import(__rewriteRelativeImportExtension(url.href)));
-    }
-    const workspaceRequire = createRequire(pathToFileURL(join(workspaceRoot, "package.json")));
-    const resolved = workspaceRequire.resolve(`${packageName}/deployment/adapter`);
-    const url = pathToFileURL(resolved);
-    return (await /* architecture-allow-local-file-url-import */ import(__rewriteRelativeImportExtension(url.href)));
-}
-/**
- * The shipped Platform CLI production binding factory. For every discovered
- * module it imports the module's own `deployment/adapter.ts` and, when that
- * adapter exposes a `createProductionBinding` factory, invokes it with the
- * module's materialized config to obtain a real bound adapter. A module without
- * a production factory, or whose materialized config the adapter does not accept,
- * is left out of the map. Import/factory exceptions are surfaced with module
- * identity instead of being mistaken for ordinary unconfigured state. The
- * catalog falls back to the module's unbound default only for explicit undefined
- * bindings, which must fail-closed
- * (ACTION_REQUIRED / NOT_READY). Platform CLI never invents a service or
- * resource reality: it only relays the adapter's own current reality.
- */
-export async function buildProductionBindings(options) {
-    const bindings = new Map();
-    const publicConfigByModuleRef = new Map([...options.configByModuleRef].map(([moduleRef, config]) => [
-        moduleRef,
-        { ...config.publicValues },
-    ]));
-    for (const module of options.modules) {
-        try {
-            const namespace = await options.importAdapter(module.packageName, module.source);
-            const materialized = options.configByModuleRef.get(module.moduleRef);
-            const config = materialized === undefined
-                ? {}
-                : { ...materialized.publicValues, ...materialized.secretValues };
-            const factory = namespace
-                .createProductionBinding;
-            if (typeof factory !== "function")
-                continue;
-            const binding = await factory({
-                moduleRef: module.moduleRef,
-                config,
-                workspaceRoot: options.workspaceRoot,
-                modules: options.modules,
-                configByModuleRef: publicConfigByModuleRef,
-            });
-            if (binding !== undefined &&
-                typeof binding === "object" &&
-                binding !== null &&
-                typeof binding.behaviorAdapter === "object" &&
-                binding.behaviorAdapter !== null) {
-                bindings.set(module.packageName, binding);
-            }
-        }
-        catch (error) {
-            throw new PlatformError("COMMAND_FAILED", `production binding failed for ${module.moduleRef}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return bindings;
-}

package/dist/src/docs/aggregate.d.ts

@@ -1,18 +0,0 @@
-import { type ConfigSlot, type ModuleProvide, type ModuleRequire } from "@tomflow/proflow-module-contract";
-import type { ResolvedModule } from "../contracts.ts";
-import type { ModuleCatalog } from "../modules.ts";
-export interface AggregatedDocument {
-    id: string;
-    path: string;
-    description?: string;
-    content: string;
-}
-export interface AggregatedModuleDocs {
-    moduleRef: string;
-    version: string;
-    provides: ModuleProvide[];
-    requires: ModuleRequire[];
-    configSlots: ConfigSlot[];
-    documents: AggregatedDocument[];
-}
-export declare function aggregateModuleDocs(workspaceRoot: string, catalog: ModuleCatalog, modules: readonly ResolvedModule[]): Promise<AggregatedModuleDocs[]>;

package/dist/src/docs/aggregate.js

@@ -1,44 +0,0 @@
-import { parseModuleDescriptor, } from "@tomflow/proflow-module-contract";
-import { readModuleDocument } from "./docs.js";
-function sourceOf(module) {
-    return module.source.path === undefined
-        ? { type: module.source.type, packageName: module.packageName }
-        : {
-            type: module.source.type,
-            packageName: module.packageName,
-            path: module.source.path,
-        };
-}
-export async function aggregateModuleDocs(workspaceRoot, catalog, modules) {
-    const output = [];
-    for (const module of [...modules].sort((a, b) => a.moduleRef.localeCompare(b.moduleRef))) {
-        const source = sourceOf(module);
-        const descriptor = parseModuleDescriptor(await catalog.loadDescriptor(source));
-        const documents = [];
-        for (const entry of descriptor.documentation) {
-            const document = await readModuleDocument({
-                workspaceRoot,
-                source,
-                descriptor,
-                documentId: entry.id,
-            });
-            documents.push({
-                id: document.documentId,
-                path: document.path,
-                ...(document.description === undefined
-                    ? {}
-                    : { description: document.description }),
-                content: document.content,
-            });
-        }
-        output.push({
-            moduleRef: module.moduleRef,
-            version: module.moduleVersion,
-            provides: [...descriptor.provides],
-            requires: [...descriptor.requires],
-            configSlots: [...descriptor.configSlots],
-            documents,
-        });
-    }
-    return output;
-}

package/dist/src/docs/docs.d.ts

@@ -1,16 +0,0 @@
-import type { ModuleDescriptor } from "@tomflow/proflow-module-contract";
-import type { ModuleSource } from "../modules.ts";
-export interface ModuleDocumentContent {
-    moduleRef: string;
-    packageName: string;
-    documentId: string;
-    path: string;
-    description?: string;
-    content: string;
-}
-export declare function readModuleDocument(input: {
-    workspaceRoot: string;
-    source: ModuleSource;
-    descriptor: ModuleDescriptor;
-    documentId: string;
-}): Promise<ModuleDocumentContent>;

package/dist/src/docs/docs.js

@@ -1,68 +0,0 @@
-import { readFile, realpath, stat } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { dirname, join, resolve, sep } from "node:path";
-import { pathToFileURL } from "node:url";
-import { PlatformError } from "../errors.js";
-async function packageRootFor(workspaceRoot, source) {
-    if (source.type === "workspace") {
-        if (source.path === undefined) {
-            throw new PlatformError("DESCRIPTOR_INVALID", `workspace source missing path for ${source.packageName}`);
-        }
-        return await realpath(source.path);
-    }
-    const require = createRequire(pathToFileURL(join(workspaceRoot, "package.json")));
-    let current;
-    try {
-        current = dirname(require.resolve(`${source.packageName}/deployment/descriptor`));
-    }
-    catch (error) {
-        throw new PlatformError("DESCRIPTOR_INVALID", `cannot resolve installed package ${source.packageName}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    for (;;) {
-        try {
-            const manifest = JSON.parse(await readFile(join(current, "package.json"), "utf8"));
-            if (manifest.name === source.packageName)
-                return await realpath(current);
-        }
-        catch {
-            // Export maps commonly hide package.json; keep walking from a resolved
-            // package-owned descriptor until the package root is found.
-        }
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    throw new PlatformError("DESCRIPTOR_INVALID", `package root not found for ${source.packageName}`);
-}
-export async function readModuleDocument(input) {
-    const entry = input.descriptor.documentation.find((candidate) => candidate.id === input.documentId);
-    if (entry === undefined) {
-        throw new PlatformError("INVALID_REQUEST", `document "${input.documentId}" is not declared by ${input.descriptor.moduleRef}`);
-    }
-    const packageRoot = await packageRootFor(input.workspaceRoot, input.source);
-    const root = resolve(packageRoot);
-    const target = resolve(root, entry.path);
-    if (target === root || !target.startsWith(`${root}${sep}`)) {
-        throw new PlatformError("DESCRIPTOR_INVALID", `documentation path escapes package root for ${input.descriptor.moduleRef}`);
-    }
-    try {
-        const info = await stat(target);
-        if (!info.isFile())
-            throw new Error("not a file");
-        const content = await readFile(target, "utf8");
-        return {
-            moduleRef: input.descriptor.moduleRef,
-            packageName: input.descriptor.packageName,
-            documentId: entry.id,
-            path: entry.path,
-            ...(entry.description === undefined
-                ? {}
-                : { description: entry.description }),
-            content,
-        };
-    }
-    catch (error) {
-        throw new PlatformError("DESCRIPTOR_INVALID", `cannot read document ${entry.id} for ${input.descriptor.moduleRef}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

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

@@ -1,2 +0,0 @@
-export type { AggregatedDocument, AggregatedModuleDocs, } from "./aggregate.ts";
-export { aggregateModuleDocs } from "./aggregate.ts";