@codefast/cli 0.7.0 → 0.8.1

package/dist/mirror/package-path.js

@@ -3,6 +3,8 @@ import { AppError } from "#/core/errors";
 import { err, ok } from "#/core/result";
 import { normalizePath } from "#/mirror/domain/path-normalizer";
 /**
+ * Resolves the optional positional package argument to a root-relative path, or `undefined` when absent.
+ *
  * @since 0.3.16-canary.0
  */
 export function resolveMirrorPackageFromCliArg(fs, args) {
@@ -22,6 +24,8 @@ export function resolveMirrorPackageFromCliArg(fs, args) {
     return ok(normalized);
 }
 /**
+ * Resolves a package filter to a root-relative path, rejecting anything outside the monorepo root.
+ *
  * @since 0.3.16-canary.0
  */
 export function resolvePackageFilterUnderRoot(fs, rootDir, packageFilter) {
@@ -36,5 +40,4 @@ export function resolvePackageFilterUnderRoot(fs, rootDir, packageFilter) {
         return err(new AppError("VALIDATION_ERROR", `Package path must be a subdirectory under monorepo root: ${rootDir}`));
     }
     return ok(normalized);
-}
-//# sourceMappingURL=package-path.js.map
+}

package/dist/mirror/prepare.js

@@ -5,6 +5,8 @@ import { err, ok } from "#/core/result";
 import { findRepoRoot } from "#/core/workspace/resolver";
 import { resolveMirrorPackageFromCliArg } from "#/mirror/package-path";
 /**
+ * Resolves the repo root, config, and package filter into the prelude a mirror run starts from.
+ *
  * @since 0.3.16-canary.0
  */
 export async function prepareMirrorSync(fs, args) {
@@ -33,5 +35,4 @@ export async function prepareMirrorSync(fs, args) {
         config: loadedOutcome.value.config,
         packageFilter: filterOutcome.value,
     });
-}
-//# sourceMappingURL=prepare.js.map
+}

package/dist/mirror/supplement-exports.js

@@ -105,6 +105,8 @@ function buildSupplementedEntry(specifier, existing, modulePath, distDir, fs, op
     return result;
 }
 /**
+ * Adds missing conditions to a package's existing exports map and returns the specifiers it touched.
+ *
  * @since 0.3.16-canary.0
  */
 export async function supplementExportsInPackageJson(fs, packageJsonPath, packageDir, options, write = true) {
@@ -153,5 +155,4 @@ export function buildSourcePathResolver(fs, packageDir) {
         const tsxPath = path.join(srcDir, `${modulePath}.tsx`);
         return fs.existsSync(tsxPath) ? `./src/${modulePath}.tsx` : `./src/${modulePath}.ts`;
     };
-}
-//# sourceMappingURL=supplement-exports.js.map
+}

package/dist/mirror/sync-reporter.js

@@ -121,5 +121,4 @@ export class MirrorSyncReporter {
         }
         return `${openSequence}${text}${ANSI.reset}`;
     }
-}
-//# sourceMappingURL=sync-reporter.js.map
+}

package/dist/mirror/sync-types.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=sync-types.js.map
+export {};

package/dist/mirror/sync-workspace-package.js

@@ -7,6 +7,8 @@ import { resolvePackageDisplayName } from "#/mirror/domain/package-display-name"
 import { buildSourcePathResolver, supplementExportsInPackageJson } from "#/mirror/supplement-exports";
 import { writePackageJsonExportsAtomic } from "#/mirror/write-exports";
 /**
+ * Regenerates one package's `package.json#exports` from its `dist/` and returns the package's stats.
+ *
  * @since 0.3.16-canary.0
  */
 export async function syncExportsForWorkspacePackage(fs, rootDir, packagePathStr, config, write = true) {
@@ -114,5 +116,4 @@ export async function syncExportsForWorkspacePackage(fs, rootDir, packagePathStr
         pkgStats.error = messageFrom(caughtError);
     }
     return pkgStats;
-}
-//# sourceMappingURL=sync-workspace-package.js.map
+}

package/dist/mirror/sync.js

@@ -7,6 +7,8 @@ import { normalizePath } from "#/mirror/domain/path-normalizer";
 import { resolvePackageFilterUnderRoot } from "#/mirror/package-path";
 import { syncExportsForWorkspacePackage } from "#/mirror/sync-workspace-package";
 /**
+ * Runs the mirror sync across the targeted packages and returns the aggregate stats.
+ *
  * @since 0.3.16-canary.0
  */
 export async function runMirrorSync(fs, input) {
@@ -86,5 +88,4 @@ function mirrorTargetsFromWorkspaceLayout(rootDir, layoutOutcome) {
         .filter((relativePath) => relativePath.length > 0);
     relPaths.sort((left, right) => left.localeCompare(right));
     return { relPaths, multiSource };
-}
-//# sourceMappingURL=sync.js.map
+}

package/dist/mirror/write-exports.js

@@ -141,5 +141,4 @@ export async function writePackageJsonExportsAtomic(fs, packageJsonPath, mergeIn
         throw new MirrorError(MirrorErrorCode.PACKAGE_WRITE, `Failed to atomically update ${packageJsonPath}: ${messageFrom(caughtRenameError)}`, caughtRenameError instanceof Error ? { cause: caughtRenameError } : undefined);
     }
     return { prunedKeys };
-}
-//# sourceMappingURL=write-exports.js.map
+}

package/dist/pack-slim/cli-result.js

@@ -0,0 +1,23 @@
+import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#/core/exit-codes";
+/**
+ * Maps a pack-slim run's stats to the process exit code.
+ *
+ * @since 0.8.1
+ */
+export function exitCodeForPackSlimResult(stats) {
+    return stats.packagesErrored > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+}
+/**
+ * Serializes a pack-slim run's stats as the single-line JSON summary printed under `--json`.
+ *
+ * @since 0.8.1
+ */
+export function formatPackSlimJsonOutput(stats, elapsedSeconds, write = true) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: stats.packagesErrored === 0,
+        write,
+        elapsedSeconds,
+        stats,
+    });
+}

package/dist/pack-slim/cli-schema.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+/**
+ * Zod schema validating the serializable inputs of a pack-slim run.
+ *
+ * @since 0.8.1
+ */
+export const packSlimRunRequestSchema = z.object({
+    rootDir: z.string().min(1),
+    packageFilter: z.string().optional(),
+    write: z.boolean().optional(),
+});

package/dist/pack-slim/command.js

@@ -0,0 +1,79 @@
+import process from "node:process";
+import { Command } from "commander";
+import { globalCliCommanderOptionsSchema } from "#/core/cli/global-options";
+import { readOptionalPositionalArg } from "#/core/cli/positional";
+import { consumeCliAppError } from "#/core/cli/result-handle";
+import { AppError, messageFrom } from "#/core/errors";
+import { nodeFilesystem } from "#/core/filesystem/node";
+import { logger } from "#/core/logger";
+import { err } from "#/core/result";
+import { parseWithSchema } from "#/core/schema-parse";
+import { findRepoRoot } from "#/core/workspace/resolver";
+import { exitCodeForPackSlimResult, formatPackSlimJsonOutput } from "#/pack-slim/cli-result";
+import { packSlimRunRequestSchema } from "#/pack-slim/cli-schema";
+import { PackSlimProgressPresenter } from "#/pack-slim/output";
+import { runPackSlim } from "#/pack-slim/sync";
+import { ensureWorkingTreeClean } from "#/pack-slim/working-tree";
+/**
+ * Creates the `pack-slim` subcommand, which strips the source lane from published packages before publish.
+ *
+ * @since 0.8.1
+ */
+export function createPackSlimCommand() {
+    const cmd = new Command("pack-slim")
+        .description("Strip src, source conditions, and dist source maps from published packages before publish")
+        .argument("[package]", "Optional package path relative to repo root (e.g. packages/ui)")
+        .option("--dry-run", "Report what would change without touching any file", false)
+        .option("--force", "Run even if the git working tree has uncommitted tracked changes", false)
+        .option("--json", "Print one JSON summary on stdout (suppresses human progress)", false)
+        .action(async (packageArg, opts, command) => {
+        const globalsOptionCarrier = command.optsWithGlobals?.() ??
+            command.opts();
+        const globalOptionsOutcome = parseWithSchema(globalCliCommanderOptionsSchema, globalsOptionCarrier);
+        if (!consumeCliAppError(globalOptionsOutcome)) {
+            return;
+        }
+        let rootDir;
+        try {
+            rootDir = findRepoRoot(process.cwd(), nodeFilesystem);
+        }
+        catch (caughtError) {
+            consumeCliAppError(err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError)));
+            return;
+        }
+        const write = !opts.dryRun;
+        // A destructive slim must never land on a developer's uncommitted work; --dry-run writes nothing, so it is exempt.
+        if (write && !opts.force) {
+            const cleanCheck = ensureWorkingTreeClean(rootDir);
+            if (!consumeCliAppError(cleanCheck)) {
+                return;
+            }
+        }
+        const parsed = parseWithSchema(packSlimRunRequestSchema, {
+            rootDir,
+            packageFilter: readOptionalPositionalArg(packageArg),
+            write,
+        });
+        if (!consumeCliAppError(parsed)) {
+            return;
+        }
+        const json = !!opts.json;
+        const presenter = new PackSlimProgressPresenter();
+        if (!json) {
+            presenter.configure({ dryRun: !write });
+        }
+        const startTime = performance.now();
+        const outcome = await runPackSlim(nodeFilesystem, {
+            ...parsed.value,
+            listener: json ? undefined : presenter,
+        });
+        if (!consumeCliAppError(outcome)) {
+            return;
+        }
+        if (json) {
+            logger.out(formatPackSlimJsonOutput(outcome.value, (performance.now() - startTime) / 1000, write));
+        }
+        process.exitCode = exitCodeForPackSlimResult(outcome.value);
+    });
+    return cmd;
+}

package/dist/pack-slim/domain/transform.js

@@ -0,0 +1,95 @@
+/** Pure transforms that strip a package's source lane from a publish artifact. */
+/**
+ * The emitted-file extensions that may carry a `sourceMappingURL` directive.
+ */
+const MAP_ANNOTATED_EXTENSIONS = new Set([".js", ".mjs", ".cjs", ".d.ts", ".d.mts", ".d.cts"]);
+/**
+ * Whether a dist entry is a source-map sidecar (`*.map`).
+ *
+ * @since 0.8.1
+ */
+export function isSourceMapFile(fileName) {
+    return fileName.endsWith(".map");
+}
+/**
+ * Whether a dist entry is an emitted file that may carry a `sourceMappingURL` directive.
+ *
+ * @since 0.8.1
+ */
+export function isMapAnnotatedFile(fileName) {
+    for (const extension of MAP_ANNOTATED_EXTENSIONS) {
+        if (fileName.endsWith(extension)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Produces a publish manifest with `src` dropped from `files` and every `source` export/import condition removed.
+ *
+ * @remarks Operates on a structural clone, so the caller's manifest is left intact. A consumer never enables the
+ * `source` condition and resolves `#/` through `types`/`default` to `dist`, so dropping the source lane and the shipped
+ * sources it points at leaves the published surface whole.
+ *
+ * @since 0.8.1
+ */
+export function slimPublishManifest(manifest) {
+    const draft = structuredClone(manifest);
+    const filesSrcRemoved = removeSrcFromFiles(draft);
+    const exportsSourceRemoved = deleteSourceConditions(draft.exports);
+    const importsSourceRemoved = deleteSourceConditions(draft.imports);
+    const changed = filesSrcRemoved || exportsSourceRemoved > 0 || importsSourceRemoved > 0;
+    return {
+        manifest: draft,
+        report: { filesSrcRemoved, exportsSourceRemoved, importsSourceRemoved, changed },
+    };
+}
+/**
+ * Strips every `sourceMappingURL` directive line from an emitted file's text.
+ *
+ * @since 0.8.1
+ */
+export function stripSourceMappingComment(text) {
+    const lines = text.split("\n");
+    const kept = lines.filter((line) => !/^\s*\/\/# sourceMappingURL=/.test(line));
+    if (kept.length === lines.length) {
+        return { text, stripped: false };
+    }
+    return { text: kept.join("\n"), stripped: true };
+}
+function removeSrcFromFiles(manifest) {
+    const files = manifest.files;
+    if (!Array.isArray(files)) {
+        return false;
+    }
+    const next = files.filter((entry) => entry !== "src");
+    if (next.length === files.length) {
+        return false;
+    }
+    manifest.files = next;
+    return true;
+}
+// Walks a conditions tree deleting every `source` key. A subpath key always starts with ".", so only real
+// condition objects match, and a source-only entry never occurs here, so no node is left empty.
+function deleteSourceConditions(node) {
+    if (Array.isArray(node)) {
+        let removed = 0;
+        for (const item of node) {
+            removed += deleteSourceConditions(item);
+        }
+        return removed;
+    }
+    if (node === null || typeof node !== "object") {
+        return 0;
+    }
+    const record = node;
+    let removed = 0;
+    if ("source" in record) {
+        delete record.source;
+        removed += 1;
+    }
+    for (const key of Object.keys(record)) {
+        removed += deleteSourceConditions(record[key]);
+    }
+    return removed;
+}

package/dist/pack-slim/domain/types.js

@@ -0,0 +1,2 @@
+/** Stats and progress types for a pack-slim run. */
+export {};

package/dist/pack-slim/output.js

@@ -0,0 +1,53 @@
+import { logger } from "#/core/logger";
+/**
+ * A progress listener that renders pack-slim run events as human-readable CLI lines.
+ *
+ * @since 0.8.1
+ */
+export class PackSlimProgressPresenter {
+    dryRun = false;
+    configure(options) {
+        this.dryRun = options.dryRun;
+    }
+    onBanner() {
+        logger.out(this.dryRun ? "pack-slim (dry run) — no files will change" : "pack-slim — stripping source lane");
+    }
+    onPackageComplete(stats, ordinal, total) {
+        const position = `[${ordinal}/${total}]`;
+        if (stats.skipped) {
+            logger.out(`${position} skip ${stats.name} (${stats.skipReason})`);
+            return;
+        }
+        if (stats.error !== null) {
+            logger.err(`${position} error ${stats.name}: ${stats.error}`);
+            return;
+        }
+        if (!stats.changed) {
+            logger.out(`${position} ok   ${stats.name} (already slim)`);
+            return;
+        }
+        const verb = this.dryRun ? "would drop" : "dropped";
+        const parts = [];
+        if (stats.filesSrcRemoved) {
+            parts.push("files:src");
+        }
+        if (stats.exportsSourceRemoved > 0) {
+            parts.push(`exports:source×${stats.exportsSourceRemoved}`);
+        }
+        if (stats.importsSourceRemoved > 0) {
+            parts.push(`imports:source×${stats.importsSourceRemoved}`);
+        }
+        if (stats.mapFilesDeleted > 0) {
+            parts.push(`maps×${stats.mapFilesDeleted}`);
+        }
+        if (stats.sourceCommentsStripped > 0) {
+            parts.push(`sourceMappingURL×${stats.sourceCommentsStripped}`);
+        }
+        logger.out(`${position} ok   ${stats.name} — ${verb} ${parts.join(", ")}`);
+    }
+    onComplete(stats, elapsedSeconds) {
+        logger.out(`pack-slim done in ${elapsedSeconds.toFixed(2)}s — ${stats.packagesChanged} changed, ` +
+            `${stats.packagesSkipped} skipped, ${stats.totalMapFilesDeleted} maps ${this.dryRun ? "to drop" : "dropped"}` +
+            (stats.packagesErrored > 0 ? `, ${stats.packagesErrored} errored` : ""));
+    }
+}

package/dist/pack-slim/sync.js

@@ -0,0 +1,151 @@
+import path from "node:path";
+import { AppError, messageFrom } from "#/core/errors";
+import { err, ok } from "#/core/result";
+import { listWorkspacePackageDirectories } from "#/core/workspace/resolver";
+import { DIST_DIR, PACKAGE_JSON } from "#/mirror/domain/constants";
+import { isMapAnnotatedFile, isSourceMapFile, slimPublishManifest, stripSourceMappingComment, } from "#/pack-slim/domain/transform";
+/**
+ * Strips the source lane from every published package's build output and returns the aggregate stats.
+ *
+ * @remarks Meant to run on an ephemeral CI checkout right before `changeset publish`: it rewrites `package.json`, drops
+ * `dist` source maps, and clears their now-dangling `sourceMappingURL` directives, so the tarball ships only `dist`
+ * runtime and types. Private packages are skipped because `changeset publish` never publishes them.
+ *
+ * @since 0.8.1
+ */
+export async function runPackSlim(fs, input) {
+    const write = input.write ?? true;
+    const { listener } = input;
+    listener?.onBanner?.();
+    const startTime = performance.now();
+    try {
+        const targets = await resolveTargets(fs, input.rootDir, input.packageFilter);
+        const stats = {
+            packagesFound: targets.length,
+            packagesProcessed: 0,
+            packagesSkipped: 0,
+            packagesErrored: 0,
+            packagesChanged: 0,
+            totalMapFilesDeleted: 0,
+            packageDetails: [],
+        };
+        let ordinal = 1;
+        for (const packageDir of targets) {
+            const pkgStats = await slimWorkspacePackage(fs, packageDir, write);
+            stats.packageDetails.push(pkgStats);
+            accumulate(stats, pkgStats);
+            listener?.onPackageComplete?.(pkgStats, ordinal, targets.length);
+            ordinal += 1;
+        }
+        listener?.onComplete?.(stats, (performance.now() - startTime) / 1000);
+        return ok(stats);
+    }
+    catch (caughtError) {
+        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+    }
+}
+async function resolveTargets(fs, rootDir, packageFilter) {
+    if (packageFilter !== undefined) {
+        const packageDir = path.resolve(rootDir, packageFilter);
+        if (!fs.existsSync(path.join(packageDir, PACKAGE_JSON))) {
+            throw new Error(`No package.json under "${packageFilter}"`);
+        }
+        return [packageDir];
+    }
+    const layout = await listWorkspacePackageDirectories(rootDir, fs, false);
+    return [...layout.packageDirectoryPathsAbsolute].sort((left, right) => left.localeCompare(right));
+}
+async function slimWorkspacePackage(fs, packageDir, write) {
+    const packageJsonPath = path.join(packageDir, PACKAGE_JSON);
+    const pkgStats = {
+        name: path.basename(packageDir),
+        path: packageDir,
+        skipped: false,
+        skipReason: "",
+        error: null,
+        filesSrcRemoved: false,
+        exportsSourceRemoved: 0,
+        importsSourceRemoved: 0,
+        mapFilesDeleted: 0,
+        sourceCommentsStripped: 0,
+        changed: false,
+    };
+    if (!fs.existsSync(packageJsonPath)) {
+        pkgStats.skipped = true;
+        pkgStats.skipReason = "package.json not found";
+        return pkgStats;
+    }
+    try {
+        const raw = await fs.readFile(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new SyntaxError("package.json root must be a JSON object");
+        }
+        const manifest = parsed;
+        if (typeof manifest.name === "string") {
+            pkgStats.name = manifest.name;
+        }
+        if (manifest.private === true) {
+            pkgStats.skipped = true;
+            pkgStats.skipReason = "private package";
+            return pkgStats;
+        }
+        const { manifest: slimmed, report } = slimPublishManifest(manifest);
+        pkgStats.filesSrcRemoved = report.filesSrcRemoved;
+        pkgStats.exportsSourceRemoved = report.exportsSourceRemoved;
+        pkgStats.importsSourceRemoved = report.importsSourceRemoved;
+        if (report.changed && write) {
+            await fs.writeFile(packageJsonPath, `${JSON.stringify(slimmed, null, 2)}\n`, "utf8");
+        }
+        await pruneDist(fs, path.join(packageDir, DIST_DIR), write, pkgStats);
+        pkgStats.changed = report.changed || pkgStats.mapFilesDeleted > 0 || pkgStats.sourceCommentsStripped > 0;
+    }
+    catch (caughtError) {
+        pkgStats.error = messageFrom(caughtError);
+    }
+    return pkgStats;
+}
+async function pruneDist(fs, distDir, write, pkgStats) {
+    if (!fs.existsSync(distDir)) {
+        return;
+    }
+    const entries = (await fs.readdir(distDir, { recursive: true, withFileTypes: true }));
+    for (const entry of entries) {
+        if (!entry.isFile()) {
+            continue;
+        }
+        const filePath = path.join(entry.parentPath, entry.name);
+        if (isSourceMapFile(entry.name)) {
+            if (write) {
+                await fs.unlink(filePath);
+            }
+            pkgStats.mapFilesDeleted += 1;
+            continue;
+        }
+        if (isMapAnnotatedFile(entry.name)) {
+            const contents = await fs.readFile(filePath, "utf8");
+            const { text, stripped } = stripSourceMappingComment(contents);
+            if (stripped) {
+                if (write) {
+                    await fs.writeFile(filePath, text, "utf8");
+                }
+                pkgStats.sourceCommentsStripped += 1;
+            }
+        }
+    }
+}
+function accumulate(stats, pkgStats) {
+    if (pkgStats.skipped) {
+        stats.packagesSkipped += 1;
+        return;
+    }
+    if (pkgStats.error !== null) {
+        stats.packagesErrored += 1;
+        return;
+    }
+    stats.packagesProcessed += 1;
+    stats.totalMapFilesDeleted += pkgStats.mapFilesDeleted;
+    if (pkgStats.changed) {
+        stats.packagesChanged += 1;
+    }
+}

package/dist/pack-slim/working-tree.js

@@ -0,0 +1,45 @@
+import { execFileSync } from "node:child_process";
+import { AppError, messageFrom } from "#/core/errors";
+import { err, ok } from "#/core/result";
+/**
+ * Whether git's tracked-only porcelain output reports any uncommitted change.
+ *
+ * @remarks The output is read with `--untracked-files=no`, so untracked and gitignored paths (like the freshly built
+ * `dist`) never appear — any non-blank line is a staged or unstaged change to a tracked file.
+ *
+ * @since 0.8.1
+ */
+export function hasUncommittedTrackedChanges(porcelainOutput) {
+    return porcelainOutput.split("\n").some((line) => line.trim().length > 0);
+}
+/**
+ * Reads git's porcelain status for tracked files only, under the given root.
+ */
+function readTrackedWorkingTreeStatus(rootDir) {
+    return execFileSync("git", ["status", "--porcelain", "--untracked-files=no"], {
+        cwd: rootDir,
+        encoding: "utf8",
+    });
+}
+/**
+ * Refuses when the git working tree carries uncommitted tracked changes, so a destructive slim never lands on real work.
+ *
+ * @remarks pack-slim rewrites tracked `package.json` files and deletes build output; its result must never be committed.
+ * A caller passing `--force` skips this, and `--dry-run` never reaches it because it writes nothing.
+ *
+ * @since 0.8.1
+ */
+export function ensureWorkingTreeClean(rootDir) {
+    let porcelain;
+    try {
+        porcelain = readTrackedWorkingTreeStatus(rootDir);
+    }
+    catch (caughtError) {
+        return err(new AppError("INFRA_FAILURE", `Could not check the git working tree: ${messageFrom(caughtError)}. Pass --force to skip this check.`, caughtError));
+    }
+    if (hasUncommittedTrackedChanges(porcelain)) {
+        return err(new AppError("VALIDATION_ERROR", "pack-slim refuses to run: the git working tree has uncommitted tracked changes. " +
+            "Commit or stash them, use --dry-run to preview, or pass --force to override."));
+    }
+    return ok(undefined);
+}

package/dist/tag/cli-result.js

@@ -1,5 +1,7 @@
 import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#/core/exit-codes";
 /**
+ * Maps a tag run's result to the process exit code.
+ *
  * @since 0.3.16-canary.0
  */
 export function exitCodeForTagSyncResult(result) {
@@ -8,5 +10,4 @@ export function exitCodeForTagSyncResult(result) {
     }
     const hasRunErrors = result.targetResults.some((targetResult) => targetResult.runError !== null);
     return hasRunErrors || result.hookError !== null ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
-}
-//# sourceMappingURL=cli-result.js.map
+}

package/dist/tag/cli-schema.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
 /**
+ * Zod schema validating a `TagSyncRunRequest`.
+ *
  * @since 0.3.16-canary.0
  */
 export const tagSyncRunRequestSchema = z.object({
@@ -9,5 +11,4 @@ export const tagSyncRunRequestSchema = z.object({
     targetPath: z.string().optional(),
     skipPackages: z.array(z.string()).optional(),
     config: z.unknown().optional(),
-});
-//# sourceMappingURL=cli-schema.js.map
+});

package/dist/tag/command.js

@@ -11,6 +11,8 @@ import { presentTagSyncResult, TagSyncProgressPresenter } from "#/tag/output";
 import { prepareTagSync } from "#/tag/prepare";
 import { runTagSync } from "#/tag/sync";
 /**
+ * Creates the `tag` subcommand, which stamps `@since` tags on exported declarations.
+ *
  * @since 0.3.16-canary.0
  */
 export function createTagCommand() {
@@ -65,5 +67,4 @@ function formatTagSyncJsonOutput(result, rootDir) {
         cwd: rootDir,
         result,
     });
-}
-//# sourceMappingURL=command.js.map
+}

package/dist/tag/domain/types.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=types.js.map
+export {};

package/dist/tag/output.js

@@ -2,6 +2,8 @@ import { CLI_EXIT_GENERAL_ERROR } from "#/core/exit-codes";
 import { logger } from "#/core/logger";
 import { exitCodeForTagSyncResult } from "#/tag/cli-result";
 /**
+ * A progress listener that prints a line as each tag target starts and completes.
+ *
  * @since 0.3.16-canary.0
  */
 export class TagSyncProgressPresenter {
@@ -27,6 +29,8 @@ const colors = {
     yellow: "\x1b[33m",
 };
 /**
+ * Prints a tag run's target table, warnings, and summary, and returns the exit code.
+ *
  * @since 0.3.16-canary.0
  */
 export function presentTagSyncResult(result, rootDir) {
@@ -97,5 +101,4 @@ function formatSummary(result) {
         lines.push(`[tag] Skipped: ${result.skippedPackages.length} package(s)`);
     }
     return lines.join("\n");
-}
-//# sourceMappingURL=output.js.map
+}

package/dist/tag/prepare.js

@@ -3,6 +3,8 @@ import { ok } from "#/core/result";
 import { findRepoRoot } from "#/core/workspace/resolver";
 import { resolveProvidedTagTargetPath } from "#/tag/resolve-target-path";
 /**
+ * Resolves the repo root, config, and optional target path into the prelude a tag run starts from.
+ *
  * @since 0.3.16-canary.0
  */
 export async function prepareTagSync(fs, args) {
@@ -26,5 +28,4 @@ export async function prepareTagSync(fs, args) {
         config: loadedOutcome.value.config,
         resolvedTargetPath,
     });
-}
-//# sourceMappingURL=prepare.js.map
+}