@codefast/cli 0.10.0 → 0.12.0

package/dist/audit/{domain → rtl/domain}/audit-file.d.ts

@@ -1,4 +1,4 @@
-import type { RtlViolation } from "#/audit/domain/types";
+import type { RtlViolation } from "#audit/domain/types";
 /**
  * Detects physical-direction Tailwind classes that should be logical or rtl:-paired.
  *

package/dist/audit/{domain → rtl/domain}/audit-file.js

@@ -1,5 +1,5 @@
-import { DIRECTION_RESOLVED_VARIANT, PHYSICAL_SIDE_VARIANT, RTL_MAPPINGS, RTL_REVERSE_MAPPINGS, RTL_SWAP_MAPPINGS, RTL_TRANSLATE_X_MAPPINGS, SLIDE_PREFIXES, } from "#/audit/domain/mappings";
-import { collectTokens } from "#/audit/domain/tokenize";
+import { DIRECTION_RESOLVED_VARIANT, PHYSICAL_SIDE_VARIANT, RTL_MAPPINGS, RTL_REVERSE_MAPPINGS, RTL_SWAP_MAPPINGS, RTL_TRANSLATE_X_MAPPINGS, SLIDE_PREFIXES, } from "#audit/rtl/domain/mappings";
+import { collectTokens } from "#audit/rtl/domain/tokenize";
 /**
  * A token satisfies an "rtl companion" requirement when the same file has a
  * token whose variants include `rtl` and whose value matches. Variant order

package/dist/audit/{domain → rtl/domain}/tokenize.d.ts

@@ -1,4 +1,4 @@
-import type { RtlClassToken } from "#/audit/domain/types";
+import type { RtlClassToken } from "#audit/domain/types";
 /**
  * Splits a class token into [variant, value, modifier], colon/slash-aware of
  * brackets and parens (arbitrary values like data-[side=left] or calc(...)).

package/dist/audit/rtl/output.d.ts

@@ -0,0 +1,7 @@
+import type { RtlAuditResult } from "#audit/domain/types";
+/**
+ * Human-readable RTL audit report (matches the former packages/ui script shape).
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function presentRtlAuditResult(result: RtlAuditResult): void;

package/dist/audit/rtl/output.js

@@ -0,0 +1,21 @@
+import { logger } from "#core/logger";
+/**
+ * Human-readable RTL audit report (matches the former packages/ui script shape).
+ *
+ * @since 0.5.0-canary.6
+ */
+export function presentRtlAuditResult(result) {
+    for (const file of result.files) {
+        logger.out(`\n${file.relativePath}`);
+        for (const { line, raw, suggestion } of file.violations) {
+            logger.out(`  ${line}: ${raw} → ${suggestion}`);
+        }
+    }
+    const allowlistSuffix = result.allowlistedCount > 0 ? ` (${result.allowlistedCount} allowlisted)` : "";
+    if (result.violationCount > 0) {
+        logger.out(`\n✖ ${result.violationCount} RTL violation(s)${allowlistSuffix}`);
+    }
+    else {
+        logger.out(`✓ No physical-direction classes outside the allowlist${allowlistSuffix}`);
+    }
+}

package/dist/audit/rtl/prepare.d.ts

@@ -0,0 +1,13 @@
+import type { AuditCommandPrelude } from "#audit/prepare";
+import { AppError } from "#core/errors";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { Result } from "#core/result";
+/**
+ * Loads config and resolves the scan target for `audit rtl`.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function prepareRtlAudit(fs: Filesystem, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<AuditCommandPrelude, AppError>>;

package/dist/audit/rtl/prepare.js

@@ -0,0 +1,41 @@
+import { resolveRepoRelativePath } from "#audit/prepare";
+import { loadCodefastConfig } from "#core/config";
+import { AppError, messageFrom } from "#core/errors";
+import { err, ok } from "#core/result";
+import { resolveProjectRoot } from "#core/workspace/resolver";
+/**
+ * Loads config and resolves the scan target for `audit rtl`.
+ *
+ * @since 0.5.0-canary.6
+ */
+export async function prepareRtlAudit(fs, args) {
+    let rootDir;
+    try {
+        // Realpath so allowlist keys (`path.relative(rootDir, file)`) stay stable when cwd is a symlink.
+        rootDir = fs.canonicalPathSync(resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir);
+    }
+    catch (caughtError) {
+        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+    }
+    const loadedOutcome = await loadCodefastConfig(rootDir, fs);
+    if (!loadedOutcome.ok) {
+        return loadedOutcome;
+    }
+    const { config } = loadedOutcome.value;
+    const rtlConfig = config.audit?.rtl ?? {};
+    const targetFromCli = args.rawTarget;
+    const targetFromConfig = rtlConfig.target;
+    const resolvedTargetInput = targetFromCli ?? targetFromConfig;
+    if (resolvedTargetInput === undefined) {
+        return err(new AppError("VALIDATION_ERROR", "Missing scan target: pass a path argument or set audit.rtl.target in codefast.config"));
+    }
+    const targetPath = resolveRepoRelativePath(targetFromCli !== undefined ? args.currentWorkingDirectory : rootDir, resolvedTargetInput);
+    if (!fs.existsSync(targetPath)) {
+        return err(new AppError("NOT_FOUND", `Not found: ${targetPath}`));
+    }
+    return ok({
+        rootDir,
+        targetPath: fs.canonicalPathSync(targetPath),
+        allowlist: rtlConfig.allowlist ?? [],
+    });
+}

package/dist/audit/rtl/run.d.ts

@@ -0,0 +1,14 @@
+import type { RtlAuditResult } from "#audit/domain/types";
+import { AppError } from "#core/errors";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { Result } from "#core/result";
+/**
+ * Scans a target path for physical-direction Tailwind class violations.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function runRtlAudit(fs: Filesystem, args: {
+    readonly rootDir: string;
+    readonly targetPath: string;
+    readonly allowlist: ReadonlyArray<string>;
+}): Result<RtlAuditResult, AppError>;

package/dist/audit/{run.js → rtl/run.js}

@@ -1,8 +1,8 @@
 import path from "node:path";
-import { auditFileContent } from "#/audit/domain/audit-file";
-import { AppError, messageFrom } from "#/core/errors";
-import { err, ok } from "#/core/result";
-import { walkTsxFiles } from "#/core/workspace/typescript-walk";
+import { auditFileContent } from "#audit/rtl/domain/audit-file";
+import { AppError, messageFrom } from "#core/errors";
+import { err, ok } from "#core/result";
+import { walkTsxFiles } from "#core/workspace/typescript-walk";
 /**
  * Scans a target path for physical-direction Tailwind class violations.
  *

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
 import process from "node:process";
-import { runCli } from "#/cli";
+import { runCli } from "#cli";
 const code = await runCli(process.argv);
 process.exit(code);

package/dist/cli.js

@@ -3,11 +3,11 @@ import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 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";
+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 {
         const dir = path.dirname(fileURLToPath(import.meta.url));

package/dist/core/cli/command-pipeline.d.ts

@@ -0,0 +1,90 @@
+import type { Command } from "commander";
+import type { ZodType } from "zod";
+import type { GlobalCliOptions } from "#core/cli/global-options";
+import type { AppError } from "#core/errors";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { Result } from "#core/result";
+/**
+ * The options every command shares: the `--json` machine-output flag. Per-command option shapes extend this.
+ *
+ * @since 0.11.0
+ */
+export interface BaseCommandOptions {
+    readonly json?: boolean | undefined;
+}
+/**
+ * A pipeline's `prepare` slot: resolves the argv context (cwd, positional, global options) into the command's prelude.
+ *
+ * @since 0.11.0
+ */
+export type CommandPrepare<Prelude> = (fs: Filesystem, input: {
+    readonly currentWorkingDirectory: string;
+    readonly rawArg: string | undefined;
+    readonly globals: GlobalCliOptions;
+}) => Promise<Result<Prelude, AppError>>;
+/** The prelude and options a request is built from, before the run. */
+interface BuildInput<Prelude, Opts> {
+    readonly prelude: Prelude;
+    readonly opts: Opts;
+    readonly globals: GlobalCliOptions;
+}
+/** The run result and its surrounding context, for the report phase. */
+interface ReportInput<Prelude, RunResult, Presenter, Opts> {
+    readonly result: RunResult;
+    readonly prelude: Prelude;
+    readonly opts: Opts;
+    readonly presenter: Presenter | undefined;
+    readonly elapsedSeconds: number;
+}
+/**
+ * The invariant shape every workspace command and subcommand shares: resolve a prelude, build and
+ * validate a request, run it, then report to one of two audiences and record a single exit code.
+ *
+ * @remarks The optional slots carry the per-command variations — a working-tree guard and a streaming
+ * presenter — so the control flow itself is written once.
+ *
+ * @since 0.11.0
+ */
+export interface CommandPipeline<Prelude, Request, RunResult, Presenter = never, Opts extends BaseCommandOptions = BaseCommandOptions> {
+    readonly name?: string | undefined;
+    readonly description?: string | undefined;
+    readonly positional?: {
+        readonly name: string;
+        readonly help: string;
+    } | undefined;
+    readonly configureArgv?: ((command: Command) => void) | undefined;
+    readonly prepare: CommandPrepare<Prelude>;
+    readonly guard?: ((input: {
+        readonly prelude: Prelude;
+        readonly opts: Opts;
+    }) => Promise<Result<void, AppError>>) | undefined;
+    readonly schema: ZodType<Request>;
+    readonly buildRequest: (input: BuildInput<Prelude, Opts>) => unknown;
+    readonly createPresenter?: ((input: BuildInput<Prelude, Opts>) => Presenter) | undefined;
+    readonly run: (fs: Filesystem, request: Request, presenter: Presenter | undefined) => Promise<Result<RunResult, AppError>>;
+    readonly presentHuman?: ((input: ReportInput<Prelude, RunResult, Presenter, Opts>) => void) | undefined;
+    readonly formatJson: (input: ReportInput<Prelude, RunResult, Presenter, Opts>) => string;
+    readonly exitCode: (result: RunResult) => number;
+}
+/**
+ * A pipeline that names itself, so it can register as a subcommand under a parent command.
+ *
+ * @since 0.11.0
+ */
+export type NamedCommandPipeline<Prelude, Request, RunResult, Presenter = never, Opts extends BaseCommandOptions = BaseCommandOptions> = CommandPipeline<Prelude, Request, RunResult, Presenter, Opts> & {
+    readonly name: string;
+    readonly description: string;
+};
+/**
+ * Wires a pipeline onto a named Command: the shared positional, `--json`, any extra options, and the action.
+ *
+ * @since 0.11.0
+ */
+export declare function applyCommandPipeline<Prelude, Request, RunResult, Presenter, Opts extends BaseCommandOptions>(command: Command, fs: Filesystem, pipeline: CommandPipeline<Prelude, Request, RunResult, Presenter, Opts>): Command;
+/**
+ * Registers a pipeline as a subcommand under `parent`, taking its name and description from the pipeline.
+ *
+ * @since 0.11.0
+ */
+export declare function registerPipelineSubcommand<Prelude, Request, RunResult, Presenter, Opts extends BaseCommandOptions>(parent: Command, fs: Filesystem, pipeline: NamedCommandPipeline<Prelude, Request, RunResult, Presenter, Opts>): void;
+export {};

package/dist/core/cli/command-pipeline.js

@@ -0,0 +1,83 @@
+import process from "node:process";
+import { globalCliCommanderOptionsSchema } from "#core/cli/global-options";
+import { readOptionalPositionalArg } from "#core/cli/positional";
+import { consumeCliAppError } from "#core/cli/result-handle";
+import { logger } from "#core/logger";
+import { parseWithSchema } from "#core/schema-parse";
+const DEFAULT_JSON_HELP = "Print one JSON object on stdout instead of the human-readable output";
+function readGlobalOptions(command) {
+    return (command.optsWithGlobals?.() ?? command.opts());
+}
+function makeAction(fs, pipeline) {
+    return async (rawArg, opts, command) => {
+        const globalsOutcome = parseWithSchema(globalCliCommanderOptionsSchema, readGlobalOptions(command));
+        if (!consumeCliAppError(globalsOutcome)) {
+            return;
+        }
+        const globals = globalsOutcome.value;
+        const prelude = await pipeline.prepare(fs, {
+            currentWorkingDirectory: process.cwd(),
+            rawArg: readOptionalPositionalArg(rawArg),
+            globals,
+        });
+        if (!consumeCliAppError(prelude)) {
+            return;
+        }
+        if (pipeline.guard) {
+            const guarded = await pipeline.guard({ prelude: prelude.value, opts });
+            if (!consumeCliAppError(guarded)) {
+                return;
+            }
+        }
+        const parsed = parseWithSchema(pipeline.schema, pipeline.buildRequest({ prelude: prelude.value, opts, globals }));
+        if (!consumeCliAppError(parsed)) {
+            return;
+        }
+        const json = !!opts.json;
+        const presenter = !json && pipeline.createPresenter
+            ? pipeline.createPresenter({ prelude: prelude.value, opts, globals })
+            : undefined;
+        const startedAt = performance.now();
+        const outcome = await pipeline.run(fs, parsed.value, presenter);
+        if (!consumeCliAppError(outcome)) {
+            return;
+        }
+        const elapsedSeconds = (performance.now() - startedAt) / 1000;
+        const report = {
+            result: outcome.value,
+            prelude: prelude.value,
+            opts,
+            presenter,
+            elapsedSeconds,
+        };
+        if (json) {
+            logger.out(pipeline.formatJson(report));
+        }
+        else {
+            pipeline.presentHuman?.(report);
+        }
+        process.exitCode = pipeline.exitCode(outcome.value);
+    };
+}
+/**
+ * Wires a pipeline onto a named Command: the shared positional, `--json`, any extra options, and the action.
+ *
+ * @since 0.11.0
+ */
+export function applyCommandPipeline(command, fs, pipeline) {
+    if (pipeline.positional) {
+        command.argument(pipeline.positional.name, pipeline.positional.help);
+    }
+    command.option("--json", DEFAULT_JSON_HELP, false);
+    pipeline.configureArgv?.(command);
+    command.action(makeAction(fs, pipeline));
+    return command;
+}
+/**
+ * Registers a pipeline as a subcommand under `parent`, taking its name and description from the pipeline.
+ *
+ * @since 0.11.0
+ */
+export function registerPipelineSubcommand(parent, fs, pipeline) {
+    applyCommandPipeline(parent.command(pipeline.name).description(pipeline.description), fs, pipeline);
+}

package/dist/core/cli/format-error.d.ts

@@ -1,4 +1,4 @@
-import type { AppError } from "#/core/errors";
+import type { AppError } from "#core/errors";
 /**
  * Formats an `AppError` as a `[CODE] message` line for CLI output.
  *

package/dist/core/cli/global-options.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
  * The validated global CLI options shared by every subcommand.
  *

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

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
  * Commander global opts shape validated before mirror prelude (`color` from `--no-color`).
  *

package/dist/core/cli/resolve-root.d.ts

@@ -0,0 +1,9 @@
+import { AppError } from "#core/errors";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { Result } from "#core/result";
+/**
+ * Resolves the project root as a `Result`, mapping a resolution failure to an `INFRA_FAILURE` error.
+ *
+ * @since 0.11.0
+ */
+export declare function resolveProjectRootResult(fs: Filesystem, currentWorkingDirectory: string): Result<string, AppError>;

package/dist/core/cli/resolve-root.js

@@ -0,0 +1,16 @@
+import { AppError, messageFrom } from "#core/errors";
+import { err, ok } from "#core/result";
+import { resolveProjectRoot } from "#core/workspace/resolver";
+/**
+ * Resolves the project root as a `Result`, mapping a resolution failure to an `INFRA_FAILURE` error.
+ *
+ * @since 0.11.0
+ */
+export function resolveProjectRootResult(fs, currentWorkingDirectory) {
+    try {
+        return ok(resolveProjectRoot(currentWorkingDirectory, fs).rootDir);
+    }
+    catch (caughtError) {
+        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+    }
+}

package/dist/core/cli/result-handle.d.ts

@@ -1,5 +1,5 @@
-import type { AppError } from "#/core/errors";
-import type { Result } from "#/core/result";
+import type { AppError } from "#core/errors";
+import type { Result } from "#core/result";
 /**
  * Narrows a `Result`, reporting a failure and setting the exit code, or logging an optional success message.
  *
@@ -10,10 +10,4 @@ export declare function consumeCliAppError<Value>(outcome: Result<Value, AppErro
 }): outcome is {
     readonly ok: true;
     readonly value: Value;
-};
-/**
- * Awaits a `Result`, hands a success to `onSuccess`, and records the returned exit code on the process.
- *
- * @since 0.3.16-canary.0
- */
-export declare function runCliResultAsync<Value>(outcomePromise: Promise<Result<Value, AppError>>, onSuccess: (value: Value) => number | void | Promise<number | void>): Promise<void>;
+};

package/dist/core/cli/result-handle.js

@@ -1,8 +1,8 @@
 import process from "node:process";
-import { formatAppError } from "#/core/cli/format-error";
-import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_USAGE } from "#/core/exit-codes";
-import { logger } from "#/core/logger";
-import { isVerboseCliDiagnostics } from "#/core/verbose-diagnostics";
+import { formatAppError } from "#core/cli/format-error";
+import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_USAGE } from "#core/exit-codes";
+import { logger } from "#core/logger";
+import { isVerboseCliDiagnostics } from "#core/verbose-diagnostics";
 function exitCodeForAppError(error) {
     switch (error.code) {
         case "NOT_FOUND":
@@ -38,17 +38,4 @@ export function consumeCliAppError(outcome, options) {
         logger.out(options.successMessage);
     }
     return true;
-}
-/**
- * Awaits a `Result`, hands a success to `onSuccess`, and records the returned exit code on the process.
- *
- * @since 0.3.16-canary.0
- */
-export async function runCliResultAsync(outcomePromise, onSuccess) {
-    const outcome = await outcomePromise;
-    if (!consumeCliAppError(outcome)) {
-        return;
-    }
-    const exit = await onSuccess(outcome.value);
-    process.exitCode = exit === undefined ? 0 : exit;
 }

package/dist/core/config/define-config.d.ts

@@ -1,4 +1,4 @@
-import type { CodefastConfig } from "#/core/config/schema";
+import type { CodefastConfig } from "#core/config/schema";
 /**
  * Types a `codefast.config.*` object for editor autocomplete and type-checking; returns it unchanged.
  *

package/dist/core/config/loader.d.ts

@@ -1,5 +1,5 @@
-import type { CodefastConfig } from "#/core/config/schema";
-import type { FilesystemPort } from "#/core/filesystem/port";
+import type { CodefastConfig } from "#core/config/schema";
+import type { Filesystem } from "#core/filesystem/filesystem";
 /**
  * A loaded config together with its schema warnings and the path it was read from.
  *
@@ -15,4 +15,4 @@ export type LoadConfigPayload = {
  *
  * @since 0.3.16-canary.0
  */
-export declare function loadConfigPayload(startDir: string, fs: FilesystemPort): Promise<LoadConfigPayload>;
+export declare function loadConfigPayload(startDir: string, fs: Filesystem): Promise<LoadConfigPayload>;

package/dist/core/config/loader.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import jiti from "jiti";
-import { codefastConfigRootSchema } from "#/core/config/schema";
-import { ancestorDirectories } from "#/core/workspace/ancestor-directories";
+import { codefastConfigRootSchema } from "#core/config/schema";
+import { ancestorDirectories } from "#core/workspace/ancestor-directories";
 function formatZodError(error, filePath) {
     const formatted = error.issues
         .map((issue) => {

package/dist/core/config/schema.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
  * A config hook invoked with the written file paths after a command rewrites files.
  *

package/dist/core/config/schema.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 const afterWriteHookSchema = z.custom((value) => typeof value === "function", {
     message: "Expected a function",
 });

package/dist/core/config/warnings.js

@@ -1,4 +1,4 @@
-import { logger } from "#/core/logger";
+import { logger } from "#core/logger";
 const yellowAnsi = "\x1b[33m";
 const resetAnsi = "\x1b[0m";
 /**

package/dist/core/config.d.ts

@@ -1,12 +1,12 @@
-import type { CodefastConfig } from "#/core/config/schema";
-import { AppError } from "#/core/errors";
-import type { FilesystemPort } from "#/core/filesystem/port";
-import type { Result } from "#/core/result";
+import type { CodefastConfig } from "#core/config/schema";
+import { AppError } from "#core/errors";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { Result } from "#core/result";
 /**
  * Loads the `codefast.config.js` for a workspace root, reporting schema warnings along the way.
  *
  * @since 0.3.16-canary.0
  */
-export declare function loadCodefastConfig(rootDir: string, fs: FilesystemPort): Promise<Result<{
+export declare function loadCodefastConfig(rootDir: string, fs: Filesystem): Promise<Result<{
     config: CodefastConfig;
 }, AppError>>;

package/dist/core/config.js

@@ -1,7 +1,7 @@
-import { loadConfigPayload } from "#/core/config/loader";
-import { reportSchemaWarnings } from "#/core/config/warnings";
-import { AppError, messageFrom } from "#/core/errors";
-import { err, ok } from "#/core/result";
+import { loadConfigPayload } from "#core/config/loader";
+import { reportSchemaWarnings } from "#core/config/warnings";
+import { AppError, messageFrom } from "#core/errors";
+import { err, ok } from "#core/result";
 /**
  * Loads the `codefast.config.js` for a workspace root, reporting schema warnings along the way.
  *

package/dist/core/filesystem/{port.d.ts → filesystem.d.ts}

@@ -20,7 +20,7 @@ export interface DirectoryEntry {
  *
  * @since 0.3.16-canary.0
  */
-export interface FilesystemPort {
+export interface Filesystem {
     existsSync(filePath: string): boolean;
     canonicalPathSync(inputPath: string): string;
     statSync(filePath: string): {

package/dist/core/filesystem/node.d.ts

@@ -1,7 +1,7 @@
-import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Filesystem } from "#core/filesystem/filesystem";
 /**
- * The `FilesystemPort` implementation backed by Node's real filesystem.
+ * The `Filesystem` implementation backed by Node's real filesystem.
  *
  * @since 0.3.16-canary.0
  */
-export declare const nodeFilesystem: FilesystemPort;
+export declare const nodeFilesystem: Filesystem;

package/dist/core/filesystem/node.js

@@ -2,7 +2,7 @@ import fsSync from "node:fs";
 import fsPromises from "node:fs/promises";
 import path from "node:path";
 /**
- * The `FilesystemPort` implementation backed by Node's real filesystem.
+ * The `Filesystem` implementation backed by Node's real filesystem.
  *
  * @since 0.3.16-canary.0
  */

package/dist/core/schema-parse.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType } from "zod";
-import { AppError } from "#/core/errors";
-import type { Result } from "#/core/result";
+import { AppError } from "#core/errors";
+import type { Result } from "#core/result";
 /**
  * Parses an input against a Zod schema and returns a `Result` with the value or a validation `AppError`.
  *

package/dist/core/schema-parse.js

@@ -1,5 +1,5 @@
-import { AppError } from "#/core/errors";
-import { err, ok } from "#/core/result";
+import { AppError } from "#core/errors";
+import { err, ok } from "#core/result";
 function formatSchemaIssues(issues) {
     return issues
         .map((issue) => {

package/dist/core/source-text-edit.d.ts

@@ -24,6 +24,20 @@ export declare function textPrefixFromLineStartToPosition(source: string, pos: n
  * @since 0.3.16-canary.0
  */
 export declare function endAfterOptionalCommaFollowingInSource(source: string, tokenEnd: number): number;
+/**
+ * Returns the edits with every overlap removed, keeping the outermost of any overlapping pair.
+ *
+ * @remarks A planned edit replaces a whole AST node, so two ranges either nest or are disjoint and
+ * the outer replacement already contains the inner span verbatim — dropping the nested edit keeps
+ * the output valid. Higher-priority edits must come first so an exact-range tie keeps the earlier
+ * one. This is the invariant `applyEditsDescending` assumes; run it before applying.
+ *
+ * @since 0.11.0
+ */
+export declare function dropOverlappingEdits<Edit extends {
+    start: number;
+    end: number;
+}>(edits: ReadonlyArray<Edit>): Array<Edit>;
 /**
  * Applies non-overlapping text edits from the highest offset down and returns the edited source.
  *

package/dist/core/source-text-edit.js

@@ -54,6 +54,28 @@ export function endAfterOptionalCommaFollowingInSource(source, tokenEnd) {
     }
     return tokenEnd;
 }
+/**
+ * Returns the edits with every overlap removed, keeping the outermost of any overlapping pair.
+ *
+ * @remarks A planned edit replaces a whole AST node, so two ranges either nest or are disjoint and
+ * the outer replacement already contains the inner span verbatim — dropping the nested edit keeps
+ * the output valid. Higher-priority edits must come first so an exact-range tie keeps the earlier
+ * one. This is the invariant `applyEditsDescending` assumes; run it before applying.
+ *
+ * @since 0.11.0
+ */
+export function dropOverlappingEdits(edits) {
+    const ordered = [...edits].toSorted((editA, editB) => editA.start - editB.start || editB.end - editA.end);
+    const kept = [];
+    let lastEnd = -1;
+    for (const edit of ordered) {
+        if (edit.start >= lastEnd) {
+            kept.push(edit);
+            lastEnd = edit.end;
+        }
+    }
+    return kept;
+}
 /**
  * Applies non-overlapping text edits from the highest offset down and returns the edited source.
  *

package/dist/core/workspace/markdown-walk.d.ts

@@ -1,7 +1,7 @@
-import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Filesystem } from "#core/filesystem/filesystem";
 /**
  * Every markdown file under a root, skipping build output and vendored trees.
  *
  * @since 0.5.0
  */
-export declare function walkMarkdownFiles(rootDirectoryPath: string, fs: FilesystemPort): Array<string>;
+export declare function walkMarkdownFiles(rootDirectoryPath: string, fs: Filesystem): Array<string>;