outfitter 0.3.4 → 0.4.0

package/dist/shared/outfitter-fgrqt6aq.js

@@ -0,0 +1,179 @@
+// @bun
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-sxf8jjjn.js";
+
+// apps/outfitter/src/commands/check-action-registry.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, relative, resolve } from "path";
+import { Result } from "@outfitter/contracts";
+var COMMANDS_RELATIVE_DIR = "apps/outfitter/src/commands";
+var ACTIONS_RELATIVE_DIR = "apps/outfitter/src/actions";
+var REGISTRY_RELATIVE_PATH = "apps/outfitter/src/actions.ts";
+var LOCAL_REGISTRY_RELATIVE_PATH = "src/actions.ts";
+var LOCAL_COMMANDS_RELATIVE_DIR = "src/commands";
+
+class CheckActionRegistryError extends Error {
+  _tag = "CheckActionRegistryError";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CheckActionRegistryError";
+  }
+}
+function extractCommandImports(content) {
+  const imports = new Set;
+  const importPattern = /from\s+["']\.\.\/commands\/([^"']+)\.(js|ts)["']/g;
+  let match;
+  while ((match = importPattern.exec(content)) !== null) {
+    const basename = match[1];
+    if (basename) {
+      imports.add(`${basename}.ts`);
+    }
+  }
+  return imports;
+}
+function parseNamedImportSymbols(namedImports) {
+  const withoutComments = namedImports.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+  return withoutComments.split(",").map((raw) => raw.trim()).filter((raw) => raw.length > 0).map((raw) => {
+    const withoutType = raw.replace(/^type\s+/, "").trim();
+    if (!withoutType) {
+      return "";
+    }
+    const aliased = withoutType.match(/^([A-Za-z_$][A-Za-z0-9_$]*)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)$/);
+    return aliased?.[2] ?? withoutType;
+  }).filter((symbol) => symbol.length > 0);
+}
+function extractRegisteredActionFiles(registryContent) {
+  const importMap = new Map;
+  const importPattern = /import\s+\{([^}]+)\}\s+from\s+["']\.\/actions\/([^"']+)\.(js|ts)["']/g;
+  let match;
+  while ((match = importPattern.exec(registryContent)) !== null) {
+    const symbols = parseNamedImportSymbols(match[1]);
+    const file = `${match[2]}.ts`;
+    for (const sym of symbols) {
+      importMap.set(sym, file);
+    }
+  }
+  const addPattern = /\.add\((\w+)\)/g;
+  const registeredFiles = new Set;
+  while ((match = addPattern.exec(registryContent)) !== null) {
+    const symbol = match[1];
+    const file = importMap.get(symbol);
+    if (file) {
+      registeredFiles.add(file);
+    }
+  }
+  return registeredFiles;
+}
+function listTsFiles(dir, rootDir = dir) {
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith("__")) {
+      continue;
+    }
+    const entryPath = resolve(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listTsFiles(entryPath, rootDir));
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (entry.name.endsWith(".ts") && !entry.name.endsWith(".test.ts")) {
+      files.push(relative(rootDir, entryPath).replaceAll("\\", "/"));
+    }
+  }
+  return files.toSorted();
+}
+function resolveWorkspaceRoot(cwd) {
+  const resolved = resolve(cwd);
+  if (existsSync(resolve(resolved, REGISTRY_RELATIVE_PATH))) {
+    return resolved;
+  }
+  if (existsSync(resolve(resolved, LOCAL_REGISTRY_RELATIVE_PATH)) && existsSync(resolve(resolved, LOCAL_COMMANDS_RELATIVE_DIR))) {
+    const parentWorkspace = resolve(resolved, "../..");
+    if (existsSync(resolve(parentWorkspace, REGISTRY_RELATIVE_PATH))) {
+      return parentWorkspace;
+    }
+  }
+  let current = resolved;
+  while (true) {
+    if (existsSync(resolve(current, REGISTRY_RELATIVE_PATH))) {
+      return current;
+    }
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      return resolved;
+    }
+    current = parent;
+  }
+}
+async function runCheckActionRegistry(options) {
+  try {
+    const workspaceRoot = resolveWorkspaceRoot(options.cwd);
+    const commandsDir = resolve(workspaceRoot, COMMANDS_RELATIVE_DIR);
+    const actionsDir = resolve(workspaceRoot, ACTIONS_RELATIVE_DIR);
+    const registryPath = resolve(workspaceRoot, REGISTRY_RELATIVE_PATH);
+    const registryContent = readFileSync(registryPath, "utf-8");
+    const registeredActionFiles = extractRegisteredActionFiles(registryContent);
+    const referencedCommands = new Set;
+    for (const actionFile of registeredActionFiles) {
+      const filePath = resolve(actionsDir, actionFile);
+      const content = readFileSync(filePath, "utf-8");
+      const imports = extractCommandImports(content);
+      for (const imp of imports) {
+        referencedCommands.add(imp);
+      }
+    }
+    const commandFiles = listTsFiles(commandsDir);
+    const registered = [];
+    const unregistered = [];
+    for (const file of commandFiles) {
+      const relativePath = join(COMMANDS_RELATIVE_DIR, file);
+      if (referencedCommands.has(file)) {
+        registered.push(relativePath);
+      } else {
+        unregistered.push(relativePath);
+      }
+    }
+    return Result.ok({
+      actionsDir,
+      commandsDir,
+      ok: unregistered.length === 0,
+      registered,
+      registeredCount: registered.length,
+      totalCommands: commandFiles.length,
+      unregistered,
+      unregisteredCount: unregistered.length
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to scan action registry";
+    return Result.err(new CheckActionRegistryError(message, { cause: error }));
+  }
+}
+async function printCheckActionRegistryResult(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    const serialized = structuredMode === "json" ? JSON.stringify(result, null, 2) : JSON.stringify(result);
+    process.stdout.write(`${serialized}
+`);
+    return;
+  }
+  process.stdout.write(`[action-registry] scanned ${result.totalCommands} command files in ${result.commandsDir}
+`);
+  process.stdout.write(`[action-registry] ${result.registeredCount} registered, ${result.unregisteredCount} unregistered
+`);
+  if (result.unregistered.length === 0) {
+    process.stdout.write(`[action-registry] all command files are referenced by action definitions
+`);
+    return;
+  }
+  process.stderr.write(`[action-registry] unregistered command files:
+`);
+  for (const file of result.unregistered) {
+    process.stderr.write(`  - ${file}
+`);
+  }
+}
+
+export { CheckActionRegistryError, runCheckActionRegistry, printCheckActionRegistryResult };

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

@@ -0,0 +1,14 @@
+import { OutputMode } from "@outfitter/cli/types";
+type StructuredOutputMode = Extract<OutputMode, "json" | "jsonl">;
+/** Output modes resolvable from CLI flags and env vars. */
+type CliOutputMode = "human" | "json" | "jsonl";
+/**
+* Narrow an output mode to its structured subset (`"json"` | `"jsonl"`).
+*
+* Returns `undefined` when the mode is not machine-readable (e.g., `"human"`,
+* `"tree"`, `"table"`) or when `mode` is `undefined`.
+* This is a pure type-narrowing helper — it does NOT check env vars.
+* Use `resolveOutputMode()` from `@outfitter/cli/query` for full resolution.
+*/
+declare function resolveStructuredOutputMode(mode?: OutputMode): StructuredOutputMode | undefined;
+export { StructuredOutputMode, CliOutputMode, resolveStructuredOutputMode };

package/dist/shared/{outfitter-c7sbs7es.js → outfitter-g6r9avgz.js}

@@ -7,7 +7,7 @@ import {
 } from "./outfitter-svts4wk2.js";
 import {
   resolveStructuredOutputMode
-} from "./outfitter-7r12fj7f.js";
+} from "./outfitter-sxf8jjjn.js";
 
 // apps/outfitter/src/commands/docs-show.ts
 import { readFile } from "fs/promises";
@@ -63,7 +63,7 @@ async function printDocsShowResults(result, options) {
       });
       process.stdout.write(filtered);
     } else {
-      await output(result, { mode: structuredMode });
+      await output(result, structuredMode);
     }
     return;
   }
@@ -86,7 +86,7 @@ async function printDocsShowResults(result, options) {
   lines.push("-".repeat(60));
   lines.push("");
   lines.push(result.content);
-  await output(lines, { mode: "human" });
+  await output(lines, "human");
 }
 
 export { runDocsShow, printDocsShowResults };

package/dist/shared/{outfitter-ssynegbs.js → outfitter-ga59fa45.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   resolveStructuredOutputMode
-} from "./outfitter-7r12fj7f.js";
+} from "./outfitter-sxf8jjjn.js";
 
 // apps/outfitter/src/commands/check-publish-guardrails.ts
 import { existsSync, readdirSync, readFileSync } from "fs";

package/dist/shared/{outfitter-tavatb5p.js → outfitter-gna739c3.js}

@@ -3,23 +3,63 @@ import {
   deriveBinName,
   deriveProjectName,
   executePlan,
+  getPresetsBaseDir,
   isPathWithin,
   resolveAuthor,
   resolveYear,
   scaffoldWorkspaceRoot,
   validateProjectDirectoryName
-} from "./outfitter-q1g58t85.js";
-import {
-  runPostScaffold
-} from "./outfitter-4s9meh3j.js";
+} from "./outfitter-gvpwpqnc.js";
 import {
   OperationCollector
 } from "./outfitter-1h7k8xxt.js";
+import {
+  runPostScaffold
+} from "./outfitter-4w9sc6bw.js";
 
 // apps/outfitter/src/commands/init-execution.ts
-import { existsSync } from "fs";
+import { existsSync, readdirSync } from "fs";
 import { basename, join, resolve } from "path";
 import { Result } from "@outfitter/contracts";
+function discoverPresetExamples() {
+  const examplesRoot = join(getPresetsBaseDir(), "_examples");
+  if (!existsSync(examplesRoot)) {
+    return new Map;
+  }
+  const examplesByPreset = new Map;
+  for (const entry of readdirSync(examplesRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const separatorIndex = entry.name.indexOf("-");
+    if (separatorIndex <= 0 || separatorIndex >= entry.name.length - 1) {
+      continue;
+    }
+    const preset = entry.name.slice(0, separatorIndex);
+    const example = entry.name.slice(separatorIndex + 1);
+    const existing = examplesByPreset.get(preset) ?? [];
+    existing.push(example);
+    examplesByPreset.set(preset, existing);
+  }
+  return new Map([...examplesByPreset.entries()].map(([preset, examples]) => [
+    preset,
+    [...new Set(examples)].toSorted()
+  ]));
+}
+function getPresetExamples() {
+  return discoverPresetExamples();
+}
+function validateExample(preset, example) {
+  const presetExamples = getPresetExamples();
+  const available = presetExamples.get(preset);
+  if (!available || available.length === 0) {
+    return Result.err(`Preset '${preset}' has no available examples. ` + `Only these presets support --example: ${[...presetExamples.keys()].join(", ")}`);
+  }
+  if (!available.includes(example)) {
+    return Result.err(`Unknown example '${example}' for preset '${preset}'. ` + `Available examples: ${available.join(", ")}`);
+  }
+  return Result.ok(`_examples/${preset}-${example}`);
+}
 function toExecutionErrorMessage(error) {
   if (error instanceof Error) {
     return error.message;
@@ -47,6 +87,13 @@ function buildInitPlan(target, input, projectDir, resolvedBinName) {
         includeTooling: input.includeTooling,
         overlayBaseTemplate: true
       },
+      ...input.exampleOverlayDir ? [
+        {
+          type: "copy-example-overlay",
+          preset: input.exampleOverlayDir,
+          targetDir: projectDir
+        }
+      ] : [],
       { type: "inject-shared-config" },
       ...input.local ? [{ type: "rewrite-local-dependencies", mode: "workspace" }] : [],
       ...blocks.length > 0 ? [{ type: "add-blocks", blocks }] : []
@@ -54,38 +101,46 @@ function buildInitPlan(target, input, projectDir, resolvedBinName) {
   };
 }
 async function executeInitPipeline(input, target, options) {
-  const projectName = deriveProjectName(input.packageName);
-  if (input.structure === "workspace") {
+  let resolvedInput = input;
+  if (input.example) {
+    const exampleResult = validateExample(input.preset, input.example);
+    if (exampleResult.isErr()) {
+      return Result.err(exampleResult.error);
+    }
+    resolvedInput = { ...input, exampleOverlayDir: exampleResult.value };
+  }
+  const projectName = deriveProjectName(resolvedInput.packageName);
+  if (resolvedInput.structure === "workspace") {
     const invalidProjectName = validateProjectDirectoryName(projectName);
     if (invalidProjectName) {
       return Result.err(`Invalid workspace project name '${projectName}': ${invalidProjectName}`);
     }
   }
   const collector = options.dryRun ? new OperationCollector : undefined;
-  const projectBaseDir = resolve(input.rootDir, target.placement);
+  const projectBaseDir = resolve(resolvedInput.rootDir, target.placement);
   const resolvedProjectDir = resolve(projectBaseDir, projectName);
-  if (input.structure === "workspace" && !isPathWithin(projectBaseDir, resolvedProjectDir)) {
+  if (resolvedInput.structure === "workspace" && !isPathWithin(projectBaseDir, resolvedProjectDir)) {
     return Result.err(`Invalid workspace project name '${projectName}': path escapes '${projectBaseDir}'`);
   }
-  const projectDir = input.structure === "workspace" ? resolvedProjectDir : input.rootDir;
-  if (input.structure === "single") {
-    if (existsSync(join(input.rootDir, "package.json")) && !options.force) {
-      return Result.err(`Directory '${input.rootDir}' already has a package.json. Use --force to overwrite, or use 'outfitter add' for existing projects.`);
+  const projectDir = resolvedInput.structure === "workspace" ? resolvedProjectDir : resolvedInput.rootDir;
+  if (resolvedInput.structure === "single") {
+    if (existsSync(join(resolvedInput.rootDir, "package.json")) && !options.force) {
+      return Result.err(`Directory '${resolvedInput.rootDir}' already has a package.json. Use --force to overwrite, or use 'outfitter add' for existing projects.`);
     }
   } else {
-    const workspaceName = input.workspaceName ?? basename(input.rootDir);
-    const workspacePackageJsonPath = join(input.rootDir, "package.json");
+    const workspaceName = resolvedInput.workspaceName ?? basename(resolvedInput.rootDir);
+    const workspacePackageJsonPath = join(resolvedInput.rootDir, "package.json");
     if (options.dryRun) {
       if (existsSync(workspacePackageJsonPath) && !options.force) {
-        return Result.err(`Directory '${input.rootDir}' already has a package.json. Use --force to overwrite.`);
+        return Result.err(`Directory '${resolvedInput.rootDir}' already has a package.json. Use --force to overwrite.`);
       }
       collector?.add({
         type: "dir-create",
-        path: join(input.rootDir, "apps")
+        path: join(resolvedInput.rootDir, "apps")
       });
       collector?.add({
         type: "dir-create",
-        path: join(input.rootDir, "packages")
+        path: join(resolvedInput.rootDir, "packages")
       });
       collector?.add(existsSync(workspacePackageJsonPath) ? {
         type: "file-overwrite",
@@ -96,7 +151,7 @@ async function executeInitPipeline(input, target, options) {
         path: workspacePackageJsonPath,
         source: "generated"
       });
-      const readmePath = join(input.rootDir, "README.md");
+      const readmePath = join(resolvedInput.rootDir, "README.md");
       if (options.force || !existsSync(readmePath)) {
         collector?.add(existsSync(readmePath) ? {
           type: "file-overwrite",
@@ -108,7 +163,7 @@ async function executeInitPipeline(input, target, options) {
           source: "generated"
         });
       }
-      const gitignorePath = join(input.rootDir, ".gitignore");
+      const gitignorePath = join(resolvedInput.rootDir, ".gitignore");
       if (options.force || !existsSync(gitignorePath)) {
         collector?.add(existsSync(gitignorePath) ? {
           type: "file-overwrite",
@@ -121,14 +176,14 @@ async function executeInitPipeline(input, target, options) {
         });
       }
     } else {
-      const workspaceResult = scaffoldWorkspaceRoot(input.rootDir, workspaceName, options.force);
+      const workspaceResult = scaffoldWorkspaceRoot(resolvedInput.rootDir, workspaceName, options.force);
       if (workspaceResult.isErr()) {
         return Result.err(workspaceResult.error.message);
       }
     }
   }
-  const resolvedBinName = input.binName ?? deriveBinName(deriveProjectName(input.packageName));
-  const plan = buildInitPlan(target, input, projectDir, resolvedBinName);
+  const resolvedBinName = resolvedInput.binName ?? deriveBinName(deriveProjectName(resolvedInput.packageName));
+  const plan = buildInitPlan(target, resolvedInput, projectDir, resolvedBinName);
   const executeResult = await executePlan(plan, {
     force: options.force,
     ...collector ? { collector } : {}
@@ -137,11 +192,11 @@ async function executeInitPipeline(input, target, options) {
     return Result.err(toExecutionErrorMessage(executeResult.error));
   }
   const postScaffoldResult = await runPostScaffold({
-    rootDir: input.rootDir,
+    rootDir: resolvedInput.rootDir,
     projectDir,
     origin: "init",
-    target: input.preset,
-    structure: input.structure,
+    target: resolvedInput.preset,
+    structure: resolvedInput.structure,
     skipInstall: options.skipInstall,
     skipGit: options.skipGit,
     skipCommit: options.skipCommit,
@@ -152,15 +207,15 @@ async function executeInitPipeline(input, target, options) {
     return Result.err("Post-scaffold step failed");
   }
   return Result.ok({
-    structure: input.structure,
-    rootDir: input.rootDir,
+    structure: resolvedInput.structure,
+    rootDir: resolvedInput.rootDir,
     projectDir,
-    preset: input.preset,
-    packageName: input.packageName,
+    preset: resolvedInput.preset,
+    packageName: resolvedInput.packageName,
     blocksAdded: executeResult.value.blocksAdded,
     postScaffold: postScaffoldResult.value,
     ...collector ? { dryRunPlan: collector.toJSON() } : {}
   });
 }
 
-export { executeInitPipeline };
+export { validateExample, executeInitPipeline };

package/dist/shared/{outfitter-nxvjxrmw.d.ts → outfitter-grt5ngqq.d.ts}

@@ -1,4 +1,4 @@
-import { CliOutputMode } from "./outfitter-a79xrm12.js";
+import { CliOutputMode } from "./outfitter-fhahf9f3.js";
 import { InternalError, Result } from "@outfitter/contracts";
 /** Validated input for the docs.search action handler. */
 interface DocsSearchInput {

package/dist/shared/{outfitter-58rn1sj1.d.ts → outfitter-gsjbcta2.d.ts}

@@ -1,7 +1,7 @@
 /**
 * Unique identifier for a scaffold target.
 */
-type TargetId = "minimal" | "cli" | "mcp" | "daemon" | "library" | "full-stack" | "api" | "worker" | "web";
+type TargetId = "minimal" | "basic" | "cli" | "mcp" | "daemon" | "library" | "full-stack" | "api" | "worker" | "web";
 /**
 * Whether the target produces a runnable application or a library package.
 */

package/dist/shared/{outfitter-q1g58t85.js → outfitter-gvpwpqnc.js}

@@ -3,6 +3,5 @@ export { injectSharedConfig, rewriteLocalDependencies } from "./config.js";
 export { executePlan } from "./executor.js";
 export { deriveBinName, deriveProjectName, isPathWithin, resolveAuthor, resolvePackageName, resolveYear, sanitizePackageName, validatePackageName, validateProjectDirectoryName } from "./names.js";
 export { copyPresetFiles, getOutputFilename, getPresetsBaseDir, isBinaryFile, replacePlaceholders } from "./preset.js";
-export { copyTemplateFiles, getTemplatesDir } from "./template.js";
 export { ScaffoldError } from "./types.js";
 export { buildWorkspaceRootPackageJson, detectWorkspaceRoot, scaffoldWorkspaceRoot } from "./workspace.js";

package/dist/shared/{outfitter-x39awx8g.js → outfitter-hr4cvmjy.js}

@@ -3,7 +3,10 @@
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
+import { extractMessage, InternalError, Result } from "@outfitter/contracts";
 import { getResolvedVersions } from "@outfitter/presets";
+import { isPlainObject } from "@outfitter/types";
+var OUTFITTER_PACKAGE_NAME = "outfitter";
 var DEPENDENCY_SECTIONS = [
   "dependencies",
   "devDependencies",
@@ -17,8 +20,13 @@ function clearResolvedVersionsCache() {
 function readJsonFile(path) {
   return JSON.parse(readFileSync(path, "utf-8"));
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function normalizeVersionRange(version) {
+  const trimmed = version.trim();
+  const semverMatch = trimmed.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+  if (semverMatch) {
+    return semverMatch[0];
+  }
+  return trimmed.replace(/^[\^~>=<]+/, "");
 }
 function normalizeRange(value) {
   const trimmed = value.trim();
@@ -37,20 +45,20 @@ function findOutfitterPackageRoot() {
     if (existsSync(packageJsonPath)) {
       try {
         const parsed = readJsonFile(packageJsonPath);
-        if (isRecord(parsed) && typeof parsed["name"] === "string" && parsed["name"] === "outfitter") {
-          return currentDir;
+        if (isPlainObject(parsed) && typeof parsed["name"] === "string" && parsed["name"] === OUTFITTER_PACKAGE_NAME) {
+          return Result.ok(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.");
+  return Result.err(InternalError.create(`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)) {
+    if (!isPlainObject(sectionValue)) {
       continue;
     }
     for (const [name, value] of Object.entries(sectionValue)) {
@@ -83,7 +91,7 @@ function collectWorkspacePackageRanges(packageRoot) {
     }
     try {
       const parsed = readJsonFile(packageJsonPath);
-      if (!isRecord(parsed)) {
+      if (!isPlainObject(parsed)) {
         continue;
       }
       const name = parsed["name"];
@@ -100,28 +108,37 @@ function collectWorkspacePackageRanges(packageRoot) {
 }
 function resolvePresetDependencyVersions() {
   if (cachedResolvedVersions) {
-    return cachedResolvedVersions;
+    return Result.ok(cachedResolvedVersions);
+  }
+  try {
+    const { all: presetsVersions } = getResolvedVersions();
+    const packageRootResult = findOutfitterPackageRoot();
+    if (packageRootResult.isErr()) {
+      return packageRootResult;
+    }
+    const packageRoot = packageRootResult.value;
+    const packageJsonPath = join(packageRoot, "package.json");
+    const raw = existsSync(packageJsonPath) ? readJsonFile(packageJsonPath) : undefined;
+    const fromOutfitterPackage = raw !== undefined && isPlainObject(raw) ? collectOutfitterDepsFromPackageJson(raw) : {};
+    const fromWorkspacePackages = collectWorkspacePackageRanges(packageRoot);
+    const internal = {
+      ...fromOutfitterPackage,
+      ...fromWorkspacePackages
+    };
+    cachedResolvedVersions = {
+      internal,
+      external: { ...presetsVersions }
+    };
+    return Result.ok(cachedResolvedVersions);
+  } catch (error) {
+    return Result.err(InternalError.create(`Failed to resolve preset dependency versions: ${extractMessage(error)}`));
   }
-  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) {
+  const unresolved = new Set;
   for (const section of DEPENDENCY_SECTIONS) {
     const sectionValue = parsedPackageJson[section];
-    if (!isRecord(sectionValue)) {
+    if (!isPlainObject(sectionValue)) {
       continue;
     }
     for (const [name, value] of Object.entries(sectionValue)) {
@@ -138,9 +155,14 @@ function applyResolvedDependencyVersions(parsedPackageJson, versions) {
       const resolvedExternal = versions.external[name];
       if (resolvedExternal) {
         sectionValue[name] = resolvedExternal;
+        continue;
+      }
+      if (value === "catalog:") {
+        unresolved.add(name);
       }
     }
   }
+  return [...unresolved].toSorted();
 }
 
-export { clearResolvedVersionsCache, resolvePresetDependencyVersions, applyResolvedDependencyVersions };
+export { DEPENDENCY_SECTIONS, clearResolvedVersionsCache, normalizeVersionRange, resolvePresetDependencyVersions, applyResolvedDependencyVersions };