@kb-labs/release-manager-cli 2.104.0 → 2.106.0

package/dist/cli/commands/deliver.d.ts

@@ -0,0 +1,18 @@
+import * as _kb_labs_shared_command_kit from '@kb-labs/shared-command-kit';
+import { CLIInput } from '@kb-labs/sdk';
+import { F as FlowResolvableFlags } from '../../resolve-flow-CDGQOKOU.js';
+
+interface DeliverFlags extends FlowResolvableFlags {
+    target?: string;
+    'artifacts-dir'?: string;
+    tag?: string;
+    registry?: string;
+    otp?: string;
+    access?: string;
+    token?: string;
+    'dry-run'?: boolean;
+    json?: boolean;
+}
+declare const _default: _kb_labs_shared_command_kit.CommandHandlerV3<unknown, CLIInput<DeliverFlags>, unknown>;
+
+export { _default as default };

package/dist/cli/commands/deliver.js

@@ -0,0 +1,597 @@
+import { readFileSync, appendFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { defineCommand, findRepoRoot, useConfig, useEnv, useLoader, useLogger } from '@kb-labs/sdk';
+import { mergeConfigWithFlow, resolvePublishTag, resolvePublishRegistry, verifyAgainstRegistry, resolveFlowFromTag } from '@kb-labs/release-manager-core';
+import { spawn } from 'child_process';
+
+// src/cli/commands/deliver.ts
+function rewriteLinkDep(deps, depName, val, pkgPath, versionMap) {
+  const pinned = versionMap.get(depName);
+  if (pinned) {
+    deps[depName] = `^${pinned}`;
+    return;
+  }
+  try {
+    const linkPath = val.slice("link:".length);
+    const linked = JSON.parse(readFileSync(join(pkgPath, linkPath, "package.json"), "utf-8"));
+    deps[depName] = `^${linked.version ?? "*"}`;
+  } catch {
+    deps[depName] = "*";
+  }
+}
+function rewriteWorkspaceDep(deps, depName, val, versionMap) {
+  const pinned = versionMap.get(depName);
+  if (!pinned) {
+    return false;
+  }
+  deps[depName] = val === "workspace:*" ? `^${pinned}` : val.replace("workspace:", "");
+  return true;
+}
+function rewriteDepsSection(deps, pkgPath, versionMap, packageManager) {
+  let modified = false;
+  for (const depName of Object.keys(deps)) {
+    const val = deps[depName];
+    if (typeof val !== "string") {
+      continue;
+    }
+    if (val.startsWith("link:")) {
+      rewriteLinkDep(deps, depName, val, pkgPath, versionMap);
+      modified = true;
+    } else if (val.startsWith("workspace:") && packageManager !== "pnpm" && rewriteWorkspaceDep(deps, depName, val, versionMap)) {
+      modified = true;
+    }
+  }
+  return modified;
+}
+function rewriteWorkspaceDeps(pkg, versionMap, packageManager) {
+  const pkgPath = pkg.path;
+  const pkgJsonPath = join(pkgPath, "package.json");
+  const original = readFileSync(pkgJsonPath, "utf-8");
+  const pkgJson = JSON.parse(original);
+  let modified = false;
+  if (pkgJson.version !== pkg.version) {
+    pkgJson.version = pkg.version;
+    modified = true;
+  }
+  for (const section of ["dependencies", "peerDependencies"]) {
+    const deps = pkgJson[section];
+    if (!deps) {
+      continue;
+    }
+    if (rewriteDepsSection(deps, pkgPath, versionMap, packageManager)) {
+      modified = true;
+    }
+  }
+  if (modified) {
+    writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+  }
+  return () => writeFileSync(pkgJsonPath, original);
+}
+function buildIntraDeps(packages, nameSet) {
+  const deps = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    const intra = /* @__PURE__ */ new Set();
+    try {
+      const pkgJson = JSON.parse(readFileSync(join(pkg.path, "package.json"), "utf-8"));
+      for (const section of ["dependencies", "peerDependencies"]) {
+        for (const depName of Object.keys(pkgJson[section] ?? {})) {
+          if (nameSet.has(depName)) {
+            intra.add(depName);
+          }
+        }
+      }
+    } catch {
+    }
+    deps.set(pkg.name, intra);
+  }
+  return deps;
+}
+function buildDependantsMap(packages, deps) {
+  const dependants = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    for (const dep of deps.get(pkg.name) ?? []) {
+      if (!dependants.has(dep)) {
+        dependants.set(dep, /* @__PURE__ */ new Set());
+      }
+      dependants.get(dep).add(pkg.name);
+    }
+  }
+  return dependants;
+}
+function computeWaves(packages, deps, dependants) {
+  const byName = new Map(packages.map((p) => [p.name, p]));
+  const remaining = new Map(
+    packages.map((p) => [p.name, (deps.get(p.name) ?? /* @__PURE__ */ new Set()).size])
+  );
+  const waves = [];
+  while (remaining.size > 0) {
+    const wave = [...remaining.entries()].filter(([, count]) => count === 0).map(([name]) => byName.get(name));
+    if (wave.length === 0) {
+      waves.push([...remaining.keys()].map((n) => byName.get(n)));
+      break;
+    }
+    waves.push(wave);
+    for (const pkg of wave) {
+      remaining.delete(pkg.name);
+      for (const dependant of dependants.get(pkg.name) ?? []) {
+        if (remaining.has(dependant)) {
+          remaining.set(dependant, (remaining.get(dependant) ?? 1) - 1);
+        }
+      }
+    }
+  }
+  return waves.filter((w) => w.length > 0);
+}
+function topoSort(packages, _packageManager) {
+  const nameSet = new Set(packages.map((p) => p.name));
+  const deps = buildIntraDeps(packages, nameSet);
+  const dependants = buildDependantsMap(packages, deps);
+  return computeWaves(packages, deps, dependants);
+}
+
+// src/shared/publish-programmatic.ts
+var MAX_RETRIES = 5;
+var RETRY_BASE_DELAYS_MS = [1e4, 2e4, 4e4, 8e4, 16e4];
+var RETRYABLE_PATTERNS = [
+  "E429",
+  "429 Too Many Requests",
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "socket hang up",
+  "network timeout",
+  "read ECONNRESET"
+];
+var ALREADY_PUBLISHED_PATTERNS = [
+  "You cannot publish over the previously published versions",
+  "cannot publish over the previously published version",
+  "EPUBLISHCONFLICT"
+  // Some registries return 403 for conflicts
+];
+function isRetryable(message) {
+  return RETRYABLE_PATTERNS.some((p) => message.includes(p));
+}
+function isAlreadyPublished(message) {
+  return ALREADY_PUBLISHED_PATTERNS.some((p) => message.includes(p));
+}
+var NPM_ERROR_HINTS = {
+  E403: "npm rejected the publish (403). If other packages in the same run succeeded with the same token, this is almost certainly an npm-side restriction on this specific package/account entry (e.g. a security hold), not a token or code problem \u2014 check npmjs.com directly or contact npm support. Retrying will not help until that is resolved.",
+  E401: "Authentication failed (401) \u2014 NPM_TOKEN/NODE_AUTH_TOKEN is missing, expired, or invalid for this registry.",
+  E404: "Registry returned 404 \u2014 check the registry URL and that the package name/scope is correct and accessible with this token.",
+  EOTP: "npm requires a one-time password for this publish \u2014 programmatic (token-based) delivery cannot supply one; this package needs an interactive `npm publish` from a human, or a token exempt from OTP."
+};
+function extractNpmErrorCode(message) {
+  const match = message.match(/\bnpm error code (E[A-Z0-9]+)\b/);
+  return match?.[1];
+}
+function classifyPublishError(message) {
+  const code = extractNpmErrorCode(message);
+  const hint = code ? NPM_ERROR_HINTS[code] : void 0;
+  return { code, hint };
+}
+function retryDelay(attempt) {
+  const base = RETRY_BASE_DELAYS_MS[Math.min(attempt, RETRY_BASE_DELAYS_MS.length - 1)];
+  const jitter = 0.8 + Math.random() * 0.4;
+  return Math.round(base * jitter);
+}
+function resolveToken(token) {
+  return token ?? useEnv("NPM_TOKEN") ?? useEnv("NODE_AUTH_TOKEN");
+}
+function spawnPublish(options) {
+  const { packagePath, tarballPath, packageManager, token, otp, dryRun, tag, access, registry } = options;
+  return new Promise((resolve, reject) => {
+    const args = ["publish"];
+    if (tarballPath) {
+      args.push(tarballPath);
+    }
+    if (packageManager === "pnpm" && !tarballPath) {
+      args.push("--no-git-checks");
+    }
+    if (dryRun) {
+      args.push("--dry-run");
+    }
+    if (tag) {
+      args.push(`--tag=${tag}`);
+    }
+    if (access) {
+      args.push(`--access=${access}`);
+    }
+    if (registry) {
+      args.push(`--registry=${registry}`);
+    }
+    if (otp) {
+      args.push(`--otp=${otp}`);
+    }
+    const env = { ...process.env };
+    if (token) {
+      env["NODE_AUTH_TOKEN"] = token;
+    }
+    const npmrcPath = join(packagePath, ".npmrc");
+    const npmrcExisted = existsSync(npmrcPath);
+    const npmrcBackup = npmrcExisted ? readFileSync(npmrcPath, "utf-8") : null;
+    const registryHost = registry ? new URL(registry).host : "registry.npmjs.org";
+    const authLine = `//${registryHost}/:_authToken=\${NODE_AUTH_TOKEN}
+`;
+    if (token) {
+      const existing = npmrcExisted ? readFileSync(npmrcPath, "utf-8") : "";
+      if (!existing.includes("_authToken")) {
+        writeFileSync(npmrcPath, existing + authLine);
+      }
+    }
+    const restoreNpmrc = () => {
+      if (!token) {
+        return;
+      }
+      try {
+        if (npmrcBackup !== null) {
+          writeFileSync(npmrcPath, npmrcBackup);
+        } else if (existsSync(npmrcPath)) {
+          unlinkSync(npmrcPath);
+        }
+      } catch {
+      }
+    };
+    const child = spawn(packageManager, args, {
+      cwd: packagePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: true,
+      env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      restoreNpmrc();
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(stderr || stdout || `${packageManager} publish exited with code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      restoreNpmrc();
+      reject(err);
+    });
+  });
+}
+async function publishOne(pkg, opts, logger) {
+  const restore = pkg.tarballPath ? (() => {
+  }) : rewriteWorkspaceDeps(pkg, opts.versionMap, opts.packageManager);
+  try {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        await spawnPublish({
+          packagePath: pkg.path,
+          tarballPath: pkg.tarballPath,
+          packageManager: opts.packageManager,
+          token: opts.token,
+          otp: opts.otp,
+          dryRun: opts.dryRun,
+          tag: opts.tag,
+          access: opts.access,
+          registry: opts.registry
+        });
+        logger.info(`Published ${pkg.name}@${pkg.version}`);
+        return { name: pkg.name, version: pkg.version, success: true };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (isAlreadyPublished(message)) {
+          logger.info(`${pkg.name}@${pkg.version} already published \u2014 skipping`);
+          return { name: pkg.name, version: pkg.version, success: true, alreadyPublished: true };
+        }
+        if (isRetryable(message) && attempt < MAX_RETRIES) {
+          const delay = retryDelay(attempt);
+          logger.warn(
+            `Transient error for ${pkg.name}@${pkg.version} (attempt ${attempt + 1}/${MAX_RETRIES}), retrying in ${(delay / 1e3).toFixed(1)}s: ${message.split("\n")[0]}`
+          );
+          await new Promise((r) => {
+            setTimeout(r, delay);
+          });
+          continue;
+        }
+        const { code, hint } = classifyPublishError(message);
+        logger.error(`Failed to publish ${pkg.name}@${pkg.version}`, void 0, { error: message, errorCode: code });
+        return { name: pkg.name, version: pkg.version, success: false, error: message, errorCode: code, errorHint: hint };
+      }
+    }
+    return {
+      name: pkg.name,
+      version: pkg.version,
+      success: false,
+      error: `Publish failed after ${MAX_RETRIES} retries (transient errors)`
+    };
+  } finally {
+    restore();
+  }
+}
+function skipRemainingWaves(waves, waveIdx, waveFailed, logger, allResults) {
+  const remaining = waves.slice(waveIdx + 1).reduce((acc, w) => acc + w.length, 0);
+  if (remaining === 0) {
+    return;
+  }
+  logger.warn(
+    `Wave ${waveIdx + 1} had ${waveFailed.length} failure(s) \u2014 skipping ${remaining} package(s) in later waves to avoid broken dependency chain`
+  );
+  for (const laterWave of waves.slice(waveIdx + 1)) {
+    for (const pkg of laterWave) {
+      allResults.push({ name: pkg.name, version: pkg.version, success: false, error: "Skipped: dependency wave failed" });
+    }
+  }
+}
+async function publishPackagesProgrammatic(options) {
+  const {
+    packages,
+    packageManager = "pnpm",
+    dryRun,
+    otp,
+    tag,
+    access,
+    registry
+  } = options;
+  const logger = useLogger();
+  const token = resolveToken(options.token);
+  if (!token && !dryRun) {
+    const error = "No npm token found. Set NPM_TOKEN (or NODE_AUTH_TOKEN) in environment.";
+    logger.error(error);
+    return {
+      results: [],
+      published: [],
+      alreadyPublished: [],
+      failed: packages.map((p) => `${p.name}@${p.version}`),
+      skipped: [],
+      errors: [error]
+    };
+  }
+  const versionMap = new Map(packages.map((p) => [p.name, p.version]));
+  const CONCURRENCY = Number(useEnv("KB_PUBLISH_CONCURRENCY") ?? 4);
+  const waves = topoSort(packages);
+  logger.info(
+    `Publishing ${packages.length} package(s) in ${waves.length} topological wave(s) (concurrency=${CONCURRENCY}, dryRun=${dryRun ?? false})`
+  );
+  const allResults = [];
+  for (let waveIdx = 0; waveIdx < waves.length; waveIdx++) {
+    const wave = waves[waveIdx];
+    logger.info(`Wave ${waveIdx + 1}/${waves.length}: publishing ${wave.length} package(s)`);
+    for (let i = 0; i < wave.length; i += CONCURRENCY) {
+      const batch = wave.slice(i, i + CONCURRENCY);
+      const batchResults = await Promise.all(
+        batch.map(
+          (pkg) => publishOne(pkg, { packageManager, token, versionMap, dryRun, otp, tag, access, registry }, logger)
+        )
+      );
+      allResults.push(...batchResults);
+    }
+    const waveFailed = allResults.slice(-wave.length).filter((r) => !r.success);
+    if (waveFailed.length > 0) {
+      skipRemainingWaves(waves, waveIdx, waveFailed, logger, allResults);
+      break;
+    }
+  }
+  const published = allResults.filter((r) => r.success && !r.alreadyPublished).map((r) => `${r.name}@${r.version}`);
+  const alreadyPublished = allResults.filter((r) => r.alreadyPublished).map((r) => `${r.name}@${r.version}`);
+  const failed = allResults.filter((r) => !r.success).map((r) => `${r.name}@${r.version}`);
+  const errors = allResults.filter((r) => !r.success && r.error).map((r) => `${r.name}: ${r.error}`);
+  if (alreadyPublished.length > 0) {
+    logger.info(`${alreadyPublished.length} package(s) already published \u2014 counted as success`);
+  }
+  return {
+    results: allResults,
+    published,
+    alreadyPublished,
+    failed,
+    skipped: dryRun ? packages.map((p) => `${p.name}@${p.version} (dry-run)`) : [],
+    errors
+  };
+}
+function resolveFlowName(config, flags) {
+  if (flags.flow) {
+    return flags.flow;
+  }
+  if (flags["release-tag"]) {
+    const resolved = resolveFlowFromTag(config, flags["release-tag"]);
+    if (!resolved) {
+      return { error: `Could not resolve a release.flows entry from tag "${flags["release-tag"]}"` };
+    }
+    return resolved.flowName;
+  }
+  return { error: "requires --flow or --release-tag" };
+}
+
+// src/cli/commands/deliver.ts
+var REGISTRY_VERIFY_RETRIES = 5;
+function loadManifest(artifactsDir) {
+  const manifestPath = join(artifactsDir, "manifest.json");
+  try {
+    return JSON.parse(readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return { error: `No manifest.json found at ${manifestPath} \u2014 run \`kb release stage\` first` };
+  }
+}
+function writeGithubStepSummary(markdown) {
+  const summaryPath = useEnv("GITHUB_STEP_SUMMARY");
+  if (!summaryPath) {
+    return;
+  }
+  try {
+    appendFileSync(summaryPath, markdown.endsWith("\n") ? markdown : `${markdown}
+`);
+  } catch {
+  }
+}
+function buildFailureSummaryMarkdown(target, publishedCount, failed) {
+  const lines = [
+    `## \u274C \`release deliver --target ${target}\` \u2014 ${failed.length} package(s) failed`,
+    "",
+    `${publishedCount} package(s) delivered successfully; ${failed.length} did not.`,
+    ""
+  ];
+  for (const f of failed) {
+    lines.push(`### \`${f.name}@${f.version}\`${f.errorCode ? ` \u2014 \`${f.errorCode}\`` : ""}`);
+    if (f.errorHint) {
+      lines.push("", `**${f.errorHint}**`);
+    }
+    lines.push("", "```", f.error.slice(0, 2e3), "```", "");
+  }
+  return lines.join("\n");
+}
+var deliver_default = defineCommand({
+  id: "release:deliver",
+  description: "Ship the tarballs `release stage` already packed to a target (npm) \u2014 no packing, no rebuild",
+  handler: {
+    async execute(ctx, input) {
+      const { flags } = input;
+      const target = flags.target ?? "npm";
+      if (target !== "npm") {
+        const msg = `release:deliver --target ${target} is not implemented \u2014 only "npm" ships this pass (see release plan's out-of-scope section for github-release/mirror)`;
+        if (flags.json) {
+          ctx.ui?.json?.({ error: msg });
+        } else {
+          ctx.ui?.error?.(msg);
+        }
+        return { exitCode: 1 };
+      }
+      const cwd = ctx.cwd || process.cwd();
+      const repoRoot = await findRepoRoot(cwd);
+      const fileConfig = await useConfig();
+      const baseConfig = fileConfig ?? {};
+      const flowResult = resolveFlowName(baseConfig, flags);
+      if (typeof flowResult !== "string") {
+        const msg = `release:deliver ${flowResult.error}`;
+        if (flags.json) {
+          ctx.ui?.json?.({ error: msg });
+        } else {
+          ctx.ui?.error?.(msg);
+        }
+        return { exitCode: 1 };
+      }
+      const config = mergeConfigWithFlow(baseConfig, flowResult);
+      const artifactsDir = join(repoRoot, flags["artifacts-dir"] ?? ".kb/release/artifacts");
+      const manifest = loadManifest(artifactsDir);
+      if (!Array.isArray(manifest)) {
+        if (flags.json) {
+          ctx.ui?.json?.({ error: manifest.error });
+        } else {
+          ctx.ui?.error?.(manifest.error);
+        }
+        return { exitCode: 1 };
+      }
+      if (manifest.length === 0) {
+        const msg = `manifest.json at ${artifactsDir} lists no packages`;
+        if (flags.json) {
+          ctx.ui?.json?.({ error: msg });
+        } else {
+          ctx.ui?.error?.(msg);
+        }
+        return { exitCode: 1 };
+      }
+      const dryRun = flags["dry-run"];
+      const npmTag = flags.tag ?? resolvePublishTag(config, "stable");
+      const registry = flags.registry ?? resolvePublishRegistry(config, "stable");
+      const token = flags.token ?? useEnv("NPM_TOKEN") ?? useEnv("NODE_AUTH_TOKEN");
+      const packages = manifest.map((a) => ({
+        name: a.name,
+        version: a.version,
+        path: artifactsDir,
+        tarballPath: join(artifactsDir, a.tarball)
+      }));
+      const publishLoader = useLoader(`Delivering ${packages.length} package(s) to npm...`);
+      publishLoader.start();
+      const publishResult = await publishPackagesProgrammatic({
+        packages,
+        packageManager: "npm",
+        dryRun,
+        otp: flags.otp,
+        tag: npmTag,
+        access: flags.access ?? config.publish?.access,
+        registry,
+        token
+      });
+      const failed = publishResult.results.filter((r) => !r.success);
+      if (failed.length > 0) {
+        publishLoader.fail(`${failed.length} package(s) failed to publish`);
+        const publishedList = publishResult.results.filter((r) => r.success).map((r) => ({ name: r.name, version: r.version }));
+        const failedList = failed.map((r) => ({
+          name: r.name,
+          version: r.version,
+          error: r.error ?? "Unknown error",
+          errorCode: r.errorCode,
+          errorHint: r.errorHint
+        }));
+        const result2 = { exitCode: 1, target, published: publishedList, failed: failedList };
+        writeGithubStepSummary(buildFailureSummaryMarkdown(target, publishedList.length, failedList));
+        if (flags.json) {
+          ctx.ui?.json?.(result2);
+        } else {
+          ctx.ui?.sideBox?.({
+            title: "Deliver \u2014 npm",
+            sections: [{
+              header: `Failed (${publishedList.length} delivered ok)`,
+              items: failedList.map((r) => `${ctx.ui.symbols.error} ${r.name}@${r.version}${r.errorCode ? ` [${r.errorCode}]` : ""} \u2014 ${r.errorHint ?? r.error}`)
+            }],
+            status: "error"
+          });
+        }
+        return result2;
+      }
+      publishLoader.succeed(`Delivered ${publishResult.results.length} package(s) to npm`);
+      if (dryRun) {
+        const result2 = { exitCode: 0, target, published: publishResult.results.map((r) => ({ name: r.name, version: r.version })) };
+        if (flags.json) {
+          ctx.ui?.json?.(result2);
+        }
+        return result2;
+      }
+      const verifyLoader = useLoader("Verifying delivery against the registry...");
+      verifyLoader.start();
+      const verifyTargets = manifest.map((a) => ({ name: a.name, version: a.version, path: artifactsDir }));
+      const verifyResults = await verifyAgainstRegistry(verifyTargets, {
+        registry,
+        retries: REGISTRY_VERIFY_RETRIES,
+        logger: ctx.platform?.logger
+      });
+      const verifyIssues = verifyResults.flatMap((r) => r.issues);
+      const result = {
+        exitCode: verifyIssues.length === 0 ? 0 : 1,
+        target,
+        published: publishResult.results.map((r) => ({ name: r.name, version: r.version })),
+        verifyIssues
+      };
+      if (verifyIssues.length > 0) {
+        verifyLoader.fail(`Delivery verification found ${verifyIssues.length} issue(s) \u2014 packages are published, verification failed`);
+        writeGithubStepSummary([
+          `## \u26A0\uFE0F \`release deliver --target ${target}\` \u2014 publish succeeded, verification found ${verifyIssues.length} issue(s)`,
+          "",
+          "Packages are already live on the registry \u2014 this is a verification problem, not a publish failure, and nothing was rolled back (npm unpublish is never attempted automatically).",
+          "",
+          ...verifyIssues.map((i) => `- ${i}`)
+        ].join("\n"));
+      } else {
+        verifyLoader.succeed("Delivery verified against the registry");
+      }
+      if (flags.json) {
+        ctx.ui?.json?.(result);
+        return result;
+      }
+      ctx.ui?.sideBox?.({
+        title: "Deliver \u2014 npm",
+        sections: [
+          { header: `Delivered to ${registry} (tag: ${npmTag})`, items: publishResult.results.map((r) => `${ctx.ui.symbols.success} ${r.name}@${r.version}`) },
+          ...verifyIssues.length > 0 ? [{ header: "Verification issues", items: verifyIssues.map((i) => `${ctx.ui.symbols.error} ${i}`) }] : []
+        ],
+        status: verifyIssues.length === 0 ? "success" : "error"
+      });
+      return result;
+    }
+  }
+});
+
+export { deliver_default as default };
+//# sourceMappingURL=deliver.js.map
+//# sourceMappingURL=deliver.js.map