outfitter 0.3.2 → 0.3.4

package/dist/shared/outfitter-tqznjgbm.js

@@ -0,0 +1,44 @@
+// @bun
+import {
+  resolvePresetDependencyVersions
+} from "./outfitter-x39awx8g.js";
+
+// apps/outfitter/src/commands/shared-deps.ts
+import { getResolvedVersions } from "@outfitter/presets";
+var { all: resolvedVersions } = getResolvedVersions();
+function requireVersion(name) {
+  const version = resolvedVersions[name];
+  if (!version) {
+    throw new Error(`Missing resolved version for "${name}" in @outfitter/presets`);
+  }
+  return version;
+}
+function requireInternalVersion(name) {
+  const versions = resolvePresetDependencyVersions();
+  const version = versions.internal[name];
+  if (!version) {
+    throw new Error(`Missing internal version for "${name}" \u2014 not found in workspace packages or outfitter's own dependencies`);
+  }
+  return version;
+}
+var SHARED_DEV_DEPS = {
+  "@outfitter/oxlint-plugin": requireInternalVersion("@outfitter/oxlint-plugin"),
+  "@outfitter/tooling": requireInternalVersion("@outfitter/tooling"),
+  "@types/bun": requireVersion("@types/bun"),
+  lefthook: requireVersion("lefthook"),
+  oxfmt: requireVersion("oxfmt"),
+  oxlint: requireVersion("oxlint"),
+  typescript: requireVersion("typescript"),
+  ultracite: requireVersion("ultracite")
+};
+var SHARED_SCRIPTS = {
+  check: "ultracite check",
+  "clean:artifacts": "rm -rf dist .turbo",
+  "verify:ci": "bun run typecheck && bun run check && bun run build && bun run test",
+  lint: "oxlint .",
+  "lint:fix": "oxlint --fix .",
+  format: "oxfmt --write .",
+  typecheck: "tsc --noEmit"
+};
+
+export { SHARED_DEV_DEPS, SHARED_SCRIPTS };

package/dist/shared/outfitter-ttjr95y9.js

@@ -0,0 +1,98 @@
+// @bun
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/engine/render-plan.ts
+import { relative } from "path";
+import { output } from "@outfitter/cli";
+async function renderOperationPlan(collector, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    await output(collector.toJSON(), { mode: structuredMode });
+    return;
+  }
+  const rootDir = options?.rootDir ?? process.cwd();
+  const operations = collector.getOperations();
+  const lines = ["[dry-run] Operation plan:", ""];
+  const fileCreates = operations.filter((op) => op.type === "file-create");
+  const fileOverwrites = operations.filter((op) => op.type === "file-overwrite");
+  const fileSkips = operations.filter((op) => op.type === "file-skip");
+  const dirCreates = operations.filter((op) => op.type === "dir-create");
+  const blockAdds = operations.filter((op) => op.type === "block-add");
+  const depAdds = operations.filter((op) => op.type === "dependency-add");
+  const configInjects = operations.filter((op) => op.type === "config-inject");
+  const installOps = operations.filter((op) => op.type === "install");
+  const gitOps = operations.filter((op) => op.type === "git");
+  if (fileCreates.length > 0) {
+    lines.push(`Create ${fileCreates.length} file(s):`);
+    for (const op of fileCreates) {
+      lines.push(`  + ${relative(rootDir, op.path)}`);
+    }
+    lines.push("");
+  }
+  if (fileOverwrites.length > 0) {
+    lines.push(`Overwrite ${fileOverwrites.length} file(s):`);
+    for (const op of fileOverwrites) {
+      lines.push(`  ~ ${relative(rootDir, op.path)}`);
+    }
+    lines.push("");
+  }
+  if (fileSkips.length > 0) {
+    lines.push(`Skip ${fileSkips.length} file(s):`);
+    for (const op of fileSkips) {
+      lines.push(`  - ${relative(rootDir, op.path)} (${op.reason})`);
+    }
+    lines.push("");
+  }
+  if (dirCreates.length > 0) {
+    lines.push(`Create ${dirCreates.length} directory(ies):`);
+    for (const op of dirCreates) {
+      lines.push(`  + ${relative(rootDir, op.path)}/`);
+    }
+    lines.push("");
+  }
+  if (depAdds.length > 0) {
+    lines.push(`Add ${depAdds.length} dependency(ies):`);
+    for (const dep of depAdds) {
+      const suffix = dep.section === "devDependencies" ? " (dev)" : "";
+      lines.push(`  + ${dep.name}@${dep.version}${suffix}`);
+    }
+    lines.push("");
+  }
+  if (blockAdds.length > 0) {
+    lines.push(`Add ${blockAdds.length} block(s):`);
+    for (const block of blockAdds) {
+      lines.push(`  + ${block.name}`);
+    }
+    lines.push("");
+  }
+  if (configInjects.length > 0) {
+    lines.push(`Config injections (${configInjects.length}):`);
+    for (const op of configInjects) {
+      lines.push(`  ~ ${relative(rootDir, op.target)} (${op.description})`);
+    }
+    lines.push("");
+  }
+  if (installOps.length > 0 || gitOps.length > 0) {
+    lines.push("Post-scaffold:");
+    for (const op of installOps) {
+      lines.push(`  $ ${op.command}`);
+    }
+    for (const op of gitOps) {
+      if (op.action === "init") {
+        lines.push("  $ git init");
+      } else if (op.action === "add-all") {
+        lines.push("  $ git add .");
+      } else {
+        lines.push(`  $ git commit -m "${op.message ?? ""}"`);
+      }
+    }
+    lines.push("");
+  }
+  const summary = collector.countByType();
+  lines.push(`Total operations: ${Object.values(summary).reduce((a, b) => a + b, 0)}`);
+  await output(lines, { mode: "human" });
+}
+
+export { renderOperationPlan };

package/dist/shared/outfitter-wcrp7d7m.d.ts

@@ -0,0 +1,5 @@
+import { CreatePresetDefinition, CreatePresetId } from "./outfitter-htx4asgr.js";
+declare const CREATE_PRESETS: Readonly<Record<CreatePresetId, CreatePresetDefinition>>;
+declare const CREATE_PRESET_IDS: CreatePresetId[];
+declare function getCreatePreset(id: string): CreatePresetDefinition | undefined;
+export { CREATE_PRESETS, CREATE_PRESET_IDS, getCreatePreset };

package/dist/shared/outfitter-wkt0a0ra.js

@@ -0,0 +1,67 @@
+// @bun
+import {
+  outputModeSchema,
+  toActionInternalErrorFromUnknown
+} from "./outfitter-7n7vsz95.js";
+import {
+  runDemo
+} from "./outfitter-ksyvwmb5.js";
+import {
+  resolveOutputModeFromContext
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/demo.ts
+import { defineAction, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var demoInputSchema = z.object({
+  section: z.string().optional(),
+  list: z.boolean().optional(),
+  animate: z.boolean().optional(),
+  outputMode: outputModeSchema
+});
+var demoAction = defineAction({
+  id: "demo",
+  description: "Run the CLI demo app",
+  surfaces: ["cli"],
+  input: demoInputSchema,
+  cli: {
+    command: "demo [section]",
+    description: "Run the CLI demo app",
+    options: [
+      {
+        flags: "-l, --list",
+        description: "List available demo sections",
+        defaultValue: false
+      },
+      {
+        flags: "-a, --animate",
+        description: "Run animated demo (spinners only)",
+        defaultValue: false
+      }
+    ],
+    mapInput: (context) => {
+      const outputMode = resolveOutputModeFromContext(context.flags);
+      const section = context.args[0];
+      return {
+        ...section !== undefined ? { section } : {},
+        list: Boolean(context.flags["list"]),
+        animate: Boolean(context.flags["animate"]),
+        outputMode
+      };
+    }
+  },
+  handler: async (input) => {
+    const { outputMode, ...demoInput } = input;
+    try {
+      const result = await runDemo({ ...demoInput, outputMode });
+      if (result.exitCode !== 0) {
+        process.exit(result.exitCode);
+      }
+      return Result.ok(result);
+    } catch (error) {
+      return Result.err(toActionInternalErrorFromUnknown("demo", error, "Failed to run demo"));
+    }
+  }
+});
+
+export { demoAction };

package/dist/shared/outfitter-wrcqq29p.js

@@ -0,0 +1,132 @@
+// @bun
+import {
+  SHARED_DEV_DEPS,
+  SHARED_SCRIPTS
+} from "./outfitter-tqznjgbm.js";
+import {
+  applyResolvedDependencyVersions,
+  resolvePresetDependencyVersions
+} from "./outfitter-x39awx8g.js";
+import {
+  getWorkspacePatterns
+} from "./outfitter-1fy7byz5.js";
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/config.ts
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { Result } from "@outfitter/contracts";
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+function getWorkspaceMemberPackageJsonPaths(rootDir, rootPackageJson) {
+  const patterns = getWorkspacePatterns(rootPackageJson["workspaces"]);
+  const packageJsonPaths = new Set;
+  for (const pattern of patterns) {
+    if (pattern.endsWith("/*")) {
+      const baseDir = join(rootDir, pattern.slice(0, -2));
+      if (!existsSync(baseDir)) {
+        continue;
+      }
+      for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+        const packageJsonPath2 = join(baseDir, entry.name, "package.json");
+        if (existsSync(packageJsonPath2)) {
+          packageJsonPaths.add(packageJsonPath2);
+        }
+      }
+      continue;
+    }
+    const packageJsonPath = join(rootDir, pattern, "package.json");
+    if (existsSync(packageJsonPath)) {
+      packageJsonPaths.add(packageJsonPath);
+    }
+  }
+  return [...packageJsonPaths];
+}
+function rewriteOutfitterDepsToWorkspace(packageJson) {
+  let updated = false;
+  for (const section of DEPENDENCY_SECTIONS) {
+    const deps = packageJson[section];
+    if (!deps || typeof deps !== "object" || Array.isArray(deps)) {
+      continue;
+    }
+    const entries = deps;
+    for (const [name, version] of Object.entries(entries)) {
+      if (typeof version === "string" && name.startsWith("@outfitter/") && version !== "workspace:*") {
+        entries[name] = "workspace:*";
+        updated = true;
+      }
+    }
+  }
+  return updated;
+}
+function injectSharedConfig(targetDir) {
+  const packageJsonPath = join(targetDir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return Result.ok(undefined);
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const dependencyVersions = resolvePresetDependencyVersions();
+    applyResolvedDependencyVersions(parsed, dependencyVersions);
+    const existingDevDeps = parsed["devDependencies"] ?? {};
+    parsed["devDependencies"] = { ...SHARED_DEV_DEPS, ...existingDevDeps };
+    const existingScripts = parsed["scripts"] ?? {};
+    parsed["scripts"] = { ...SHARED_SCRIPTS, ...existingScripts };
+    writeFileSync(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf-8");
+    const workspaceMembers = getWorkspaceMemberPackageJsonPaths(targetDir, parsed);
+    for (const memberPackageJsonPath of workspaceMembers) {
+      const memberContent = readFileSync(memberPackageJsonPath, "utf-8");
+      const memberParsed = JSON.parse(memberContent);
+      const before = JSON.stringify(memberParsed);
+      applyResolvedDependencyVersions(memberParsed, dependencyVersions);
+      if (JSON.stringify(memberParsed) !== before) {
+        writeFileSync(memberPackageJsonPath, `${JSON.stringify(memberParsed, null, 2)}
+`, "utf-8");
+      }
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to inject shared config: ${message}`));
+  }
+}
+function rewriteLocalDependencies(targetDir) {
+  const packageJsonPath = join(targetDir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return Result.ok(undefined);
+  }
+  try {
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (rewriteOutfitterDepsToWorkspace(parsed)) {
+      writeFileSync(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf-8");
+    }
+    const workspaceMembers = getWorkspaceMemberPackageJsonPaths(targetDir, parsed);
+    for (const memberPackageJsonPath of workspaceMembers) {
+      const memberContent = readFileSync(memberPackageJsonPath, "utf-8");
+      const memberParsed = JSON.parse(memberContent);
+      if (rewriteOutfitterDepsToWorkspace(memberParsed)) {
+        writeFileSync(memberPackageJsonPath, `${JSON.stringify(memberParsed, null, 2)}
+`, "utf-8");
+      }
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to update local dependencies: ${message}`));
+  }
+}
+
+export { injectSharedConfig, rewriteLocalDependencies };

package/dist/shared/outfitter-wyg1tpp5.d.ts

@@ -0,0 +1,43 @@
+import { CliOutputMode } from "./outfitter-a79xrm12.js";
+import { InternalError, NotFoundError, Result } from "@outfitter/contracts";
+/** Validated input for the docs.show action handler. */
+interface DocsShowInput {
+	readonly cwd: string;
+	readonly id: string;
+	readonly jq?: string | undefined;
+	readonly outputMode: CliOutputMode;
+}
+/** Output shape for the docs.show action. */
+interface DocsShowOutput {
+	readonly content: string;
+	readonly entry: {
+		readonly id: string;
+		readonly kind: string;
+		readonly outputPath: string;
+		readonly package?: string;
+		readonly sourcePath: string;
+		readonly tags: string[];
+		readonly title: string;
+	};
+}
+/**
+* Show a specific documentation entry and its file content.
+*
+* Generates the docs map for the workspace, looks up the entry by ID,
+* and reads the source file content.
+*
+* @param input - Validated action input
+* @returns Result containing the entry metadata and content, or an error
+*/
+declare function runDocsShow(input: DocsShowInput): Promise<Result<DocsShowOutput, InternalError | NotFoundError>>;
+/**
+* Print docs show results in the appropriate output format.
+*
+* @param result - The docs show output
+* @param options - Output formatting options
+*/
+declare function printDocsShowResults(result: DocsShowOutput, options?: {
+	mode?: CliOutputMode;
+	jq?: string | undefined;
+}): Promise<void>;
+export { DocsShowInput, DocsShowOutput, runDocsShow, printDocsShowResults };

package/dist/shared/outfitter-x0vpb7tj.js

@@ -0,0 +1,126 @@
+// @bun
+import {
+  readMigrationDocsWithMetadata
+} from "./outfitter-fx1m251y.js";
+
+// apps/outfitter/src/commands/upgrade-codemods.ts
+import { existsSync } from "fs";
+import { isAbsolute, join, relative, resolve } from "path";
+import { InternalError, Result } from "@outfitter/contracts";
+var CODEMOD_PATHS = ["plugins/outfitter/shared/codemods"];
+function findCodemodsDir(cwd, binaryDir) {
+  for (const relativePath of CODEMOD_PATHS) {
+    const dir = join(cwd, relativePath);
+    if (existsSync(dir))
+      return dir;
+  }
+  let current = resolve(cwd);
+  const root = resolve("/");
+  while (current !== root) {
+    const parent = resolve(current, "..");
+    if (parent === current)
+      break;
+    current = parent;
+    for (const relativePath of CODEMOD_PATHS) {
+      const dir = join(current, relativePath);
+      if (existsSync(dir))
+        return dir;
+    }
+  }
+  const resolvedBinaryDir = binaryDir ?? resolve(import.meta.dir, "../../../..");
+  for (const relativePath of CODEMOD_PATHS) {
+    const dir = join(resolvedBinaryDir, relativePath);
+    if (existsSync(dir))
+      return dir;
+  }
+  return null;
+}
+function discoverCodemods(migrationsDir, codemodsDir, shortName, fromVersion, toVersion) {
+  const resolvedCodemodsDir = resolve(codemodsDir);
+  const docs = (() => {
+    try {
+      return readMigrationDocsWithMetadata(migrationsDir, shortName, fromVersion, toVersion);
+    } catch {
+      return [];
+    }
+  })();
+  const seen = new Set;
+  const codemods = [];
+  for (const doc of docs) {
+    if (!doc.frontmatter.changes)
+      continue;
+    for (const change of doc.frontmatter.changes) {
+      if (!change.codemod)
+        continue;
+      if (seen.has(change.codemod))
+        continue;
+      seen.add(change.codemod);
+      const absolutePath = resolveCodemodPath(resolvedCodemodsDir, change.codemod);
+      if (absolutePath === null)
+        continue;
+      if (!existsSync(absolutePath))
+        continue;
+      codemods.push({
+        relativePath: change.codemod,
+        absolutePath
+      });
+    }
+  }
+  return codemods;
+}
+function resolveCodemodPath(codemodsDir, relativePath) {
+  if (relativePath.trim().length === 0) {
+    return null;
+  }
+  if (isAbsolute(relativePath)) {
+    return null;
+  }
+  const resolvedPath = resolve(codemodsDir, relativePath);
+  const relPath = relative(codemodsDir, resolvedPath);
+  if (relPath === "" || relPath.startsWith("..") || isAbsolute(relPath)) {
+    return null;
+  }
+  return resolvedPath;
+}
+async function runCodemod(codemodPath, targetDir, dryRun) {
+  let mod;
+  try {
+    mod = await import(codemodPath);
+  } catch (error) {
+    return Result.err(InternalError.create("Failed to load codemod", {
+      codemodPath,
+      error: error instanceof Error ? error.message : String(error)
+    }));
+  }
+  if (typeof mod["transform"] !== "function") {
+    return Result.err(InternalError.create(`Codemod has no transform export: ${codemodPath}`, {
+      codemodPath
+    }));
+  }
+  const transform = mod["transform"];
+  try {
+    const result = await transform({ targetDir, dryRun });
+    if (!isCodemodResult(result)) {
+      return Result.err(InternalError.create("Codemod returned invalid result shape", {
+        codemodPath
+      }));
+    }
+    return Result.ok(result);
+  } catch (error) {
+    return Result.err(InternalError.create("Codemod execution failed", {
+      codemodPath,
+      error: error instanceof Error ? error.message : String(error)
+    }));
+  }
+}
+function isCodemodResult(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const candidate = value;
+  return isStringArray(candidate["changedFiles"]) && isStringArray(candidate["skippedFiles"]) && isStringArray(candidate["errors"]);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+export { findCodemodsDir, discoverCodemods, runCodemod };

package/dist/shared/outfitter-x39awx8g.js

@@ -0,0 +1,146 @@
+// @bun
+// apps/outfitter/src/engine/dependency-versions.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { getResolvedVersions } from "@outfitter/presets";
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+var cachedResolvedVersions;
+function clearResolvedVersionsCache() {
+  cachedResolvedVersions = undefined;
+}
+function readJsonFile(path) {
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeRange(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed === "workspace:*") {
+    return;
+  }
+  if (/^\d+\.\d+\.\d+(?:[-+].+)?$/.test(trimmed)) {
+    return `^${trimmed}`;
+  }
+  return trimmed;
+}
+function findOutfitterPackageRoot() {
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0;i < 10; i += 1) {
+    const packageJsonPath = join(currentDir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const parsed = readJsonFile(packageJsonPath);
+        if (isRecord(parsed) && typeof parsed["name"] === "string" && parsed["name"] === "outfitter") {
+          return currentDir;
+        }
+      } catch {}
+    }
+    currentDir = dirname(currentDir);
+  }
+  throw new Error(`Unable to find outfitter package root (walked 10 levels up from ${dirname(fileURLToPath(import.meta.url))}). ` + "Ensure this module is running from within the outfitter package tree.");
+}
+function collectOutfitterDepsFromPackageJson(packageJson) {
+  const collected = {};
+  for (const section of DEPENDENCY_SECTIONS) {
+    const sectionValue = packageJson[section];
+    if (!isRecord(sectionValue)) {
+      continue;
+    }
+    for (const [name, value] of Object.entries(sectionValue)) {
+      if (typeof value !== "string" || !name.startsWith("@outfitter/")) {
+        continue;
+      }
+      const normalized = normalizeRange(value);
+      if (normalized) {
+        collected[name] = normalized;
+      }
+    }
+  }
+  return collected;
+}
+function collectWorkspacePackageRanges(packageRoot) {
+  const repoRoot = resolve(packageRoot, "..", "..");
+  const expectedPackageRoot = join(repoRoot, "apps", "outfitter");
+  if (resolve(expectedPackageRoot) !== resolve(packageRoot)) {
+    return {};
+  }
+  const packagesDir = join(repoRoot, "packages");
+  if (!existsSync(packagesDir)) {
+    return {};
+  }
+  const collected = {};
+  for (const entry of readdirSync(packagesDir)) {
+    const packageJsonPath = join(packagesDir, entry, "package.json");
+    if (!existsSync(packageJsonPath)) {
+      continue;
+    }
+    try {
+      const parsed = readJsonFile(packageJsonPath);
+      if (!isRecord(parsed)) {
+        continue;
+      }
+      const name = parsed["name"];
+      const version = parsed["version"];
+      if (typeof name === "string" && typeof version === "string" && name.startsWith("@outfitter/")) {
+        const normalized = normalizeRange(version);
+        if (normalized) {
+          collected[name] = normalized;
+        }
+      }
+    } catch {}
+  }
+  return collected;
+}
+function resolvePresetDependencyVersions() {
+  if (cachedResolvedVersions) {
+    return cachedResolvedVersions;
+  }
+  const { all: presetsVersions } = getResolvedVersions();
+  const packageRoot = findOutfitterPackageRoot();
+  const packageJsonPath = join(packageRoot, "package.json");
+  const raw = existsSync(packageJsonPath) ? readJsonFile(packageJsonPath) : undefined;
+  const fromOutfitterPackage = raw !== undefined && isRecord(raw) ? collectOutfitterDepsFromPackageJson(raw) : {};
+  const fromWorkspacePackages = collectWorkspacePackageRanges(packageRoot);
+  const internal = {
+    ...fromOutfitterPackage,
+    ...fromWorkspacePackages
+  };
+  cachedResolvedVersions = {
+    internal,
+    external: { ...presetsVersions }
+  };
+  return cachedResolvedVersions;
+}
+function applyResolvedDependencyVersions(parsedPackageJson, versions) {
+  for (const section of DEPENDENCY_SECTIONS) {
+    const sectionValue = parsedPackageJson[section];
+    if (!isRecord(sectionValue)) {
+      continue;
+    }
+    for (const [name, value] of Object.entries(sectionValue)) {
+      if (typeof value !== "string") {
+        continue;
+      }
+      if (name.startsWith("@outfitter/")) {
+        const resolvedInternal = versions.internal[name];
+        if (resolvedInternal) {
+          sectionValue[name] = resolvedInternal;
+        }
+        continue;
+      }
+      const resolvedExternal = versions.external[name];
+      if (resolvedExternal) {
+        sectionValue[name] = resolvedExternal;
+      }
+    }
+  }
+}
+
+export { clearResolvedVersionsCache, resolvePresetDependencyVersions, applyResolvedDependencyVersions };