@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/commands/inspect-module-plan-format.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatModulePlanAgentText = formatModulePlanAgentText;
+exports.formatModulePlanBlocking = formatModulePlanBlocking;
+exports.compactInvalidModulePlanFacade = compactInvalidModulePlanFacade;
+exports.collectInvalidModulePlanAffectedFiles = collectInvalidModulePlanAffectedFiles;
+exports.formatModulePlanBoundaryWarnings = formatModulePlanBoundaryWarnings;
+exports.formatModulePlanPreviewSummary = formatModulePlanPreviewSummary;
+exports.formatModulePlanPreviewWarnings = formatModulePlanPreviewWarnings;
+exports.formatModulePlanPreviewNext = formatModulePlanPreviewNext;
+exports.formatModulePlanIntegrity = formatModulePlanIntegrity;
+function formatModulePlanAgentText(response) {
+    const items = Array.isArray(response.results)
+        ? response.results.filter(isObject)
+        : isObject(response) ? [response] : [];
+    if (items.length === 0) {
+        return null;
+    }
+    const lines = [];
+    for (const item of items) {
+        const operation = typeof item.operation === "string" ? item.operation : "modulePlan.preview";
+        const planId = typeof item.planId === "string" ? item.planId : "";
+        lines.push(planId ? `${operation} ${planId}` : operation);
+        if (item.ok === false && typeof item.code === "string") {
+            lines.push(`blocked: ${item.code}`);
+        }
+        if (typeof item.summary === "string") {
+            lines.push(item.summary);
+        }
+        if (typeof item.integrity === "string") {
+            lines.push(item.integrity);
+        }
+        if (isObject(item.api) && typeof item.api.status === "string") {
+            const before = typeof item.api.before === "number" ? item.api.before : null;
+            const after = typeof item.api.after === "number" ? item.api.after : null;
+            lines.push(before !== null && after !== null
+                ? `api: ${item.api.status} ${before}->${after}`
+                : `api: ${item.api.status}`);
+        }
+        if (typeof item.cycles === "string") {
+            lines.push(`cycles: ${item.cycles}`);
+        }
+        if (Array.isArray(item.targets) && item.targets.length > 0) {
+            lines.push("targets:");
+            for (const target of item.targets.filter(isObject)) {
+                const file = typeof target.file === "string" ? target.file : "";
+                const summary = typeof target.summary === "string" ? target.summary : "";
+                if (file && summary) {
+                    lines.push(`${file}: ${summary}`);
+                }
+            }
+        }
+        if (Array.isArray(item.blocking) && item.blocking.length > 0) {
+            lines.push("blocking:");
+            for (const issue of item.blocking.filter(isObject)) {
+                const code = typeof issue.code === "string" ? issue.code : "MODULE_PLAN_BLOCKING";
+                const symbols = Array.isArray(issue.symbols)
+                    ? issue.symbols.filter((symbol) => typeof symbol === "string")
+                    : [];
+                lines.push(symbols.length > 0 ? `${code}: ${symbols.join(", ")}` : code);
+                if (Array.isArray(issue.suggestedFixes) && issue.suggestedFixes.length > 0) {
+                    lines.push(`suggestedFixes: ${issue.suggestedFixes.length}`);
+                }
+            }
+        }
+        if (Array.isArray(item.remainingBlocking) && item.remainingBlocking.length > 0) {
+            lines.push(`remainingBlocking: ${item.remainingBlocking.length}`);
+        }
+        if (Array.isArray(item.resolved) && item.resolved.length > 0) {
+            lines.push(`resolved: ${item.resolved.length}`);
+        }
+        if (Array.isArray(item.changes) && item.changes.length > 0) {
+            lines.push("changes:");
+            for (const change of item.changes.filter((entry) => typeof entry === "string")) {
+                lines.push(change);
+            }
+        }
+        if (isObject(item.preview) && typeof item.preview.summary === "string") {
+            lines.push(`preview: ${item.preview.summary}`);
+        }
+        if (typeof item.next === "string") {
+            lines.push(`next: ${item.next}`);
+        }
+    }
+    return lines.join("\n");
+}
+function formatModulePlanBlocking(rawBoundary) {
+    const issues = Array.isArray(rawBoundary.nonExportedImports) ? rawBoundary.nonExportedImports.filter(isObject) : [];
+    return issues.map((issue) => {
+        const blocking = {
+            code: issue.code ?? "MODULE_PLAN_BOUNDARY_WARNING",
+            from: issue.from ?? "",
+            source: issue.source ?? "",
+            usage: issue.usage ?? "unknown",
+            symbols: Array.isArray(issue.symbols) ? issue.symbols : []
+        };
+        if (Array.isArray(issue.suggestedFixes) && issue.suggestedFixes.length > 0) {
+            blocking.suggestedFixes = issue.suggestedFixes;
+        }
+        if (typeof issue.hint === "string") {
+            blocking.hint = issue.hint;
+        }
+        return blocking;
+    });
+}
+function compactInvalidModulePlanFacade(rawFacade) {
+    const facade = {};
+    if (typeof rawFacade.file === "string") {
+        facade.file = rawFacade.file;
+    }
+    if (Array.isArray(rawFacade.exports)) {
+        facade.exports = rawFacade.exports.length;
+    }
+    return facade;
+}
+function collectInvalidModulePlanAffectedFiles(result) {
+    const files = new Set();
+    const blocking = Array.isArray(result.blocking) ? result.blocking.filter(isObject) : [];
+    for (const issue of blocking) {
+        if (typeof issue.from === "string" && issue.from) {
+            files.add(issue.from);
+        }
+        if (typeof issue.source === "string" && issue.source) {
+            files.add(issue.source);
+        }
+    }
+    return Array.from(files);
+}
+function formatModulePlanBoundaryWarnings(rawBoundary) {
+    if (!isObject(rawBoundary) || !Array.isArray(rawBoundary.nonExportedImports)) {
+        return [];
+    }
+    return rawBoundary.nonExportedImports
+        .filter(isObject)
+        .map((issue) => {
+        const from = typeof issue.from === "string" ? issue.from : "";
+        const source = typeof issue.source === "string" ? issue.source : "";
+        const symbols = Array.isArray(issue.symbols)
+            ? issue.symbols.filter((item) => typeof item === "string")
+            : [];
+        return from && source && symbols.length > 0
+            ? `${from} imports non-exported ${symbols.join(", ")} from ${source}`
+            : "";
+    })
+        .filter((warning) => warning !== "");
+}
+function formatModulePlanPreviewSummary(fileCount, facadeLineCount, patchLineCount, rawResult) {
+    const parts = [`${fileCount} ${fileCount === 1 ? "file" : "files"}`];
+    if (facadeLineCount > 0) {
+        parts.push(`facade ${facadeLineCount}l`);
+    }
+    if (patchLineCount > 0) {
+        parts.push(`patch ${patchLineCount}l`);
+    }
+    parts.push(modulePlanHasRuntimeCycles(rawResult) ? "cycles detected" : "cycles none");
+    return parts.join("; ");
+}
+function formatModulePlanPreviewWarnings(rawResult) {
+    if (!modulePlanHasRuntimeCycles(rawResult)) {
+        return [];
+    }
+    return ["runtime cycles detected"];
+}
+function formatModulePlanPreviewNext(rawResult, hasLargeArtifacts) {
+    if (modulePlanHasRuntimeCycles(rawResult)) {
+        return [
+            "fix module plan before applying",
+            "rerun modulePlan"
+        ];
+    }
+    return [
+        hasLargeArtifacts ? "check summary/api/cycles/imports before reading large preview artifacts" : "check summary/api/cycles/imports",
+        "read targeted preview artifacts only if a warning/check points there",
+        "use top-level next for apply/revise action"
+    ];
+}
+function formatModulePlanIntegrity(rawResult) {
+    const modules = Array.isArray(rawResult.modules) ? rawResult.modules.filter(isObject) : [];
+    if (modules.length === 0) {
+        return "";
+    }
+    const movedDeclarations = modules.reduce((count, module) => count + (Array.isArray(module.symbols) ? module.symbols.length : 0), 0);
+    const generatedImports = modules.reduce((count, module) => count + countModulePlanImportSymbols(module.imports), 0);
+    const facadeExports = isObject(rawResult.facade) && Array.isArray(rawResult.facade.exports)
+        ? rawResult.facade.exports.length
+        : 0;
+    const parts = [`${movedDeclarations} declarations moved unchanged`, `${generatedImports} imports generated`];
+    if (facadeExports > 0) {
+        parts.push(`facade exports ${facadeExports}`);
+    }
+    return parts.join("; ");
+}
+function modulePlanHasRuntimeCycles(rawResult) {
+    return Array.isArray(rawResult.cycles) && rawResult.cycles.length > 0;
+}
+function countModulePlanImportSymbols(rawImports) {
+    if (!isObject(rawImports)) {
+        return 0;
+    }
+    let count = 0;
+    for (const key of ["typeOnly", "value", "unclassified"]) {
+        const group = rawImports[key];
+        if (!Array.isArray(group)) {
+            continue;
+        }
+        for (const item of group) {
+            if (isObject(item) && Array.isArray(item.symbols)) {
+                count += item.symbols.length;
+            }
+        }
+    }
+    return count;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/commands/inspect-module-plan-serialization.js

@@ -0,0 +1,402 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatModulePlanResult = formatModulePlanResult;
+const inspect_format_primitives_1 = require("./inspect-format-primitives");
+const inspect_module_plan_format_1 = require("./inspect-module-plan-format");
+const inspect_symbol_format_1 = require("./inspect-symbol-format");
+const LARGE_PREVIEW_FILE_LINE_THRESHOLD = 500;
+const LARGE_PREVIEW_PATCH_LINE_THRESHOLD = 500;
+function formatModulePlanResult(rawResult, config, options, commonFile) {
+    const invalid = rawResult.ok === false;
+    const result = {
+        ...(0, inspect_format_primitives_1.baseResult)(rawResult, options, commonFile)
+    };
+    if (!invalid) {
+        const moduleSummaries = formatModulePlanTargetSummaries(rawResult.modules, config, options);
+        if (moduleSummaries.length > 0) {
+            result.targets = moduleSummaries;
+            result.moduleCount = moduleSummaries.length;
+        }
+        if (options.details === true) {
+            result.modules = formatModulePlanModules(rawResult.modules, config, options);
+        }
+    }
+    for (const field of ["planId", "executable", "next"]) {
+        if (rawResult[field] !== undefined) {
+            result[field] = rawResult[field];
+        }
+    }
+    if (invalid) {
+        result.ok = false;
+        result.code = typeof rawResult.code === "string" ? rawResult.code : "MODULE_PLAN_BLOCKED";
+    }
+    if ((0, inspect_format_primitives_1.isObject)(rawResult.api)) {
+        result.api = formatModulePlanApi(rawResult.api, config);
+    }
+    if ((0, inspect_format_primitives_1.isObject)(rawResult.boundary)) {
+        result.boundary = formatModulePlanBoundary(rawResult.boundary, config, options);
+        if (invalid && (0, inspect_format_primitives_1.isObject)(result.boundary)) {
+            const blocking = (0, inspect_module_plan_format_1.formatModulePlanBlocking)(result.boundary);
+            if (blocking.length > 0) {
+                result.blocking = blocking;
+                delete result.boundary;
+            }
+        }
+    }
+    const boundaryWarnings = (0, inspect_module_plan_format_1.formatModulePlanBoundaryWarnings)(result.boundary);
+    if (boundaryWarnings.length > 0) {
+        result.warnings = boundaryWarnings;
+    }
+    else if (Array.isArray(rawResult.warnings) && rawResult.warnings.length > 0) {
+        result.warnings = rawResult.warnings
+            .filter((item) => typeof item === "string")
+            .map((warning) => (0, inspect_format_primitives_1.formatTextPathReferences)(warning, options));
+    }
+    if ((0, inspect_format_primitives_1.isObject)(rawResult.facade)) {
+        const facade = formatModulePlanFacade(rawResult.facade, options);
+        result.facade = invalid ? (0, inspect_module_plan_format_1.compactInvalidModulePlanFacade)(facade) : facade;
+    }
+    const integrity = (0, inspect_module_plan_format_1.formatModulePlanIntegrity)(rawResult);
+    if (integrity) {
+        result.integrity = integrity;
+    }
+    if (Array.isArray(rawResult.cycles) && rawResult.cycles.length > 0) {
+        result.cycles = rawResult.cycles;
+    }
+    else {
+        result.cycles = "none";
+    }
+    if (!invalid && (0, inspect_format_primitives_1.isObject)(rawResult.preview)) {
+        result.preview = formatModulePlanPreview(rawResult.preview, options, rawResult);
+    }
+    if (Array.isArray(rawResult.symbolErrors) && rawResult.symbolErrors.length > 0) {
+        result.ok = false;
+        result.symbolErrors = rawResult.symbolErrors;
+    }
+    if (invalid) {
+        const affected = (0, inspect_module_plan_format_1.collectInvalidModulePlanAffectedFiles)(result);
+        if (affected.length > 0) {
+            result.affected = affected;
+        }
+        if (!result.next) {
+            result.next = "Revise the plan, then rerun modulePlan preview.";
+        }
+    }
+    return result;
+}
+function formatModulePlanApi(rawApi, config) {
+    const api = {};
+    if (typeof rawApi.status === "string") {
+        api.status = rawApi.status;
+    }
+    if (typeof rawApi.before === "number") {
+        api.before = rawApi.before;
+    }
+    if (typeof rawApi.after === "number") {
+        api.after = rawApi.after;
+    }
+    const removed = (0, inspect_symbol_format_1.formatSymbolReferencesArray)(rawApi.removed, config);
+    const added = (0, inspect_symbol_format_1.formatSymbolReferencesArray)(rawApi.added, config);
+    if (removed.length > 0) {
+        api.removed = removed;
+    }
+    if (added.length > 0) {
+        api.added = added;
+    }
+    return api;
+}
+function formatModulePlanBoundary(rawBoundary, config, options) {
+    const rawIssues = Array.isArray(rawBoundary.nonExportedImports) ? rawBoundary.nonExportedImports : [];
+    const issues = rawIssues
+        .filter(inspect_format_primitives_1.isObject)
+        .map((issue) => {
+        const payload = {
+            code: typeof issue.code === "string" ? issue.code : "MODULE_PLAN_BOUNDARY_WARNING",
+            from: typeof issue.importerFile === "string" ? (0, inspect_format_primitives_1.formatFilePath)(issue.importerFile, options) : "",
+            source: typeof issue.sourceFile === "string" ? (0, inspect_format_primitives_1.formatFilePath)(issue.sourceFile, options) : "",
+            usage: typeof issue.usageKind === "string" ? issue.usageKind : "unknown",
+            symbols: (0, inspect_symbol_format_1.formatSymbolReferencesArray)(issue.symbols, config)
+        };
+        const suggestedFixes = formatModulePlanSuggestedFixes(issue.suggestedFixes, config, options);
+        if (suggestedFixes.length > 0) {
+            payload.suggestedFixes = suggestedFixes;
+        }
+        if (typeof issue.hint === "string") {
+            payload.hint = issue.hint;
+        }
+        return payload;
+    })
+        .filter((issue) => Array.isArray(issue.symbols) && issue.symbols.length > 0);
+    return issues.length > 0 ? { nonExportedImports: issues } : {};
+}
+function formatModulePlanSuggestedFixes(rawFixes, config, options) {
+    if (!Array.isArray(rawFixes)) {
+        return [];
+    }
+    return rawFixes
+        .filter(inspect_format_primitives_1.isObject)
+        .map((fix) => {
+        const payload = {
+            kind: typeof fix.kind === "string" ? fix.kind : "unknown"
+        };
+        const symbol = (0, inspect_symbol_format_1.formatSymbolReference)(fix.symbol, config);
+        if (symbol) {
+            payload.symbol = symbol;
+        }
+        if (typeof fix.toFile === "string") {
+            payload.to = (0, inspect_format_primitives_1.formatFilePath)(fix.toFile, options);
+        }
+        if (typeof fix.fromFile === "string") {
+            payload.from = (0, inspect_format_primitives_1.formatFilePath)(fix.fromFile, options);
+        }
+        if (typeof fix.risk === "string") {
+            payload.risk = fix.risk;
+        }
+        if (typeof fix.warning === "string") {
+            payload.warning = fix.warning;
+        }
+        if ((0, inspect_format_primitives_1.isObject)(fix.saferAlternative)) {
+            const saferAlternatives = formatModulePlanSuggestedFixes([fix.saferAlternative], config, options);
+            const saferAlternative = saferAlternatives[0];
+            if (saferAlternative) {
+                payload.saferAlternative = saferAlternative;
+            }
+        }
+        return payload;
+    })
+        .filter((fix) => typeof fix.symbol === "string");
+}
+function formatModulePlanModules(rawModules, config, options) {
+    if (!Array.isArray(rawModules)) {
+        return {};
+    }
+    const modules = {};
+    for (const rawModule of rawModules) {
+        if (!(0, inspect_format_primitives_1.isObject)(rawModule) || typeof rawModule.targetFile !== "string") {
+            continue;
+        }
+        const targetFile = (0, inspect_format_primitives_1.formatFilePath)(rawModule.targetFile, options);
+        const modulePayload = {
+            owns: (0, inspect_symbol_format_1.formatSymbolReferencesArray)(rawModule.symbols, config)
+        };
+        const imports = formatModulePlanImports(rawModule.imports, config, options);
+        if (Object.keys(imports).length > 0) {
+            modulePayload.uses = imports;
+        }
+        const internalDependencies = (0, inspect_symbol_format_1.formatSymbolReferencesArray)(rawModule.internalDependencies, config);
+        if (internalDependencies.length > 0) {
+            modulePayload.internalDeps = internalDependencies;
+        }
+        const unassigned = formatModulePlanDependencyGroups(rawModule.unassignedDependencies, config);
+        if (Object.keys(unassigned).length > 0) {
+            modulePayload.unassigned = unassigned;
+        }
+        modules[targetFile] = modulePayload;
+    }
+    return modules;
+}
+function formatModulePlanTargetSummaries(rawModules, config, options) {
+    if (!Array.isArray(rawModules)) {
+        return [];
+    }
+    return rawModules
+        .filter(inspect_format_primitives_1.isObject)
+        .filter((module) => typeof module.targetFile === "string")
+        .map((module) => {
+        const target = {
+            file: (0, inspect_format_primitives_1.formatFilePath)(String(module.targetFile), options),
+            summary: formatModulePlanTargetSummary(module, config, options)
+        };
+        const unassigned = countDependencyGroups(module.unassignedDependencies);
+        if (unassigned !== "") {
+            target.warning = `unassigned ${unassigned}`;
+        }
+        return target;
+    });
+}
+function formatModulePlanTargetSummary(module, config, options) {
+    const exported = formatModulePlanSymbolsByExport(module.symbols, config, true);
+    const privateSymbols = formatModulePlanSymbolsByExport(module.symbols, config, false);
+    const imports = summarizeModulePlanImports(module.imports, config, options);
+    const internalDeps = (0, inspect_symbol_format_1.formatSymbolReferencesArray)(module.internalDependencies, config).length;
+    const parts = [`exports ${(0, inspect_format_primitives_1.summarizeList)(exported, 4) || "none"}`];
+    if (privateSymbols.length > 0) {
+        parts.push(`private ${(0, inspect_format_primitives_1.summarizeList)(privateSymbols, 3)}`);
+    }
+    if (imports !== "") {
+        parts.push(`imports ${imports}`);
+    }
+    if (internalDeps > 0) {
+        parts.push(`internalDeps ${internalDeps}`);
+    }
+    return parts.join("; ");
+}
+function formatModulePlanSymbolsByExport(rawSymbols, config, exported) {
+    if (!Array.isArray(rawSymbols)) {
+        return [];
+    }
+    return rawSymbols
+        .filter(inspect_format_primitives_1.isObject)
+        .filter((symbol) => (symbol.exported === true) === exported)
+        .map((symbol) => (0, inspect_symbol_format_1.formatSymbolReference)(symbol, config))
+        .filter((selector) => selector !== "");
+}
+function summarizeModulePlanImports(rawImports, config, options) {
+    if (!(0, inspect_format_primitives_1.isObject)(rawImports)) {
+        return "";
+    }
+    const parts = [];
+    const keyLabels = {
+        typeOnly: "type",
+        value: "run",
+        unclassified: "unclassified"
+    };
+    for (const key of ["typeOnly", "value", "unclassified"]) {
+        const summary = summarizeModulePlanImportGroup(rawImports[key], config, options);
+        if (summary !== "") {
+            parts.push(`${keyLabels[key]} ${summary}`);
+        }
+    }
+    return parts.join("; ");
+}
+function summarizeModulePlanImportGroup(rawGroup, config, options) {
+    if (!Array.isArray(rawGroup)) {
+        return "";
+    }
+    const entries = rawGroup
+        .filter(inspect_format_primitives_1.isObject)
+        .filter((item) => typeof item.targetFile === "string")
+        .map((item) => {
+        const file = (0, inspect_format_primitives_1.formatFilePath)(String(item.targetFile), options);
+        const symbols = (0, inspect_symbol_format_1.formatSymbolReferencesArray)(item.symbols, config).filter((value) => typeof value === "string");
+        return `${file}: ${(0, inspect_format_primitives_1.summarizeList)(symbols, 3) || "none"}`;
+    });
+    return (0, inspect_format_primitives_1.summarizeList)(entries, 2, "more imports");
+}
+function countDependencyGroups(rawGroups) {
+    if (!(0, inspect_format_primitives_1.isObject)(rawGroups)) {
+        return "";
+    }
+    const parts = [];
+    for (const key of ["typeOnly", "value", "unclassified"]) {
+        const group = rawGroups[key];
+        if (Array.isArray(group) && group.length > 0) {
+            parts.push(`${key} ${group.length}`);
+        }
+    }
+    return parts.join("; ");
+}
+function formatModulePlanImports(rawImports, config, options) {
+    if (!(0, inspect_format_primitives_1.isObject)(rawImports)) {
+        return {};
+    }
+    const imports = {};
+    const keyMap = {
+        typeOnly: "type",
+        value: "run",
+        unclassified: "unclassified"
+    };
+    for (const key of ["typeOnly", "value", "unclassified"]) {
+        const group = formatModulePlanImportGroup(rawImports[key], config, options);
+        if (Object.keys(group).length > 0) {
+            imports[keyMap[key]] = group;
+        }
+    }
+    return imports;
+}
+function formatModulePlanImportGroup(rawGroup, config, options) {
+    if (!Array.isArray(rawGroup)) {
+        return {};
+    }
+    const group = {};
+    for (const rawImport of rawGroup) {
+        if (!(0, inspect_format_primitives_1.isObject)(rawImport) || typeof rawImport.targetFile !== "string") {
+            continue;
+        }
+        group[(0, inspect_format_primitives_1.formatFilePath)(rawImport.targetFile, options)] = (0, inspect_symbol_format_1.formatSymbolReferencesArray)(rawImport.symbols, config);
+    }
+    return group;
+}
+function formatModulePlanDependencyGroups(rawGroups, config) {
+    if (!(0, inspect_format_primitives_1.isObject)(rawGroups)) {
+        return {};
+    }
+    const groups = {};
+    for (const key of ["typeOnly", "value", "unclassified"]) {
+        const symbols = (0, inspect_symbol_format_1.formatSymbolReferencesArray)(rawGroups[key], config);
+        if (symbols.length > 0) {
+            groups[key] = symbols;
+        }
+    }
+    return groups;
+}
+function formatModulePlanFacade(rawFacade, options) {
+    const facade = {};
+    if (typeof rawFacade.file === "string") {
+        facade.file = (0, inspect_format_primitives_1.formatFilePath)(rawFacade.file, options);
+    }
+    if (Array.isArray(rawFacade.exports) && rawFacade.exports.length > 0) {
+        facade.exports = rawFacade.exports
+            .filter((value) => typeof value === "string")
+            .map((line) => line.match(/from\s+"([^"]+)"/)?.[1] ?? line);
+    }
+    return facade;
+}
+function formatModulePlanPreview(rawPreview, options, rawResult) {
+    const preview = {};
+    if (typeof rawPreview.dir === "string") {
+        preview.dir = (0, inspect_format_primitives_1.formatFilePath)(rawPreview.dir, options);
+    }
+    const largeArtifacts = [];
+    let fileCount = 0;
+    let facadeLineCount = 0;
+    let patchLineCount = 0;
+    if (Array.isArray(rawPreview.files)) {
+        const files = {};
+        for (const item of rawPreview.files) {
+            if (!(0, inspect_format_primitives_1.isObject)(item) || typeof item.targetFile !== "string" || typeof item.previewFile !== "string") {
+                continue;
+            }
+            fileCount += 1;
+            const targetFile = (0, inspect_format_primitives_1.formatFilePath)(item.targetFile, options);
+            const lineCount = (0, inspect_format_primitives_1.numberOrZero)(item.lineCount);
+            files[(0, inspect_format_primitives_1.formatFilePath)(item.targetFile, options)] = {
+                file: (0, inspect_format_primitives_1.formatFilePath)(item.previewFile, options),
+                lines: lineCount
+            };
+            if (lineCount >= LARGE_PREVIEW_FILE_LINE_THRESHOLD) {
+                largeArtifacts.push(`${targetFile} ${lineCount}l`);
+            }
+        }
+        if (Object.keys(files).length > 0) {
+            preview.files = files;
+        }
+    }
+    if ((0, inspect_format_primitives_1.isObject)(rawPreview.facade) && typeof rawPreview.facade.previewFile === "string") {
+        facadeLineCount = (0, inspect_format_primitives_1.numberOrZero)(rawPreview.facade.lineCount);
+        preview.facade = {
+            file: (0, inspect_format_primitives_1.formatFilePath)(rawPreview.facade.previewFile, options),
+            lines: facadeLineCount
+        };
+    }
+    if ((0, inspect_format_primitives_1.isObject)(rawPreview.patch) && typeof rawPreview.patch.file === "string") {
+        patchLineCount = (0, inspect_format_primitives_1.numberOrZero)(rawPreview.patch.lineCount);
+        preview.patch = {
+            file: (0, inspect_format_primitives_1.formatFilePath)(rawPreview.patch.file, options),
+            lines: patchLineCount
+        };
+        if (patchLineCount >= LARGE_PREVIEW_PATCH_LINE_THRESHOLD) {
+            largeArtifacts.push(`patch ${patchLineCount}l`);
+        }
+    }
+    preview.summary = (0, inspect_module_plan_format_1.formatModulePlanPreviewSummary)(fileCount, facadeLineCount, patchLineCount, rawResult);
+    if (largeArtifacts.length > 0) {
+        preview.large = largeArtifacts;
+    }
+    const warnings = (0, inspect_module_plan_format_1.formatModulePlanPreviewWarnings)(rawResult);
+    if (warnings.length > 0) {
+        preview.warnings = warnings;
+    }
+    preview.next = (0, inspect_module_plan_format_1.formatModulePlanPreviewNext)(rawResult, largeArtifacts.length > 0);
+    return preview;
+}