@codefast/cli 0.8.0 → 0.9.0

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

@@ -0,0 +1,221 @@
+/** Pure transforms that slim a package's manifest and dist for publish. */
+/**
+ * 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"]);
+/**
+ * The script names npm and pnpm run on their own, on a consumer's install or on this package's publish.
+ */
+const LIFECYCLE_SCRIPT_STEMS = new Set([
+    "install",
+    "prepare",
+    "prepublish",
+    "prepublishOnly",
+    "pack",
+    "publish",
+]);
+/**
+ * The characters that make a `files` entry a glob rather than a path.
+ */
+const GLOB_CHARACTERS = /[*?[\]{}]/;
+/**
+ * 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;
+}
+/**
+ * Whether a script name is an install or publish lifecycle hook, with or without its `pre`/`post` prefix.
+ *
+ * @remarks Publish hooks stay because `pnpm publish` runs them right after pack-slim; install hooks stay because a
+ * consumer's package manager runs them.
+ *
+ * @since 0.9.0
+ */
+export function isLifecycleScript(name) {
+    if (LIFECYCLE_SCRIPT_STEMS.has(name)) {
+        return true;
+    }
+    const stem = name.replace(/^(?:pre|post)/, "");
+    return stem !== name && LIFECYCLE_SCRIPT_STEMS.has(stem);
+}
+/**
+ * Produces a publish manifest carrying only what a consumer's `tsc` and Node read.
+ *
+ * @remarks Operates on a structural clone, so the caller's manifest is left intact. A consumer never enables `source`
+ * and resolves `#/` through `types`/`default` to `dist`, so dropping the source lane, the `imports` left pointing
+ * outside `files`, the scripts that are not lifecycle hooks, and `devDependencies` 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 importsUnshippedRemoved = deleteUnshippedImports(draft);
+    const scriptsRemoved = deleteDevOnlyScripts(draft);
+    const devDependenciesRemoved = deleteDevDependencies(draft);
+    const changed = JSON.stringify(draft) !== JSON.stringify(manifest);
+    return {
+        manifest: draft,
+        report: {
+            filesSrcRemoved,
+            exportsSourceRemoved,
+            importsSourceRemoved,
+            importsUnshippedRemoved,
+            scriptsRemoved,
+            devDependenciesRemoved,
+            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; an `imports` entry this leaves empty is what the unshipped pass removes.
+function deleteSourceConditions(node) {
+    if (Array.isArray(node)) {
+        let removed = 0;
+        for (const item of node) {
+            removed += deleteSourceConditions(item);
+        }
+        return removed;
+    }
+    if (!isRecord(node)) {
+        return 0;
+    }
+    let removed = 0;
+    if ("source" in node) {
+        delete node.source;
+        removed += 1;
+    }
+    for (const key of Object.keys(node)) {
+        removed += deleteSourceConditions(node[key]);
+    }
+    return removed;
+}
+// Keeps an `imports` entry only while one of its targets lands inside a path `files` ships. `files` is read after the
+// `src` drop, so a lane still pointing at `./src/*` counts as unshipped; with no `files` at all npm ships everything.
+function deleteUnshippedImports(manifest) {
+    const imports = manifest.imports;
+    const files = manifest.files;
+    if (!isRecord(imports) || !Array.isArray(files)) {
+        return 0;
+    }
+    const shippedEntries = files.filter((entry) => typeof entry === "string");
+    let removed = 0;
+    for (const specifier of Object.keys(imports)) {
+        const targets = collectTargets(imports[specifier]);
+        if (targets.some((target) => isShippedTarget(target, shippedEntries))) {
+            continue;
+        }
+        delete imports[specifier];
+        removed += 1;
+    }
+    if (Object.keys(imports).length === 0) {
+        delete manifest.imports;
+    }
+    return removed;
+}
+function collectTargets(node, into = []) {
+    if (typeof node === "string") {
+        into.push(node);
+    }
+    else if (Array.isArray(node)) {
+        for (const item of node) {
+            collectTargets(item, into);
+        }
+    }
+    else if (isRecord(node)) {
+        for (const value of Object.values(node)) {
+            collectTargets(value, into);
+        }
+    }
+    return into;
+}
+// A glob entry is left to npm, so any target counts as shipped under it; a negated entry ships nothing.
+function isShippedTarget(target, shippedEntries) {
+    const relativeTarget = stripDotSlash(target);
+    return shippedEntries.some((entry) => {
+        if (entry.startsWith("!")) {
+            return false;
+        }
+        if (GLOB_CHARACTERS.test(entry)) {
+            return true;
+        }
+        const shipped = stripDotSlash(entry).replace(/\/+$/, "");
+        return relativeTarget === shipped || relativeTarget.startsWith(`${shipped}/`);
+    });
+}
+function stripDotSlash(filePath) {
+    return filePath.startsWith("./") ? filePath.slice(2) : filePath;
+}
+// Drops every script that is not a lifecycle hook, and the field itself once nothing is left in it.
+function deleteDevOnlyScripts(manifest) {
+    const scripts = manifest.scripts;
+    if (!isRecord(scripts)) {
+        return 0;
+    }
+    let removed = 0;
+    for (const name of Object.keys(scripts)) {
+        if (isLifecycleScript(name)) {
+            continue;
+        }
+        delete scripts[name];
+        removed += 1;
+    }
+    if (Object.keys(scripts).length === 0) {
+        delete manifest.scripts;
+    }
+    return removed;
+}
+function deleteDevDependencies(manifest) {
+    const devDependencies = manifest.devDependencies;
+    if (!isRecord(devDependencies)) {
+        return 0;
+    }
+    delete manifest.devDependencies;
+    return Object.keys(devDependencies).length;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

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,62 @@
+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 — slimming publish artifacts");
+    }
+    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.importsUnshippedRemoved > 0) {
+            parts.push(`imports:unshipped×${stats.importsUnshippedRemoved}`);
+        }
+        if (stats.scriptsRemoved > 0) {
+            parts.push(`scripts×${stats.scriptsRemoved}`);
+        }
+        if (stats.devDependenciesRemoved > 0) {
+            parts.push(`devDependencies×${stats.devDependenciesRemoved}`);
+        }
+        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,157 @@
+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";
+/**
+ * Slims every published package's manifest and build output for publish and returns the aggregate stats.
+ *
+ * @remarks Meant to run on an ephemeral CI checkout right before `changeset publish`: it rewrites `package.json` down to
+ * what a consumer reads, 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,
+        importsUnshippedRemoved: 0,
+        scriptsRemoved: 0,
+        devDependenciesRemoved: 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;
+        pkgStats.importsUnshippedRemoved = report.importsUnshippedRemoved;
+        pkgStats.scriptsRemoved = report.scriptsRemoved;
+        pkgStats.devDependenciesRemoved = report.devDependenciesRemoved;
+        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

@@ -10,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

@@ -11,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

@@ -67,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

@@ -101,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

@@ -28,5 +28,4 @@ export async function prepareTagSync(fs, args) {
         config: loadedOutcome.value.config,
         resolvedTargetPath,
     });
-}
-//# sourceMappingURL=prepare.js.map
+}

package/dist/tag/resolve-target-path.js

@@ -12,5 +12,4 @@ export function resolveProvidedTagTargetPath(fs, args) {
         ? path.resolve(args.rawTarget)
         : path.resolve(args.currentWorkingDirectory, args.rawTarget);
     return fs.canonicalPathSync(candidate);
-}
-//# sourceMappingURL=resolve-target-path.js.map
+}

package/dist/tag/since-writer.js

@@ -229,5 +229,4 @@ export class TagSinceWriter {
             replacement: `${indent}${this.makeSinceOnlyJSDocBlock(indent, version)}\n${indent}`,
         };
     }
-}
-//# sourceMappingURL=since-writer.js.map
+}

package/dist/tag/sync.js

@@ -164,5 +164,4 @@ async function runOnResolvedTarget(fs, resolvedTarget, write, listener) {
         listener?.onTargetCompleted(resolvedTarget, failedTargetRunResult);
         return failedTargetRunResult;
     }
-}
-//# sourceMappingURL=sync.js.map
+}

package/dist/tag/target-candidates.js

@@ -77,5 +77,4 @@ export async function resolveTagTargetCandidates(fs, rootDir, explicitTarget) {
         ];
     }
     return packageDirs.map((packageDir) => toPackageTargetCandidate(fs, rootDir, packageDir));
-}
-//# sourceMappingURL=target-candidates.js.map
+}

package/dist/tag/target-runner.js

@@ -23,5 +23,4 @@ export function runTagOnTarget(fs, targetPath, opts) {
         taggedDeclarations,
         fileResults,
     };
-}
-//# sourceMappingURL=target-runner.js.map
+}

package/dist/tag/version-resolver.js

@@ -10,5 +10,4 @@ export function resolveNearestPackageVersion(fs, targetPath) {
         throw new Error(`Unable to resolve a package version from target: ${targetPath}`);
     }
     return version;
-}
-//# sourceMappingURL=version-resolver.js.map
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codefast/cli",
-  "version": "0.8.0",
-  "description": "Developer CLI for the Codefast monorepo (arrange, audit, mirror, tag)",
+  "version": "0.9.0",
+  "description": "Developer CLI for the Codefast monorepo (arrange, audit, mirror, pack-slim, tag)",
   "keywords": [
     "cli",
     "codefast",
@@ -15,7 +15,7 @@
     "url": "https://github.com/codefastlabs/codefast/issues"
   },
   "license": "MIT",
-  "author": "Vuong Phan <mr.thevuong@gmail.com>",
+  "author": "Vuong Phan <mr.thevuong@gmail.com> (https://github.com/thevuong)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/codefastlabs/codefast.git",
@@ -26,27 +26,13 @@
   },
   "files": [
     "dist",
-    "LICENSE",
+    "CHANGELOG.md",
     "README.md",
-    "package.json"
+    "LICENSE"
   ],
   "type": "module",
   "imports": {
-    "#/tests/*": [
-      "./tests/*",
-      "./tests/*.ts",
-      "./tests/*.tsx",
-      "./tests/*/index.ts",
-      "./tests/*/index.tsx"
-    ],
     "#/*": {
-      "source": [
-        "./src/*",
-        "./src/*.ts",
-        "./src/*.tsx",
-        "./src/*/index.ts",
-        "./src/*/index.tsx"
-      ],
       "default": "./dist/*.js"
     }
   },
@@ -57,33 +43,12 @@
     "@microsoft/tsdoc": "^0.16.0",
     "commander": "^15.0.0",
     "jiti": "^2.7.0",
-    "oxc-parser": "^0.146.0",
-    "picomatch": "^4.0.5",
+    "oxc-parser": "^0.148.0",
+    "picomatch": "^4.0.7",
     "yaml": "^2.9.0",
-    "zod": "^4.4.3"
-  },
-  "devDependencies": {
-    "@types/node": "^26.2.0",
-    "@types/picomatch": "^4.0.3",
-    "@vitest/coverage-v8": "^4.1.11",
-    "typescript": "^7.0.2",
-    "vite": "^8.2.2",
-    "vitest": "^4.1.11",
-    "@codefast/typescript-config": "0.8.0"
+    "zod": "^4.5.4"
   },
   "engines": {
     "node": ">=24.0.0"
-  },
-  "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json",
-    "check-types": "tsc --noEmit",
-    "clean": "rm -rf dist",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "test:e2e": "vitest run tests/e2e",
-    "test:integration": "vitest run tests/integration",
-    "test:type": "vitest run tests/types",
-    "test:unit": "vitest run tests/unit",
-    "test:watch": "vitest"
   }
 }

package/dist/arrange/analyze.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyze.js","sourceRoot":"","sources":["../../src/arrange/analyze.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAElH,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,eAAe,CAAC;AAExC;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAAkB,EAAE,eAAuB;IAC1E,MAAM,MAAM,GAAG,wBAAwB,EAAE,CAAC;IAC1C,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,kBAAkB,CAAC,EAAE,EAAE,eAAe,CAAC,CAAC;QACtD,KAAK,MAAM,QAAQ,IAAI,KAAK,EAAE,CAAC;YAC7B,MAAM,UAAU,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YACrD,MAAM,QAAQ,GAAG,qBAAqB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;YAC7D,oCAAoC,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QAC/E,CAAC;QACD,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC;IACpB,CAAC;IAAC,OAAO,WAAoB,EAAE,CAAC;QAC9B,OAAO,GAAG,CAAC,IAAI,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;IACnF,CAAC;AACH,CAAC"}

package/dist/arrange/cli-schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-schema.js","sourceRoot":"","sources":["../../src/arrange/cli-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoCxB;;;;GAIG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAA8C,CAAC,CAAC,MAAM,CAAC;IACtG,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,6BAA6B,CAAC;CAClE,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAqC,CAAC,CAAC,MAAM,CAAC;IACpF,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE;IAClB,aAAa,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IACrC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC/B,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAA2C,CAAC,CAAC,MAAM,CAAC;IAChG,aAAa,EAAE,CAAC;SACb,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,EAAE,sFAAsF,CAAC;IACjG,gBAAgB,EAAE,CAAC,CAAC,OAAO,EAAE;IAC7B,iBAAiB,EAAE,CAAC,CAAC,OAAO,EAAE;CAC/B,CAAC,CAAC"}