@codefast/cli 0.12.0 → 0.13.0

package/dist/audit/publish/cli-result.d.ts

@@ -1,6 +1,6 @@
 import type { PublishAuditResult } from "#audit/domain/types";
 /**
- * Exit `1` when any `#/` import or unshipped publish target remains.
+ * Exit `1` when any `#/` import, unshipped publish target, or unreachable stylesheet source remains.
  *
  * @since 0.12.0
  */

package/dist/audit/publish/cli-result.js

@@ -1,11 +1,11 @@
 import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#core/exit-codes";
 /**
- * Exit `1` when any `#/` import or unshipped publish target remains.
+ * Exit `1` when any `#/` import, unshipped publish target, or unreachable stylesheet source remains.
  *
  * @since 0.12.0
  */
 export function exitCodeForPublishAuditResult(result) {
-    return result.legacyImportCount > 0 || result.unshipped.length > 0 ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+    return isCleanPublishAudit(result) ? CLI_EXIT_SUCCESS : CLI_EXIT_GENERAL_ERROR;
 }
 /**
  * Machine-readable publish audit summary for `--json`.
@@ -15,8 +15,11 @@ export function exitCodeForPublishAuditResult(result) {
 export function formatPublishAuditJsonOutput(result, rootDir) {
     return JSON.stringify({
         schemaVersion: 1,
-        ok: result.legacyImportCount === 0 && result.unshipped.length === 0,
+        ok: isCleanPublishAudit(result),
         cwd: rootDir,
         result,
     });
+}
+function isCleanPublishAudit(result) {
+    return result.legacyImportCount === 0 && result.unshipped.length === 0 && result.unreachableStylesheets.length === 0;
 }

package/dist/audit/publish/domain/stylesheet-sources.d.ts

@@ -0,0 +1,22 @@
+/** Reads the paths a stylesheet registers with Tailwind's `@source` and checks them against a shipped file list. */
+import type { StylesheetSource } from "#audit/domain/types";
+/**
+ * Every path a stylesheet registers with `@source`, with the line it sits on.
+ *
+ * @since 0.13.0
+ */
+export declare function scanStylesheetSources(content: string): Array<StylesheetSource>;
+/**
+ * Whether a stylesheet's `@source` paths all miss the files its package ships.
+ *
+ * @remarks Paths are package-relative and POSIX. A path that leaves the package names another package's files, which
+ * this tarball cannot vouch for, so it is not judged. One reachable path is enough: a workspace-only lane beside the
+ * published one is expected.
+ *
+ * @param stylesheetPath - The stylesheet, relative to its package root.
+ * @param sources - What {@link scanStylesheetSources} found in it.
+ * @param shippedFiles - Every file the package's tarball ships, relative to the package root.
+ *
+ * @since 0.13.0
+ */
+export declare function missesShippedFiles(stylesheetPath: string, sources: ReadonlyArray<StylesheetSource>, shippedFiles: ReadonlyArray<string>): boolean;

package/dist/audit/publish/domain/stylesheet-sources.js

@@ -0,0 +1,64 @@
+/** Reads the paths a stylesheet registers with Tailwind's `@source` and checks them against a shipped file list. */
+import path from "node:path";
+import { createAnyGlobMatcher } from "#core/glob";
+import { lineOfOffset } from "#core/source-position";
+// A plain `@source "<path>";` — `@source not …` excludes paths and `@source inline(…)` names classes, so neither
+// registers files.
+const SOURCE_DIRECTIVE = /@source\s+(["'])([^"']+)\1\s*;/g;
+// A string or a comment. Strings match first, so the `/**/` of a quoted glob is never read as a comment.
+const STRING_OR_COMMENT = /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')|\/\*[\s\S]*?\*\//g;
+const GLOB_CHARACTERS = /[*?[\]{}]/;
+/**
+ * Every path a stylesheet registers with `@source`, with the line it sits on.
+ *
+ * @since 0.13.0
+ */
+export function scanStylesheetSources(content) {
+    // Blanking comments keeps every offset in place, so a commented-out directive drops out and lines still count.
+    const code = content.replaceAll(STRING_OR_COMMENT, (match, quoted) => quoted ?? match.replaceAll(/[^\n]/g, " "));
+    const found = [];
+    for (const match of code.matchAll(SOURCE_DIRECTIVE)) {
+        const pattern = match[2];
+        if (pattern !== undefined) {
+            found.push({ line: lineOfOffset(code, match.index), pattern });
+        }
+    }
+    return found;
+}
+/**
+ * Whether a stylesheet's `@source` paths all miss the files its package ships.
+ *
+ * @remarks Paths are package-relative and POSIX. A path that leaves the package names another package's files, which
+ * this tarball cannot vouch for, so it is not judged. One reachable path is enough: a workspace-only lane beside the
+ * published one is expected.
+ *
+ * @param stylesheetPath - The stylesheet, relative to its package root.
+ * @param sources - What {@link scanStylesheetSources} found in it.
+ * @param shippedFiles - Every file the package's tarball ships, relative to the package root.
+ *
+ * @since 0.13.0
+ */
+export function missesShippedFiles(stylesheetPath, sources, shippedFiles) {
+    const patterns = sources.flatMap((source) => packagePatternsFor(stylesheetPath, source.pattern));
+    if (patterns.length === 0) {
+        return false;
+    }
+    const isReached = createAnyGlobMatcher(patterns, { dot: true });
+    return !shippedFiles.some(isReached);
+}
+// Tailwind resolves a `@source` path against the stylesheet's directory; a path without a glob is a file or a
+// directory, and a directory registers everything beneath it.
+function packagePatternsFor(stylesheetPath, pattern) {
+    if (path.posix.isAbsolute(pattern)) {
+        return [];
+    }
+    const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(stylesheetPath), pattern));
+    if (resolved === ".." || resolved.startsWith("../")) {
+        return [];
+    }
+    if (GLOB_CHARACTERS.test(resolved)) {
+        return [resolved];
+    }
+    const withoutTrailingSlash = resolved.replace(/\/+$/, "");
+    return withoutTrailingSlash === "." ? ["**"] : [withoutTrailingSlash, `${withoutTrailingSlash}/**`];
+}

package/dist/audit/publish/output.js

@@ -14,11 +14,20 @@ export function presentPublishAuditResult(result) {
     for (const { packageName, field, subpath, target } of result.unshipped) {
         logger.out(`\n${packageName}: ${field}["${subpath}"] → ${target} is not shipped by "files"`);
     }
-    const problems = result.legacyImportCount + result.unshipped.length;
+    for (const { packageName, stylesheet, sources, missingFilesEntries } of result.unreachableStylesheets) {
+        logger.out(`\n${packageName}: ${stylesheet} registers no file the tarball ships`);
+        for (const { line, pattern } of sources) {
+            logger.out(`  ${line}: @source "${pattern}"`);
+        }
+        if (missingFilesEntries.length > 0) {
+            logger.out(`  not on disk: ${missingFilesEntries.join(", ")} — build the package first`);
+        }
+    }
+    const problems = result.legacyImportCount + result.unshipped.length + result.unreachableStylesheets.length;
     if (problems > 0) {
-        logger.out(`\n✖ ${result.legacyImportCount} legacy "#/" import(s), ${result.unshipped.length} unshipped target(s)`);
+        logger.out(`\n✖ ${result.legacyImportCount} legacy "#/" import(s), ${result.unshipped.length} unshipped target(s), ${result.unreachableStylesheets.length} stylesheet(s) registering nothing shipped`);
     }
     else {
-        logger.out(`✓ No "#/" imports across ${result.scannedFileCount} file(s); every publish target ships across ${result.packageCount} package(s)`);
+        logger.out(`✓ No "#/" imports across ${result.scannedFileCount} file(s); every publish target and stylesheet source ships across ${result.packageCount} package(s)`);
     }
 }

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

@@ -4,7 +4,8 @@ import type { Filesystem } from "#core/filesystem/filesystem";
 import type { Result } from "#core/result";
 /**
  * Reports what would break a consumer's install: a `#/`-prefixed import Node's ESM resolver rejects on
- * the floor, and an `exports`/`imports` target the slimmed publish manifest does not ship.
+ * the floor, an `exports`/`imports` target the slimmed publish manifest does not ship, and a shipped
+ * stylesheet whose `@source` paths reach none of the files that do ship.
  *
  * @since 0.12.0
  */

package/dist/audit/publish/run.js

@@ -1,5 +1,7 @@
 import path from "node:path";
 import { scanLegacySubpathImports } from "#audit/publish/domain/legacy-subpath";
+import { missesShippedFiles, scanStylesheetSources } from "#audit/publish/domain/stylesheet-sources";
+import { listShippedFiles } from "#audit/publish/shipped-files";
 import { AppError, messageFrom } from "#core/errors";
 import { err, ok } from "#core/result";
 import { listWorkspacePackageDirectories } from "#core/workspace/resolver";
@@ -8,7 +10,8 @@ import { packageJsonFileName } from "#core/workspace/well-known-files";
 import { unshippedPublishTargets } from "#pack-slim/domain/transform";
 /**
  * Reports what would break a consumer's install: a `#/`-prefixed import Node's ESM resolver rejects on
- * the floor, and an `exports`/`imports` target the slimmed publish manifest does not ship.
+ * the floor, an `exports`/`imports` target the slimmed publish manifest does not ship, and a shipped
+ * stylesheet whose `@source` paths reach none of the files that do ship.
  *
  * @since 0.12.0
  */
@@ -29,6 +32,7 @@ export async function runPublishAudit(fs, args) {
         }
         const layout = await listWorkspacePackageDirectories(rootDir, fs, true);
         const unshipped = [];
+        const unreachableStylesheets = [];
         let packageCount = 0;
         for (const packageDir of layout.packageDirectoryPathsAbsolute) {
             const manifestPath = path.join(packageDir, packageJsonFileName);
@@ -44,10 +48,14 @@ export async function runPublishAudit(fs, args) {
             for (const target of unshippedPublishTargets(manifest)) {
                 unshipped.push({ packageName, field: target.field, subpath: target.subpath, target: target.target });
             }
+            for (const violation of unreachableStylesheetsOf(fs, { rootDir, packageDir, manifest })) {
+                unreachableStylesheets.push({ packageName, ...violation });
+            }
         }
         return ok({
             legacyImportFiles,
             unshipped,
+            unreachableStylesheets,
             legacyImportCount,
             scannedFileCount: sourceFiles.length,
             packageCount,
@@ -57,6 +65,27 @@ export async function runPublishAudit(fs, args) {
         return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
     }
 }
+// The shipped stylesheets whose `@source` paths register nothing the tarball ships — what a consumer's Tailwind scans.
+function unreachableStylesheetsOf(fs, args) {
+    const { rootDir, packageDir, manifest } = args;
+    const shipped = listShippedFiles(fs, packageDir, manifest);
+    if (shipped === null) {
+        return [];
+    }
+    const violations = [];
+    for (const stylesheet of shipped.files.filter((file) => file.endsWith(".css"))) {
+        const stylesheetPath = path.join(packageDir, stylesheet);
+        const sources = scanStylesheetSources(fs.readFileSync(stylesheetPath, "utf8"));
+        if (sources.length > 0 && missesShippedFiles(stylesheet, sources, shipped.files)) {
+            violations.push({
+                stylesheet: toPosixPath(path.relative(rootDir, stylesheetPath)),
+                sources,
+                missingFilesEntries: shipped.missingEntries,
+            });
+        }
+    }
+    return violations;
+}
 function toPosixPath(filePath) {
     return filePath.split(path.sep).join("/");
 }

package/dist/audit/publish/shipped-files.d.ts

@@ -0,0 +1,21 @@
+/** Lists the files a package's slimmed tarball ships, read from disk. */
+import type { Filesystem } from "#core/filesystem/filesystem";
+/**
+ * What a package's tarball ships, plus the `files` entries that match nothing on disk.
+ *
+ * @since 0.13.0
+ */
+export interface ShippedFiles {
+    /** Package-relative POSIX paths, sorted. */
+    readonly files: Array<string>;
+    readonly missingEntries: Array<string>;
+}
+/**
+ * Lists the files a package ships once the publish step has slimmed it, or `null` with no `files` field to go by.
+ *
+ * @remarks Applies the same slim as `pack-slim`, so a subtree it drops is absent here too, and leaves out source maps,
+ * which the publish step deletes. Without a `files` field npm ships the whole directory, which leaves nothing to judge.
+ *
+ * @since 0.13.0
+ */
+export declare function listShippedFiles(fs: Filesystem, packageDir: string, manifest: Record<string, unknown>): ShippedFiles | null;

package/dist/audit/publish/shipped-files.js

@@ -0,0 +1,36 @@
+/** Lists the files a package's slimmed tarball ships, read from disk. */
+import path from "node:path";
+import { isSourceMapFile, slimPublishManifest } from "#pack-slim/domain/transform";
+/**
+ * Lists the files a package ships once the publish step has slimmed it, or `null` with no `files` field to go by.
+ *
+ * @remarks Applies the same slim as `pack-slim`, so a subtree it drops is absent here too, and leaves out source maps,
+ * which the publish step deletes. Without a `files` field npm ships the whole directory, which leaves nothing to judge.
+ *
+ * @since 0.13.0
+ */
+export function listShippedFiles(fs, packageDir, manifest) {
+    const { manifest: slimmed } = slimPublishManifest(manifest);
+    if (!Array.isArray(slimmed.files)) {
+        return null;
+    }
+    const files = new Set();
+    const missingEntries = [];
+    for (const entry of slimmed.files) {
+        if (typeof entry !== "string" || entry.startsWith("!")) {
+            continue;
+        }
+        // An entry names a file, a directory whose whole subtree ships, or a glob.
+        const matches = [...fs.globSync(entry, { cwd: packageDir }), ...fs.globSync(`${entry}/**`, { cwd: packageDir })];
+        if (matches.length === 0) {
+            missingEntries.push(entry);
+            continue;
+        }
+        for (const match of matches) {
+            if (fs.statSync(path.join(packageDir, match)).isFile()) {
+                files.add(match.split(path.sep).join("/"));
+            }
+        }
+    }
+    return { files: [...files].filter((file) => !isSourceMapFile(file)).sort(), missingEntries };
+}

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

@@ -71,7 +71,12 @@ interface CodefastAuditConfig {
     links?: CodefastAuditAllowlistConfig | undefined;
     comments?: CodefastAuditAllowlistConfig | undefined;
     imports?: CodefastAuditAllowlistConfig | undefined;
+    assertions?: CodefastAuditAllowlistConfig | undefined;
     displayNames?: CodefastAuditAllowlistConfig | undefined;
+    constants?: {
+        target?: string | undefined;
+        allowlist?: Array<string> | undefined;
+    } | undefined;
 }
 /**
  * The validated root `codefast.config` shape.

package/dist/core/config/schema.js

@@ -58,7 +58,9 @@ const codefastAuditConfigSchema = z
     links: codefastAuditAllowlistConfigSchema.optional(),
     comments: codefastAuditAllowlistConfigSchema.optional(),
     imports: codefastAuditAllowlistConfigSchema.optional(),
+    assertions: codefastAuditAllowlistConfigSchema.optional(),
     displayNames: codefastAuditAllowlistConfigSchema.optional(),
+    constants: codefastAuditRtlConfigSchema.optional(),
 })
     .strict();
 /**

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

@@ -32,10 +32,9 @@ export interface Filesystem {
     readdirSync(filePath: string): Array<string>;
     readFile(filePath: string, encoding: CliFileEncoding): Promise<string>;
     writeFile(filePath: string, data: string, encoding: CliFileEncoding): Promise<void>;
-    readdir(filePath: string, options?: {
-        recursive?: boolean;
-        withFileTypes?: boolean;
-    }): Promise<Array<string> | Array<DirectoryEntry>>;
+    readdirEntries(filePath: string, options?: {
+        readonly recursive?: boolean | undefined;
+    }): Promise<Array<DirectoryEntry>>;
     globSync(pattern: string, options: {
         readonly cwd: string;
     }): Array<string>;

package/dist/core/filesystem/node.js

@@ -22,13 +22,7 @@ export const nodeFilesystem = {
     },
     readFile: (filePath, enc) => fsPromises.readFile(filePath, enc),
     writeFile: (filePath, data, enc) => fsPromises.writeFile(filePath, data, enc),
-    readdir: async (filePath, opts) => {
-        const raw = await fsPromises.readdir(filePath, opts);
-        if (!opts?.withFileTypes) {
-            return raw;
-        }
-        return raw;
-    },
+    readdirEntries: (filePath, options) => fsPromises.readdir(filePath, { recursive: options?.recursive ?? false, withFileTypes: true }),
     globSync: (pattern, options) => fsSync.globSync(pattern, options),
     rename: (oldPath, newPath) => fsPromises.rename(oldPath, newPath),
     unlink: (filePath) => fsPromises.unlink(filePath),

package/dist/core/oxc-node.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The structural view every module that walks `oxc-parser`'s ESTree output reads nodes through.
+ */
+/**
+ * An oxc ESTree node: a `type` discriminant, UTF-16 `start`/`end` offsets, and fields read by name.
+ *
+ * @remarks Structural on purpose: the walkers match node shapes by `type` and read the few fields
+ * they need, so the parser's full node union never has to be spelled out.
+ *
+ * @since 0.13.0
+ */
+export interface OxcNode {
+    readonly type: string;
+    readonly start: number;
+    readonly end: number;
+    readonly [key: string]: unknown;
+}
+/**
+ * Returns whether a value is an ESTree node rather than a scalar, a list or a location record.
+ *
+ * @since 0.13.0
+ */
+export declare function isOxcNode(value: unknown): value is OxcNode;
+/**
+ * Returns a parsed program's top-level statements.
+ *
+ * @remarks Takes `parseSync(...).program` as it comes, so no caller asserts the parser's type onto
+ * the structural view.
+ *
+ * @since 0.13.0
+ */
+export declare function programStatements(program: unknown): ReadonlyArray<OxcNode>;

package/dist/core/oxc-node.js

@@ -0,0 +1,25 @@
+/**
+ * The structural view every module that walks `oxc-parser`'s ESTree output reads nodes through.
+ */
+/**
+ * Returns whether a value is an ESTree node rather than a scalar, a list or a location record.
+ *
+ * @since 0.13.0
+ */
+export function isOxcNode(value) {
+    return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+/**
+ * Returns a parsed program's top-level statements.
+ *
+ * @remarks Takes `parseSync(...).program` as it comes, so no caller asserts the parser's type onto
+ * the structural view.
+ *
+ * @since 0.13.0
+ */
+export function programStatements(program) {
+    if (!isOxcNode(program) || !Array.isArray(program.body)) {
+        return [];
+    }
+    return program.body.filter(isOxcNode);
+}

package/dist/core/source-position.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Where an offset sits in a source text, as the audits report it.
+ */
+/**
+ * Returns the one-based line an offset falls on.
+ *
+ * @since 0.13.0
+ */
+export declare function lineOfOffset(sourceText: string, offset: number): number;
+/**
+ * Returns a text up to its first line break, so a multi-line node reports as one line.
+ *
+ * @since 0.13.0
+ */
+export declare function firstLineOf(text: string): string;

package/dist/core/source-position.js

@@ -0,0 +1,26 @@
+/**
+ * Where an offset sits in a source text, as the audits report it.
+ */
+/**
+ * Returns the one-based line an offset falls on.
+ *
+ * @since 0.13.0
+ */
+export function lineOfOffset(sourceText, offset) {
+    let line = 1;
+    for (let index = 0; index < offset; index++) {
+        if (sourceText.charCodeAt(index) === 10) {
+            line++;
+        }
+    }
+    return line;
+}
+/**
+ * Returns a text up to its first line break, so a multi-line node reports as one line.
+ *
+ * @since 0.13.0
+ */
+export function firstLineOf(text) {
+    const newlineIndex = text.indexOf("\n");
+    return newlineIndex === -1 ? text : text.slice(0, newlineIndex);
+}

package/dist/mirror/dist-filesystem-node.js

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { isDirentList } from "#mirror/domain/dirent-guard";
 import { normalizePath } from "#mirror/domain/path-normalizer";
 /**
  * Creates the `DistFilesystem` the mirror scan uses, backed by a `Filesystem`.
@@ -10,11 +9,8 @@ export function createMirrorDistFilesystem(fs) {
     return {
         async listRelativeFilesRecursively(dirPath) {
             try {
-                const raw = await fs.readdir(dirPath, { recursive: true, withFileTypes: true });
-                if (!isDirentList(raw)) {
-                    return [];
-                }
-                return raw
+                const entries = await fs.readdirEntries(dirPath, { recursive: true });
+                return entries
                     .filter((dirent) => dirent.isFile())
                     .map((dirent) => {
                     const fullPath = path.join(dirent.parentPath, dirent.name);
@@ -31,14 +27,8 @@ export function createMirrorDistFilesystem(fs) {
         },
         async isDirectoryCssOnly(distDir, dirPath) {
             try {
-                const raw = await fs.readdir(path.join(distDir, dirPath), { withFileTypes: true });
-                if (!isDirentList(raw)) {
-                    return false;
-                }
-                if (raw.length === 0) {
-                    return true;
-                }
-                return raw.every((dirent) => dirent.isFile() && dirent.name.endsWith(".css"));
+                const entries = await fs.readdirEntries(path.join(distDir, dirPath));
+                return entries.every((dirent) => dirent.isFile() && dirent.name.endsWith(".css"));
             }
             catch {
                 return false;

package/dist/pack-slim/run.js

@@ -115,7 +115,7 @@ async function pruneDist(fs, distDir, write, pkgStats) {
     if (!fs.existsSync(distDir)) {
         return;
     }
-    const entries = (await fs.readdir(distDir, { recursive: true, withFileTypes: true }));
+    const entries = await fs.readdirEntries(distDir, { recursive: true });
     for (const entry of entries) {
         if (!entry.isFile()) {
             continue;

package/dist/tag/domain/version-summary.d.ts

@@ -1,10 +1,13 @@
-import type { TagTargetExecutionResult } from "#tag/domain/types";
 /**
  * Collects the distinct, non-empty package versions stamped across a run's target results.
  *
  * @since 0.11.0
  */
-export declare function extractDistinctVersions(targetResults: Array<TagTargetExecutionResult>): Set<string>;
+export declare function extractDistinctVersions(targetResults: ReadonlyArray<{
+    readonly result: {
+        readonly version: string;
+    } | null;
+}>): Set<string>;
 /**
  * Summarizes a set of versions as `"none"`, the single version, or `"mixed"`.
  *

package/dist/tag/writer/since-writer.js

@@ -1,4 +1,5 @@
 import { parseSync } from "oxc-parser";
+import { isOxcNode, programStatements } from "#core/oxc-node";
 import { applyEditsDescending, indentOfLineContaining } from "#core/source-text-edit";
 /**
  * Top-level statement kinds that carry a `@since` tag: function, class, interface,
@@ -12,9 +13,6 @@ const TAGGABLE_DECLARATION_TYPES = new Set([
     "TSEnumDeclaration",
     "VariableDeclaration",
 ]);
-function isOxcNode(value) {
-    return typeof value === "object" && value !== null && typeof value.type === "string";
-}
 function identifierName(node) {
     if (isOxcNode(node) && node.type === "Identifier" && typeof node.name === "string") {
         return node.name;
@@ -35,7 +33,7 @@ export class TagSinceWriter {
     applySinceTagsToFile(filePath, version, write) {
         const sourceText = this.fs.readFileSync(filePath, "utf8");
         const { program, comments } = parseSync(filePath, sourceText);
-        const statements = program.body;
+        const statements = programStatements(program);
         const jsDocComments = comments.filter((comment) => comment.type === "Block" && comment.value.startsWith("*"));
         const edits = [];
         for (const declaration of this.collectExportedDeclarations(statements)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/cli",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Developer CLI for the Codefast monorepo (arrange, audit, mirror, pack-slim, tag)",
   "keywords": [
     "cli",
@@ -54,13 +54,13 @@
     "@microsoft/tsdoc": "^0.17.0",
     "commander": "^15.0.0",
     "jiti": "^2.7.0",
-    "oxc-parser": "^0.150.0",
+    "oxc-parser": "^0.151.0",
     "picomatch": "^4.0.7",
     "yaml": "^2.9.1",
     "zod": "^4.6.5"
   },
   "peerDependencies": {
-    "typescript": "^7.0.2"
+    "typescript": ">=7.0.0"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -68,6 +68,6 @@
     }
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=24.0.0"
   }
 }

package/dist/mirror/domain/dirent-guard.d.ts

@@ -1,10 +0,0 @@
-import type { DirectoryEntry } from "#core/filesystem/filesystem";
-/**
- * Narrow `fs.promises.readdir` overload result to `Dirent[]` when `withFileTypes: true`.
- * Accepts both historical checks (`isFile` / `isDirectory`) in one guard.
- * Returning `true` for an empty array is intentional: callers treat empty lists
- * the same regardless of the element type, so `[]` is safely accepted as `Dirent[]`.
- *
- * @since 0.3.16-canary.0
- */
-export declare function isDirentList(x: Array<string> | Array<DirectoryEntry>): x is Array<DirectoryEntry>;

package/dist/mirror/domain/dirent-guard.js

@@ -1,15 +0,0 @@
-/**
- * Narrow `fs.promises.readdir` overload result to `Dirent[]` when `withFileTypes: true`.
- * Accepts both historical checks (`isFile` / `isDirectory`) in one guard.
- * Returning `true` for an empty array is intentional: callers treat empty lists
- * the same regardless of the element type, so `[]` is safely accepted as `Dirent[]`.
- *
- * @since 0.3.16-canary.0
- */
-export function isDirentList(x) {
-    if (x.length === 0) {
-        return true;
-    }
-    const first = x[0];
-    return typeof first === "object" && first !== null && "isFile" in first && "isDirectory" in first;
-}