outfitter 0.3.2 → 0.3.3

package/dist/shared/outfitter-ssrtakh3.js

@@ -0,0 +1,342 @@
+// @bun
+import {
+  readManifest
+} from "./outfitter-ypcvwg1s.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { output } from "@outfitter/cli";
+import { Result } from "@outfitter/contracts";
+import { createTheme } from "@outfitter/tui/render";
+class CheckError extends Error {
+  _tag = "CheckError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckError";
+  }
+}
+function getRegistryPath() {
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0;i < 10; i++) {
+    const registryPath = join(currentDir, "node_modules/@outfitter/tooling/registry/registry.json");
+    if (existsSync(registryPath)) {
+      return registryPath;
+    }
+    const monoRepoPath = join(currentDir, "packages/tooling/registry/registry.json");
+    if (existsSync(monoRepoPath)) {
+      return monoRepoPath;
+    }
+    currentDir = dirname(currentDir);
+  }
+  throw new CheckError("Could not find registry.json. Ensure @outfitter/tooling is installed.");
+}
+function readToolingVersion(registryPath) {
+  try {
+    const toolingRoot = dirname(dirname(registryPath));
+    const pkgPath = join(toolingRoot, "package.json");
+    const content = readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function isRegistryLike(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return !!record["blocks"] && typeof record["blocks"] === "object";
+}
+function loadRegistry() {
+  try {
+    const registryPath = getRegistryPath();
+    const content = readFileSync(registryPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!isRegistryLike(parsed)) {
+      return Result.err(new CheckError("Failed to load registry: invalid registry shape"));
+    }
+    const registry = parsed;
+    const toolingVersion = readToolingVersion(registryPath);
+    return Result.ok({ registry, toolingVersion });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new CheckError(`Failed to load registry: ${message}`));
+  }
+}
+function resolveBlockFiles(registry, blockName, visited = new Set) {
+  if (visited.has(blockName)) {
+    return [];
+  }
+  visited.add(blockName);
+  const block = registry.blocks[blockName];
+  if (!block) {
+    return [];
+  }
+  const files = [];
+  if (block.extends && block.extends.length > 0) {
+    for (const extendedName of block.extends) {
+      files.push(...resolveBlockFiles(registry, extendedName, visited));
+    }
+  }
+  if (block.files) {
+    files.push(...block.files);
+  }
+  return files;
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return a === b;
+  if (typeof a !== typeof b)
+    return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEqual(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    for (const key of aKeys) {
+      if (!Object.hasOwn(bObj, key))
+        return false;
+      if (!deepEqual(aObj[key], bObj[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function compareFileContent(filePath, localContent, registryContent) {
+  if (filePath.endsWith(".json") || filePath.endsWith(".jsonc")) {
+    try {
+      const cleanLocal = filePath.endsWith(".jsonc") ? stripJsoncComments(localContent) : localContent;
+      const cleanRegistry = filePath.endsWith(".jsonc") ? stripJsoncComments(registryContent) : registryContent;
+      const localParsed = JSON.parse(cleanLocal);
+      const registryParsed = JSON.parse(cleanRegistry);
+      return deepEqual(localParsed, registryParsed);
+    } catch {}
+  }
+  return localContent === registryContent;
+}
+function stripJsoncComments(content) {
+  return content.split(`
+`).map((line) => {
+    let inString = false;
+    for (let i = 0;i < line.length; i++) {
+      const char = line[i];
+      if (char === '"' && (i === 0 || line[i - 1] !== "\\")) {
+        inString = !inString;
+      }
+      if (!inString && char === "/" && line[i + 1] === "/") {
+        return line.slice(0, i).trimEnd();
+      }
+    }
+    return line;
+  }).filter((line) => line.trim() !== "").join(`
+`);
+}
+var BLOCK_FILE_MARKERS = {
+  linter: [".oxlintrc.json", ".oxfmtrc.jsonc"],
+  lefthook: [".lefthook.yml"],
+  claude: [".claude/settings.json"],
+  markdownlint: [".markdownlint-cli2.jsonc"],
+  bootstrap: ["scripts/bootstrap.sh"]
+};
+function detectBlocksByFilePresence(cwd) {
+  const detected = [];
+  for (const [blockName, files] of Object.entries(BLOCK_FILE_MARKERS)) {
+    const hasAnyFile = files.some((filePath) => existsSync(join(cwd, filePath)));
+    if (hasAnyFile) {
+      detected.push(blockName);
+    }
+  }
+  return detected;
+}
+function checkBlock(cwd, blockName, registry, toolingVersion, installedFrom, verbose) {
+  const versionFields = {
+    ...installedFrom !== undefined ? { installedFrom } : {},
+    currentToolingVersion: toolingVersion
+  };
+  const files = resolveBlockFiles(registry, blockName);
+  if (files.length === 0 && !registry.blocks[blockName]) {
+    return {
+      name: blockName,
+      status: "missing",
+      ...versionFields
+    };
+  }
+  if (files.length === 0) {
+    return {
+      name: blockName,
+      status: "current",
+      ...versionFields
+    };
+  }
+  let allMissing = true;
+  let anyDrifted = false;
+  const driftedFiles = [];
+  for (const file of files) {
+    const localPath = join(cwd, file.path);
+    if (!existsSync(localPath)) {
+      anyDrifted = true;
+      if (verbose) {
+        driftedFiles.push({ path: file.path, reason: "missing" });
+      }
+      continue;
+    }
+    allMissing = false;
+    const localContent = readFileSync(localPath, "utf-8");
+    if (!compareFileContent(file.path, localContent, file.content)) {
+      anyDrifted = true;
+      if (verbose) {
+        driftedFiles.push({ path: file.path, reason: "modified" });
+      }
+    }
+  }
+  if (allMissing) {
+    return {
+      name: blockName,
+      status: "missing",
+      ...versionFields,
+      ...verbose && driftedFiles.length > 0 ? { driftedFiles } : {}
+    };
+  }
+  if (anyDrifted) {
+    return {
+      name: blockName,
+      status: "drifted",
+      ...versionFields,
+      ...verbose && driftedFiles.length > 0 ? { driftedFiles } : {}
+    };
+  }
+  return {
+    name: blockName,
+    status: "current",
+    ...versionFields
+  };
+}
+async function runCheck(options) {
+  const {
+    cwd: rawCwd,
+    verbose = false,
+    block: blockFilter,
+    manifestOnly = false
+  } = options;
+  const cwd = resolve(rawCwd);
+  const registryResult = loadRegistry();
+  if (registryResult.isErr()) {
+    return registryResult;
+  }
+  const { registry, toolingVersion } = registryResult.value;
+  const manifestResult = await readManifest(cwd);
+  if (manifestResult.isErr()) {
+    return Result.err(new CheckError(`Failed to read manifest: ${manifestResult.error.message}`));
+  }
+  const manifest = manifestResult.value;
+  let blocksToCheck;
+  if (manifest) {
+    blocksToCheck = Object.entries(manifest.blocks).map(([name, entry]) => ({
+      name,
+      installedFrom: entry.installedFrom
+    }));
+  } else if (manifestOnly) {
+    blocksToCheck = [];
+  } else {
+    const detected = detectBlocksByFilePresence(cwd);
+    blocksToCheck = detected.map((name) => ({
+      name,
+      installedFrom: undefined
+    }));
+  }
+  if (blockFilter) {
+    blocksToCheck = blocksToCheck.filter((b) => b.name === blockFilter);
+  }
+  const blocks = [];
+  for (const { name, installedFrom } of blocksToCheck) {
+    blocks.push(checkBlock(cwd, name, registry, toolingVersion, installedFrom, verbose));
+  }
+  const currentCount = blocks.filter((b) => b.status === "current").length;
+  const driftedCount = blocks.filter((b) => b.status === "drifted").length;
+  const missingCount = blocks.filter((b) => b.status === "missing").length;
+  return Result.ok({
+    blocks,
+    totalChecked: blocks.length,
+    currentCount,
+    driftedCount,
+    missingCount
+  });
+}
+async function printCheckResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    await output(result, { mode: structuredMode });
+    return;
+  }
+  const theme = createTheme();
+  const lines = [];
+  lines.push("");
+  lines.push("Outfitter Check");
+  lines.push("=".repeat(50));
+  lines.push("");
+  for (const block of result.blocks) {
+    let statusIcon;
+    switch (block.status) {
+      case "current":
+        statusIcon = theme.success("[PASS]");
+        break;
+      case "drifted":
+        statusIcon = theme.error("[DRIFT]");
+        break;
+      case "missing":
+        statusIcon = theme.warning("[MISSING]");
+        break;
+      default:
+        statusIcon = "[?]";
+    }
+    const versionInfo = block.installedFrom ? ` (installed from ${block.installedFrom})` : "";
+    lines.push(`${statusIcon} ${block.name}${versionInfo}`);
+    if (options?.verbose && block.driftedFiles) {
+      for (const file of block.driftedFiles) {
+        const reason = file.reason === "missing" ? "file missing" : "modified";
+        lines.push(`       ${theme.muted(`${file.path}: ${reason}`)}`);
+      }
+    }
+  }
+  lines.push("");
+  lines.push("=".repeat(50));
+  const summaryColor = result.driftedCount === 0 && result.missingCount === 0 ? theme.success : theme.error;
+  lines.push(summaryColor(`${result.currentCount}/${result.totalChecked} blocks current`));
+  if (result.driftedCount > 0) {
+    lines.push(theme.muted(`${result.driftedCount} block(s) have drifted`));
+  }
+  if (result.missingCount > 0) {
+    lines.push(theme.muted(`${result.missingCount} block(s) have missing files`));
+  }
+  if (result.driftedCount > 0 || result.missingCount > 0) {
+    lines.push("");
+    lines.push(theme.muted("Run 'outfitter add <block> --force' to restore registry defaults."));
+  }
+  if (result.totalChecked === 0) {
+    lines.push("");
+    lines.push(theme.muted("No blocks found. If this is a workspace root, run 'outfitter check' from an app or package directory."));
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { CheckError, runCheck, printCheckResults };

package/dist/shared/outfitter-ssynegbs.js

@@ -0,0 +1,167 @@
+// @bun
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check-publish-guardrails.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { Result } from "@outfitter/contracts";
+var REQUIRED_PREPUBLISH_ONLY = "bun ../../scripts/check-publish-manifest.ts";
+var WORKSPACE_DIRS = ["packages", "apps", "plugins"];
+
+class CheckPublishGuardrailsError extends Error {
+  _tag = "CheckPublishGuardrailsError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckPublishGuardrailsError";
+  }
+}
+function readManifest(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function listWorkspacePackageManifests(cwd) {
+  const manifests = [];
+  for (const workspaceDirName of WORKSPACE_DIRS) {
+    const workspaceDir = join(cwd, workspaceDirName);
+    if (!existsSync(workspaceDir)) {
+      continue;
+    }
+    for (const entry of readdirSync(workspaceDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const manifestPath = join(workspaceDir, entry.name, "package.json");
+      if (!existsSync(manifestPath)) {
+        continue;
+      }
+      manifests.push({
+        path: manifestPath,
+        manifest: readManifest(manifestPath)
+      });
+    }
+  }
+  return manifests;
+}
+function isPublishablePackage(manifest) {
+  return manifest.private !== true;
+}
+function findPublishGuardrailViolations(packages) {
+  const violations = [];
+  for (const pkg of packages) {
+    if (!isPublishablePackage(pkg.manifest)) {
+      continue;
+    }
+    const actual = pkg.manifest.scripts?.["prepublishOnly"];
+    if (actual === REQUIRED_PREPUBLISH_ONLY) {
+      continue;
+    }
+    violations.push({
+      packageName: pkg.manifest.name ?? pkg.path,
+      path: pkg.path,
+      expected: REQUIRED_PREPUBLISH_ONLY,
+      actual
+    });
+  }
+  return violations;
+}
+function formatActual(actual) {
+  return typeof actual === "string" ? actual : "<missing>";
+}
+async function runCheckPublishGuardrails(options) {
+  try {
+    const workspaceRoot = resolve(options.cwd);
+    const packages = listWorkspacePackageManifests(workspaceRoot);
+    const violations = findPublishGuardrailViolations(packages);
+    return Result.ok({
+      workspaceRoot,
+      checkedManifestCount: packages.length,
+      violations,
+      ok: violations.length === 0
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to check publish guardrails";
+    return Result.err(new CheckPublishGuardrailsError(message));
+  }
+}
+async function printCheckPublishGuardrailsResult(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;
+  }
+  if (result.ok) {
+    process.stdout.write(`[publish-guardrails] checked ${result.checkedManifestCount} workspace manifests; all publishable packages enforce prepublishOnly guard
+`);
+    return;
+  }
+  const details = result.violations.map((violation) => `- ${violation.packageName} (${violation.path}): prepublishOnly=${formatActual(violation.actual)}; expected=${violation.expected}`).join(`
+`);
+  process.stderr.write([
+    `[publish-guardrails] found ${result.violations.length} publish guardrail violation(s)`,
+    details,
+    "",
+    "Every non-private package must set scripts.prepublishOnly to run check-publish-manifest."
+  ].join(`
+`));
+  process.stderr.write(`
+`);
+}
+function parseCliArgs(argv) {
+  let cwd = process.cwd();
+  let outputMode = "human";
+  for (let index = 0;index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "--cwd") {
+      const value = argv[index + 1];
+      if (!value) {
+        throw new CheckPublishGuardrailsError("Missing value for --cwd");
+      }
+      cwd = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--json") {
+      outputMode = "json";
+      continue;
+    }
+    if (arg === "--jsonl") {
+      outputMode = "jsonl";
+      continue;
+    }
+  }
+  return {
+    cwd: resolve(cwd),
+    outputMode
+  };
+}
+async function runCheckPublishGuardrailsFromArgv(argv) {
+  let parsed;
+  try {
+    parsed = parseCliArgs(argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid command arguments";
+    process.stderr.write(`${message}
+`);
+    return 1;
+  }
+  const result = await runCheckPublishGuardrails({ cwd: parsed.cwd });
+  if (result.isErr()) {
+    process.stderr.write(`${result.error.message}
+`);
+    return 1;
+  }
+  await printCheckPublishGuardrailsResult(result.value, {
+    mode: parsed.outputMode
+  });
+  return result.value.ok ? 0 : 1;
+}
+if (import.meta.main) {
+  runCheckPublishGuardrailsFromArgv(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  });
+}
+
+export { REQUIRED_PREPUBLISH_ONLY, CheckPublishGuardrailsError, findPublishGuardrailViolations, runCheckPublishGuardrails, printCheckPublishGuardrailsResult, runCheckPublishGuardrailsFromArgv };

package/dist/shared/outfitter-svts4wk2.js

@@ -0,0 +1,36 @@
+// @bun
+// apps/outfitter/src/commands/docs-module-loader.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { pathToFileURL } from "url";
+var require2 = createRequire(import.meta.url);
+function resolveDocsEntrypoint() {
+  const packageJsonPath = require2.resolve("@outfitter/docs/package.json");
+  const packageRoot = dirname(packageJsonPath);
+  const srcEntrypoint = join(packageRoot, "src", "index.ts");
+  if (existsSync(srcEntrypoint)) {
+    return srcEntrypoint;
+  }
+  const distEntrypoint = join(packageRoot, "dist", "index.js");
+  if (existsSync(distEntrypoint)) {
+    return distEntrypoint;
+  }
+  throw new Error("Unable to resolve @outfitter/docs entrypoint (expected src/index.ts or dist/index.js).");
+}
+var docsModulePromise;
+async function loadDocsModule() {
+  if (!docsModulePromise) {
+    docsModulePromise = (async () => {
+      const entrypoint = resolveDocsEntrypoint();
+      const module = await import(pathToFileURL(entrypoint).href);
+      if (typeof module.createDocsCommand !== "function" || typeof module.executeCheckCommand !== "function" || typeof module.executeSyncCommand !== "function" || typeof module.executeExportCommand !== "function" || typeof module.generateDocsMap !== "function" || typeof module.generatePackageListSection !== "function" || typeof module.replaceSentinelSection !== "function") {
+        throw new Error("Resolved @outfitter/docs entrypoint does not export required docs functions.");
+      }
+      return module;
+    })();
+  }
+  return await docsModulePromise;
+}
+
+export { loadDocsModule };

package/dist/shared/outfitter-tavatb5p.js

@@ -0,0 +1,166 @@
+// @bun
+import {
+  deriveBinName,
+  deriveProjectName,
+  executePlan,
+  isPathWithin,
+  resolveAuthor,
+  resolveYear,
+  scaffoldWorkspaceRoot,
+  validateProjectDirectoryName
+} from "./outfitter-q1g58t85.js";
+import {
+  runPostScaffold
+} from "./outfitter-4s9meh3j.js";
+import {
+  OperationCollector
+} from "./outfitter-1h7k8xxt.js";
+
+// apps/outfitter/src/commands/init-execution.ts
+import { existsSync } from "fs";
+import { basename, join, resolve } from "path";
+import { Result } from "@outfitter/contracts";
+function toExecutionErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return "Unknown init error";
+}
+function buildInitPlan(target, input, projectDir, resolvedBinName) {
+  const blocks = input.includeTooling ? input.blocksOverride ?? [...target.defaultBlocks] : [];
+  return {
+    values: {
+      name: deriveProjectName(input.packageName),
+      projectName: deriveProjectName(input.packageName),
+      packageName: input.packageName,
+      binName: resolvedBinName,
+      version: "0.1.0",
+      description: "A new project created with Outfitter",
+      author: resolveAuthor(),
+      year: resolveYear()
+    },
+    changes: [
+      {
+        type: "copy-preset",
+        preset: target.presetDir,
+        targetDir: projectDir,
+        includeTooling: input.includeTooling,
+        overlayBaseTemplate: true
+      },
+      { type: "inject-shared-config" },
+      ...input.local ? [{ type: "rewrite-local-dependencies", mode: "workspace" }] : [],
+      ...blocks.length > 0 ? [{ type: "add-blocks", blocks }] : []
+    ]
+  };
+}
+async function executeInitPipeline(input, target, options) {
+  const projectName = deriveProjectName(input.packageName);
+  if (input.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 resolvedProjectDir = resolve(projectBaseDir, projectName);
+  if (input.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.`);
+    }
+  } else {
+    const workspaceName = input.workspaceName ?? basename(input.rootDir);
+    const workspacePackageJsonPath = join(input.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.`);
+      }
+      collector?.add({
+        type: "dir-create",
+        path: join(input.rootDir, "apps")
+      });
+      collector?.add({
+        type: "dir-create",
+        path: join(input.rootDir, "packages")
+      });
+      collector?.add(existsSync(workspacePackageJsonPath) ? {
+        type: "file-overwrite",
+        path: workspacePackageJsonPath,
+        source: "generated"
+      } : {
+        type: "file-create",
+        path: workspacePackageJsonPath,
+        source: "generated"
+      });
+      const readmePath = join(input.rootDir, "README.md");
+      if (options.force || !existsSync(readmePath)) {
+        collector?.add(existsSync(readmePath) ? {
+          type: "file-overwrite",
+          path: readmePath,
+          source: "generated"
+        } : {
+          type: "file-create",
+          path: readmePath,
+          source: "generated"
+        });
+      }
+      const gitignorePath = join(input.rootDir, ".gitignore");
+      if (options.force || !existsSync(gitignorePath)) {
+        collector?.add(existsSync(gitignorePath) ? {
+          type: "file-overwrite",
+          path: gitignorePath,
+          source: "generated"
+        } : {
+          type: "file-create",
+          path: gitignorePath,
+          source: "generated"
+        });
+      }
+    } else {
+      const workspaceResult = scaffoldWorkspaceRoot(input.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 executeResult = await executePlan(plan, {
+    force: options.force,
+    ...collector ? { collector } : {}
+  });
+  if (executeResult.isErr()) {
+    return Result.err(toExecutionErrorMessage(executeResult.error));
+  }
+  const postScaffoldResult = await runPostScaffold({
+    rootDir: input.rootDir,
+    projectDir,
+    origin: "init",
+    target: input.preset,
+    structure: input.structure,
+    skipInstall: options.skipInstall,
+    skipGit: options.skipGit,
+    skipCommit: options.skipCommit,
+    dryRun: options.dryRun,
+    installTimeoutMs: options.installTimeout
+  }, collector);
+  if (postScaffoldResult.isErr()) {
+    return Result.err("Post-scaffold step failed");
+  }
+  return Result.ok({
+    structure: input.structure,
+    rootDir: input.rootDir,
+    projectDir,
+    preset: input.preset,
+    packageName: input.packageName,
+    blocksAdded: executeResult.value.blocksAdded,
+    postScaffold: postScaffoldResult.value,
+    ...collector ? { dryRunPlan: collector.toJSON() } : {}
+  });
+}
+
+export { executeInitPipeline };