@codefast/cli 0.7.0 → 0.8.1

package/dist/audit/domain/mappings.js

@@ -2,7 +2,7 @@
  * Physical → logical replacements. Order matters: negative before positive,
  * specific corners before general edges, with-value before bare.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export const RTL_MAPPINGS = [
     ["-ml-", "-ms-"],
@@ -53,7 +53,7 @@ export const RTL_MAPPINGS = [
 /**
  * translate-x has no logical equivalent — it needs an rtl:-negated twin.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export const RTL_TRANSLATE_X_MAPPINGS = [
     ["-translate-x-", "translate-x-"],
@@ -62,7 +62,7 @@ export const RTL_TRANSLATE_X_MAPPINGS = [
 /**
  * Classes that need an rtl:*-reverse companion.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export const RTL_REVERSE_MAPPINGS = [
     ["space-x-", "space-x-reverse"],
@@ -71,7 +71,7 @@ export const RTL_REVERSE_MAPPINGS = [
 /**
  * Classes that need an rtl: companion with the swapped value.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export const RTL_SWAP_MAPPINGS = [
     ["cursor-w-resize", "cursor-e-resize"],
@@ -81,23 +81,24 @@ export const RTL_SWAP_MAPPINGS = [
  * Anything anchored to a physical side variant stays physical: Radix resolves
  * `side` per direction, and a border/position/slide tied to that side must follow it.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export const PHYSICAL_SIDE_VARIANT = /data-side-(?:left|right)|data-\[side=(?:left|right)\]|\[data-side=(?:left|right)\]/;
 /**
  * Slide animations under direction-resolved contexts are correct as-is:
  * Radix flips `side`/`motion` values itself under DirectionProvider.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export const DIRECTION_RESOLVED_VARIANT = /data-\[motion[=^]/;
 /**
- * @since 1.0.0-canary.7
+ * The physical slide-animation class prefixes the RTL audit inspects.
+ *
+ * @since 0.5.0-canary.6
  */
 export const SLIDE_PREFIXES = [
     "slide-in-from-left",
     "slide-in-from-right",
     "slide-out-to-left",
     "slide-out-to-right",
-];
-//# sourceMappingURL=mappings.js.map
+];

package/dist/audit/domain/markdown-links.js

@@ -72,5 +72,4 @@ function lineNumberAt(content, index) {
         }
     }
     return line;
-}
-//# sourceMappingURL=markdown-links.js.map
+}

package/dist/audit/domain/react-imports.js

@@ -0,0 +1,91 @@
+import { parseSync } from "oxc-parser";
+function isOxcNode(value) {
+    return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function isIdentifierNamed(node, name) {
+    return isOxcNode(node) && node.type === "Identifier" && node.name === name;
+}
+/**
+ * Scans one TypeScript source for React import-policy violations.
+ *
+ * @remarks Three violation kinds: `import * as React`, a default `React` import (type-only
+ * included), and — only when no import binds `React` — an implicit `React.*` UMD-global type
+ * reference, which tsc accepts silently through the `export as namespace React` in `@types/react`.
+ *
+ * @since 0.8.0
+ */
+export function auditReactImportSource(filePath, sourceText) {
+    const { program } = parseSync(filePath, sourceText);
+    const statements = program.body;
+    const violations = [];
+    let bindsReact = false;
+    for (const statement of statements) {
+        if (statement.type !== "ImportDeclaration") {
+            continue;
+        }
+        const source = statement.source;
+        if (!isOxcNode(source) || source.value !== "react") {
+            continue;
+        }
+        const specifiers = Array.isArray(statement.specifiers) ? statement.specifiers.filter(isOxcNode) : [];
+        bindsReact ||= specifiers.some((specifier) => isIdentifierNamed(specifier.local, "React"));
+        for (const specifier of specifiers) {
+            if (specifier.type === "ImportNamespaceSpecifier") {
+                violations.push({
+                    line: lineOfOffset(sourceText, statement.start),
+                    raw: firstLineOf(sourceText.slice(statement.start, statement.end)),
+                    reason: 'namespace React import — import members by name from "react"',
+                });
+            }
+            else if (specifier.type === "ImportDefaultSpecifier") {
+                violations.push({
+                    line: lineOfOffset(sourceText, statement.start),
+                    raw: firstLineOf(sourceText.slice(statement.start, statement.end)),
+                    reason: 'default React import — import members by name from "react"',
+                });
+            }
+        }
+    }
+    // A bound `React` means the import itself is flagged above; qualified names under it are
+    // symptoms, not extra findings.
+    if (!bindsReact) {
+        collectUmdGlobalReferences(program, sourceText, violations);
+    }
+    violations.sort((a, b) => a.line - b.line);
+    return violations;
+}
+function collectUmdGlobalReferences(node, sourceText, violations) {
+    if (node.type === "TSQualifiedName" && isIdentifierNamed(node.left, "React")) {
+        violations.push({
+            line: lineOfOffset(sourceText, node.start),
+            raw: sourceText.slice(node.start, node.end),
+            reason: 'implicit React.* UMD global — add import type { … } from "react"',
+        });
+        return;
+    }
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (isOxcNode(item)) {
+                    collectUmdGlobalReferences(item, sourceText, violations);
+                }
+            }
+        }
+        else if (isOxcNode(value)) {
+            collectUmdGlobalReferences(value, sourceText, violations);
+        }
+    }
+}
+function lineOfOffset(sourceText, offset) {
+    let line = 1;
+    for (let index = 0; index < offset; index++) {
+        if (sourceText.charCodeAt(index) === 10) {
+            line++;
+        }
+    }
+    return line;
+}
+function firstLineOf(text) {
+    const newlineIndex = text.indexOf("\n");
+    return newlineIndex === -1 ? text : text.slice(0, newlineIndex);
+}

package/dist/audit/domain/since-versions.js

@@ -0,0 +1,85 @@
+/**
+ * Flags `@since` tags naming a version the owning package has not reached.
+ */
+const versionPattern = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.-]+)?$/;
+// `@since` appears only inside comments; matching the comment lead-in keeps code and prose out.
+const sinceLinePattern = /^\s*(?:\*|\/\/|\/\*+)\s*@since\s+(\S+)/;
+const numericIdentifierPattern = /^\d+$/;
+function parseVersion(value) {
+    const match = versionPattern.exec(value);
+    if (match === null) {
+        return null;
+    }
+    return {
+        core: [Number(match[1]), Number(match[2]), Number(match[3])],
+        prerelease: match[4] === undefined ? [] : match[4].split("."),
+    };
+}
+/**
+ * Compares two SemVer strings by precedence — positive when `left` is greater,
+ * null when either side is not a SemVer version.
+ *
+ * @since 0.8.0
+ */
+export function compareVersionPrecedence(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (a === null || b === null) {
+        return null;
+    }
+    for (let index = 0; index < 3; index++) {
+        if (a.core[index] !== b.core[index]) {
+            return a.core[index] - b.core[index];
+        }
+    }
+    // A pre-release ranks below the release it precedes.
+    if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+        return b.prerelease.length - a.prerelease.length;
+    }
+    const shared = Math.min(a.prerelease.length, b.prerelease.length);
+    for (let index = 0; index < shared; index++) {
+        const leftId = a.prerelease[index];
+        const rightId = b.prerelease[index];
+        const leftIsNumeric = numericIdentifierPattern.test(leftId);
+        const rightIsNumeric = numericIdentifierPattern.test(rightId);
+        if (leftIsNumeric && rightIsNumeric) {
+            const difference = Number(leftId) - Number(rightId);
+            if (difference !== 0) {
+                return difference;
+            }
+        }
+        else if (leftIsNumeric !== rightIsNumeric) {
+            // Numeric identifiers rank below alphanumeric ones.
+            return leftIsNumeric ? -1 : 1;
+        }
+        else if (leftId !== rightId) {
+            return leftId < rightId ? -1 : 1;
+        }
+    }
+    return a.prerelease.length - b.prerelease.length;
+}
+/**
+ * Scans a file's comments for `@since` tags stamped above the package's current
+ * version — a release that has not happened, so the stamp cannot be true.
+ *
+ * @since 0.8.0
+ */
+export function scanImpossibleSinceTags(content, packageVersion) {
+    if (parseVersion(packageVersion) === null) {
+        return [];
+    }
+    const findings = [];
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index++) {
+        const match = sinceLinePattern.exec(lines[index]);
+        if (match === null) {
+            continue;
+        }
+        const stamped = match[1];
+        const comparison = compareVersionPrecedence(stamped, packageVersion);
+        if (comparison !== null && comparison > 0) {
+            findings.push({ line: index + 1, raw: `@since ${stamped}` });
+        }
+    }
+    return findings;
+}

package/dist/audit/domain/tokenize.js

@@ -2,7 +2,7 @@
  * Splits a class token into [variant, value, modifier], colon/slash-aware of
  * brackets and parens (arbitrary values like data-[side=left] or calc(...)).
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export function splitClassName(token) {
     const segments = [];
@@ -50,9 +50,9 @@ export function splitClassName(token) {
 /**
  * Extracts string/template literal contents with their line numbers.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
-export function* stringLiterals(content) {
+function* stringLiterals(content) {
     const pattern = /"([^"\n]*)"|'([^'\n]*)'|`([^`]*)`/g;
     for (const match of content.matchAll(pattern)) {
         const text = match[1] ?? match[2] ?? match[3] ?? "";
@@ -61,7 +61,9 @@ export function* stringLiterals(content) {
     }
 }
 /**
- * @since 1.0.0-canary.7
+ * Collects the parsed class tokens from every string literal in a file's content.
+ *
+ * @since 0.5.0-canary.6
  */
 export function collectTokens(content) {
     const tokens = [];
@@ -79,5 +81,4 @@ export function collectTokens(content) {
         }
     }
     return tokens;
-}
-//# sourceMappingURL=tokenize.js.map
+}

package/dist/audit/domain/tsdoc-syntax.js

@@ -29,5 +29,4 @@ export function scanTsdocSyntax(content) {
         }
     }
     return findings;
-}
-//# sourceMappingURL=tsdoc-syntax.js.map
+}

package/dist/audit/domain/types.js

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

package/dist/audit/output.js

@@ -3,7 +3,7 @@ import { logger } from "#/core/logger";
 /**
  * Exit `1` when any non-allowlisted violation remains.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export function exitCodeForRtlAuditResult(result) {
     return result.violationCount > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
@@ -11,7 +11,7 @@ export function exitCodeForRtlAuditResult(result) {
 /**
  * Human-readable RTL audit report (matches the former packages/ui script shape).
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export function presentRtlAuditResult(result) {
     for (const file of result.files) {
@@ -31,7 +31,7 @@ export function presentRtlAuditResult(result) {
 /**
  * Machine-readable RTL audit summary for `--json`.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export function formatRtlAuditJsonOutput(result, rootDir) {
     return JSON.stringify({
@@ -82,6 +82,47 @@ export function formatLinkAuditJsonOutput(result, rootDir) {
         result,
     });
 }
+/**
+ * Exit `1` when any non-allowlisted React import-policy violation remains.
+ *
+ * @since 0.8.0
+ */
+export function exitCodeForReactAuditResult(result) {
+    return result.violationCount > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+}
+/**
+ * Human-readable React import-policy report.
+ *
+ * @since 0.8.0
+ */
+export function presentReactAuditResult(result) {
+    for (const file of result.files) {
+        logger.out(`\n${file.relativePath}`);
+        for (const { line, raw, reason } of file.violations) {
+            logger.out(`  ${line}: ${raw} → ${reason}`);
+        }
+    }
+    const allowlistSuffix = result.allowlistedCount > 0 ? ` (${result.allowlistedCount} allowlisted)` : "";
+    if (result.violationCount > 0) {
+        logger.out(`\n✖ ${result.violationCount} React import violation(s)${allowlistSuffix}`);
+    }
+    else {
+        logger.out(`✓ No namespace/default React imports or React.* UMD globals across ${result.scannedFileCount} file(s)${allowlistSuffix}`);
+    }
+}
+/**
+ * Machine-readable React import-policy summary for `--json`.
+ *
+ * @since 0.8.0
+ */
+export function formatReactAuditJsonOutput(result, rootDir) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: result.violationCount === 0,
+        cwd: rootDir,
+        result,
+    });
+}
 /**
  * Exit `1` when any non-allowlisted divider still breaks the convention.
  *
@@ -128,5 +169,4 @@ export function formatCommentAuditJsonOutput(result, rootDir) {
 }
 function truncate(raw) {
     return raw.length <= 60 ? raw : `${raw.slice(0, 57)}…`;
-}
-//# sourceMappingURL=output.js.map
+}

package/dist/audit/prepare.js

@@ -6,7 +6,7 @@ import { findRepoRoot } from "#/core/workspace/resolver";
 /**
  * Loads config and resolves the scan target for `audit rtl`.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export async function prepareRtlAudit(fs, args) {
     let rootDir;
@@ -70,6 +70,37 @@ export async function prepareLinkAudit(fs, args) {
         allowlist: linksConfig.allowlist ?? [],
     });
 }
+/**
+ * Loads config and resolves the scan target for `audit react`.
+ *
+ * @remarks Defaults to the repo root: the import policy is repo-wide, and generated or vendored
+ * trees are already excluded by the shared walk.
+ *
+ * @since 0.8.0
+ */
+export async function prepareReactAudit(fs, args) {
+    let rootDir;
+    try {
+        rootDir = fs.canonicalPathSync(findRepoRoot(args.currentWorkingDirectory, fs));
+    }
+    catch (caughtError) {
+        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+    }
+    const loadedOutcome = await loadCodefastConfig(rootDir, fs);
+    if (!loadedOutcome.ok) {
+        return loadedOutcome;
+    }
+    const reactConfig = loadedOutcome.value.config.audit?.react ?? {};
+    const targetPath = args.rawTarget === undefined ? rootDir : resolveRepoRelativePath(args.currentWorkingDirectory, args.rawTarget);
+    if (!fs.existsSync(targetPath)) {
+        return err(new AppError("NOT_FOUND", `Not found: ${targetPath}`));
+    }
+    return ok({
+        rootDir,
+        targetPath: fs.canonicalPathSync(targetPath),
+        allowlist: reactConfig.allowlist ?? [],
+    });
+}
 /**
  * Loads config and resolves the scan target for `audit comments`.
  *
@@ -100,5 +131,4 @@ export async function prepareCommentAudit(fs, args) {
         targetPath: fs.canonicalPathSync(targetPath),
         allowlist: commentsConfig.allowlist ?? [],
     });
-}
-//# sourceMappingURL=prepare.js.map
+}

package/dist/audit/run-comments.js

@@ -2,9 +2,11 @@ import path from "node:path";
 import { scanCommentContent } from "#/audit/domain/comment-content";
 import { applyCommentDividerFixes, DIVIDER_COLUMN, scanCommentDividers } from "#/audit/domain/comment-dividers";
 import { countHeadMentions, isPathLinkTarget, linkTargetHead, scanLinkReferences, } from "#/audit/domain/link-references";
+import { scanImpossibleSinceTags } from "#/audit/domain/since-versions";
 import { scanTsdocSyntax } from "#/audit/domain/tsdoc-syntax";
 import { AppError, messageFrom } from "#/core/errors";
 import { err, ok } from "#/core/result";
+import { findNearestPackageVersion } from "#/core/workspace/package-version";
 import { sourceCommentLanguage, walkSourceFiles } from "#/core/workspace/source-walk";
 const reasonByDefect = {
     "bad-width": `rule does not end at column ${DIVIDER_COLUMN}`,
@@ -15,6 +17,7 @@ const reasonByDefect = {
     "legacy-form": "legacy divider form",
     "param-coverage": "a block naming any parameter must name them all — a partial list reads as complete",
     "param-hyphen": "TSDoc separates the name from its description with ' - '",
+    "since-impossible": "@since names a version the package has not reached — set it to the release that shipped the symbol",
     "since-order": "@since is stamped at release and stays the block's last tag",
     "stacked-doc": "// run stacked above a doc block — fold it into the block",
 };
@@ -32,6 +35,7 @@ export function runCommentAudit(fs, args) {
         const filesToScan = collectScanPaths(fs, targetPath);
         const perFile = new Map();
         const scanned = [];
+        const versionByDirectory = new Map();
         let allowlistedCount = 0;
         let fixedCount = 0;
         let dividerCount = 0;
@@ -71,6 +75,16 @@ export function runCommentAudit(fs, args) {
                 }
                 breakages.push({ line: finding.line, raw: finding.raw, reason: reasonByDefect[finding.defect] });
             }
+            const packageVersion = nearestVersion(fs, absolutePath, versionByDirectory);
+            if (packageVersion !== null) {
+                for (const finding of scanImpossibleSinceTags(content, packageVersion)) {
+                    if (allowlist.has(finding.raw) || allowlist.has(`${relativePath}:${finding.raw}`)) {
+                        allowlistedCount++;
+                        continue;
+                    }
+                    breakages.push({ line: finding.line, raw: finding.raw, reason: reasonByDefect["since-impossible"] });
+                }
+            }
             if (language === "js") {
                 for (const finding of scanTsdocSyntax(content)) {
                     if (allowlist.has(finding.raw) || allowlist.has(`${relativePath}:${finding.raw}`)) {
@@ -152,6 +166,17 @@ function appendDeadLinkBreakages(fs, scanned, allowlist, perFile) {
     }
     return allowlisted;
 }
+// One package.json walk per directory — sibling files share the answer.
+function nearestVersion(fs, absolutePath, cache) {
+    const directory = path.dirname(absolutePath);
+    const cached = cache.get(directory);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const version = findNearestPackageVersion(fs, directory);
+    cache.set(directory, version);
+    return version;
+}
 function collectScanPaths(fs, targetPath) {
     const stats = fs.statSync(targetPath);
     if (stats.isFile()) {
@@ -161,5 +186,4 @@ function collectScanPaths(fs, targetPath) {
 }
 function toPosixPath(filePath) {
     return filePath.split(path.sep).join("/");
-}
-//# sourceMappingURL=run-comments.js.map
+}

package/dist/audit/run-links.js

@@ -88,5 +88,4 @@ function collectScanPaths(fs, targetPath) {
 }
 function toPosixPath(filePath) {
     return filePath.split(path.sep).join("/");
-}
-//# sourceMappingURL=run-links.js.map
+}

package/dist/audit/run-react.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+import { auditReactImportSource } from "#/audit/domain/react-imports";
+import { AppError, messageFrom } from "#/core/errors";
+import { err, ok } from "#/core/result";
+import { walkTsxFiles } from "#/core/workspace/typescript-walk";
+/**
+ * Scans a target path for React import-policy violations.
+ *
+ * @since 0.8.0
+ */
+export function runReactAudit(fs, args) {
+    try {
+        const allowlist = new Set(args.allowlist);
+        const { rootDir, targetPath } = args;
+        const filesToScan = collectScanPaths(fs, targetPath);
+        const files = [];
+        let violationCount = 0;
+        let allowlistedCount = 0;
+        for (const absolutePath of filesToScan) {
+            const relativePath = toPosixPath(path.relative(rootDir, absolutePath));
+            const content = fs.readFileSync(absolutePath, "utf8");
+            const remaining = auditReactImportSource(absolutePath, content).filter(({ raw }) => {
+                const isAllowed = allowlist.has(raw) || allowlist.has(`${relativePath}:${raw}`);
+                if (isAllowed) {
+                    allowlistedCount++;
+                }
+                return !isAllowed;
+            });
+            if (remaining.length === 0) {
+                continue;
+            }
+            violationCount += remaining.length;
+            files.push({ relativePath, violations: remaining });
+        }
+        return ok({
+            files,
+            violationCount,
+            allowlistedCount,
+            scannedFileCount: filesToScan.length,
+        });
+    }
+    catch (caughtError) {
+        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+    }
+}
+function collectScanPaths(fs, targetPath) {
+    const stats = fs.statSync(targetPath);
+    if (stats.isFile()) {
+        return [targetPath];
+    }
+    return walkTsxFiles(targetPath, fs);
+}
+function toPosixPath(filePath) {
+    return filePath.split(path.sep).join("/");
+}

package/dist/audit/run.js

@@ -6,7 +6,7 @@ import { walkTsxFiles } from "#/core/workspace/typescript-walk";
 /**
  * Scans a target path for physical-direction Tailwind class violations.
  *
- * @since 1.0.0-canary.7
+ * @since 0.5.0-canary.6
  */
 export function runRtlAudit(fs, args) {
     try {
@@ -53,5 +53,4 @@ function collectScanPaths(fs, targetPath) {
 }
 function toPosixPath(filePath) {
     return filePath.split(path.sep).join("/");
-}
-//# sourceMappingURL=run.js.map
+}

package/dist/bin.js

@@ -2,5 +2,4 @@
 import process from "node:process";
 import { runCli } from "#/cli";
 const code = await runCli(process.argv);
-process.exit(code);
-//# sourceMappingURL=bin.js.map
+process.exit(code);

package/dist/cli.js

@@ -6,6 +6,7 @@ import { Command } from "commander";
 import { createArrangeCommand } from "#/arrange/command";
 import { createAuditCommand } from "#/audit/command";
 import { createMirrorCommand } from "#/mirror/command";
+import { createPackSlimCommand } from "#/pack-slim/command";
 import { createTagCommand } from "#/tag/command";
 function readVersion() {
     try {
@@ -20,6 +21,8 @@ function readVersion() {
     }
 }
 /**
+ * Runs the `codefast` CLI over the given argv and returns the process exit code.
+ *
  * @since 0.3.16-canary.0
  */
 export async function runCli(argv) {
@@ -37,9 +40,9 @@ export async function runCli(argv) {
     program.addCommand(createArrangeCommand());
     program.addCommand(createAuditCommand());
     program.addCommand(createMirrorCommand());
+    program.addCommand(createPackSlimCommand());
     program.addCommand(createTagCommand());
     await program.parseAsync(argv, { from: "node" });
     const code = process.exitCode ?? 0;
     return typeof code === "number" ? code : Number(code) || 0;
-}
-//# sourceMappingURL=cli.js.map
+}

package/dist/core/cli/format-error.js

@@ -1,4 +1,6 @@
 /**
+ * Formats an `AppError` as a `[CODE] message` line for CLI output.
+ *
  * @since 0.3.16-canary.0
  */
 export function formatAppError(error) {
@@ -15,5 +17,4 @@ export function formatAppError(error) {
             return `Unhandled error code: ${String(exhaustive)}`;
         }
     }
-}
-//# sourceMappingURL=format-error.js.map
+}

package/dist/core/cli/global-options.js

@@ -6,5 +6,4 @@ import { z } from "zod";
  */
 export const globalCliCommanderOptionsSchema = z.object({
     color: z.boolean().optional(),
-});
-//# sourceMappingURL=global-options.js.map
+});

package/dist/core/cli/positional.js

@@ -5,5 +5,4 @@
  */
 export function readOptionalPositionalArg(candidate) {
     return typeof candidate === "string" ? candidate : undefined;
-}
-//# sourceMappingURL=positional.js.map
+}