ts-repo-utils 7.7.2 → 7.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-repo-utils",
-  "version": "7.7.2",
+  "version": "7.8.0",
   "private": false,
   "keywords": [
     "typescript"
@@ -24,11 +24,11 @@
   "module": "./dist/entry-point.mjs",
   "types": "./dist/types.d.mts",
   "bin": {
-    "assert-repo-is-clean": "./src/cmd/assert-repo-is-clean.mts",
-    "check-should-run-type-checks": "./src/cmd/check-should-run-type-checks.mts",
-    "format-diff-from": "./src/cmd/format-diff-from.mts",
-    "format-uncommitted": "./src/cmd/format-uncommitted.mts",
-    "gen-index-ts": "./src/cmd/gen-index-ts.mts"
+    "assert-repo-is-clean": "./dist/cmd/assert-repo-is-clean.mjs",
+    "check-should-run-type-checks": "./dist/cmd/check-should-run-type-checks.mjs",
+    "format-diff-from": "./dist/cmd/format-diff-from.mjs",
+    "format-uncommitted": "./dist/cmd/format-uncommitted.mjs",
+    "gen-index-ts": "./dist/cmd/gen-index-ts.mjs"
   },
   "files": [
     "src",
@@ -38,13 +38,14 @@
   ],
   "scripts": {
     "build": "tsx ./scripts/cmd/build.mts",
+    "build:min": "tsx ./scripts/cmd/build.mts --skip-check",
     "check-all": "tsx ./scripts/cmd/check-all.mts",
     "check:ext": "tsx ./scripts/cmd/check-ext.mts",
     "cspell": "cspell \"**\" --gitignore --gitignore-root ./ --no-progress",
     "doc": "tsx ./scripts/cmd/gen-docs.mts",
     "doc:embed": "tsx ./scripts/cmd/embed-samples.mts",
-    "fmt": "format-uncommitted",
-    "fmt:diff": "format-diff-from origin/main",
+    "fmt": "pnpm run z:format-uncommitted",
+    "fmt:diff": "pnpm run z:format-diff-from origin/main",
     "fmt:full": "prettier --write .",
     "gh:apply-all": "run-s gh:apply-variables gh:apply-rulesets gh:apply-repository-settings",
     "gh:apply-repository-settings": "tsx --env-file=.env scripts/github/repository/apply.mts",
@@ -54,72 +55,83 @@
     "gh:backup-repository-settings": "tsx --env-file=.env scripts/github/repository/backup.mts",
     "gh:backup-rulesets": "tsx --env-file=.env scripts/github/ruleset/backup.mts",
     "gi": "run-s gi:scripts gi:src fmt",
-    "gi:scripts": "gen-index-ts ./scripts/github --index-ext .mts --export-ext .mjs --target-ext .mts --exclude cmd --exclude apply.mts --exclude octokit.mts",
-    "gi:src": "gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --exclude cmd --exclude node-global.mts",
+    "gi:scripts": "pnpm run z:gen-index-ts ./scripts/github --index-ext .mts --export-ext .mjs --target-ext .mts --exclude cmd --exclude apply.mts --exclude octokit.mts",
+    "gi:src": "pnpm run z:gen-index-ts ./src --index-ext .mts --export-ext .mjs --target-ext .mts --target-ext .tsx --exclude entry-point.mts --exclude cmd --exclude node-global.mts",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "md": "markdownlint-cli2",
     "prepare-release": "run-s sync-cli-versions fmt build doc",
     "sync-cli-versions": "tsx scripts/cmd/sync-cli-versions.mts",
-    "test": "npm run z:vitest -- run",
-    "test:cov": "npm run z:vitest -- run --coverage",
+    "test": "pnpm run z:vitest run",
+    "test:cov": "pnpm run z:vitest run --coverage",
     "test:cov:ui": "vite preview --outDir ./coverage",
-    "test:ui": "npm run z:vitest -- --ui",
-    "testw": "npm run z:vitest -- watch",
+    "test:ui": "pnpm run z:vitest --ui",
+    "testw": "pnpm run z:vitest watch",
     "tsc": "tsc --noEmit",
     "tscw": "tsc --noEmit --watch -p ./tsconfig.json",
     "type-check": "tsc --noEmit",
-    "update-packages": "npx npm-check-updates -u --install always",
+    "update-packages": "pnpm update --latest",
+    "z:assert-repo-is-clean": "tsx ./src/cmd/assert-repo-is-clean.mjs",
+    "z:check-should-run-type-checks": "tsx ./src/cmd/check-should-run-type-checks.mjs",
+    "z:format-diff-from": "tsx ./src/cmd/format-diff-from.mjs",
+    "z:format-uncommitted": "tsx ./src/cmd/format-uncommitted.mjs",
+    "z:gen-index-ts": "tsx ./src/cmd/gen-index-ts.mjs",
     "z:vitest": "vitest --config ./configs/vitest.config.ts"
   },
   "dependencies": {
-    "@types/micromatch": "^4.0.9",
-    "cmd-ts": "^0.14.1",
+    "@types/micromatch": "^4.0.10",
+    "cmd-ts": "^0.14.3",
     "fast-glob": "^3.3.3",
     "micromatch": "^4.0.8",
     "prettier": "^3.6.2",
-    "ts-data-forge": "^3.3.0",
+    "ts-data-forge": "^3.3.1",
     "tsx": "^4.20.6"
   },
   "devDependencies": {
-    "@octokit/core": "^7.0.3",
-    "@rollup/plugin-replace": "^6.0.2",
+    "@octokit/core": "7.0.6",
+    "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-strip": "^3.0.4",
-    "@rollup/plugin-typescript": "^12.1.4",
+    "@rollup/plugin-typescript": "^12.3.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^11.0.6",
-    "@semantic-release/npm": "^12.0.2",
+    "@semantic-release/github": "^12.0.1",
+    "@semantic-release/npm": "^13.1.1",
     "@semantic-release/release-notes-generator": "^14.1.0",
-    "@types/node": "^24.5.2",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/ui": "^3.2.4",
+    "@types/node": "^24.9.2",
+    "@vitest/coverage-v8": "^4.0.6",
+    "@vitest/ui": "^4.0.6",
     "conventional-changelog-conventionalcommits": "^9.1.0",
-    "cspell": "^9.2.1",
+    "cspell": "^9.2.2",
     "dedent": "^1.7.0",
-    "eslint": "^9.37.0",
-    "eslint-config-typed": "^1.2.8",
+    "eslint": "9.38.0",
+    "eslint-config-typed": "^3.1.1",
     "fast-glob": "^3.3.3",
+    "jiti": "^2.6.1",
+    "markdownlint": "^0.39.0",
     "markdownlint-cli2": "^0.18.1",
     "npm-run-all2": "^8.0.4",
-    "octokit-safe-types": "^1.0.0",
+    "octokit-safe-types": "^1.1.2",
     "prettier": "^3.6.2",
     "prettier-plugin-organize-imports": "^4.3.0",
     "prettier-plugin-packagejson": "^2.5.19",
-    "rollup": "^4.52.3",
-    "semantic-release": "^24.2.9",
-    "ts-fortress": "^4.3.0",
-    "ts-repo-utils": "^7.5.0",
-    "ts-type-forge": "^2.2.0",
+    "rollup": "^4.52.5",
+    "semantic-release": "^25.0.1",
+    "ts-fortress": "^5.2.0",
+    "ts-type-forge": "^2.3.0",
     "tslib": "^2.8.1",
-    "typedoc": "^0.28.13",
+    "tsx": "^4.20.6",
+    "typedoc": "^0.28.14",
     "typedoc-plugin-markdown": "^4.9.0",
-    "typescript": "^5.9.2",
-    "vitest": "^3.2.4"
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.6"
   },
   "peerDependencies": {
     "prettier": "^3.6.2"
+  },
+  "volta": {
+    "node": "25.0.0",
+    "npm": "11.6.2"
   }
 }

package/src/cmd/assert-repo-is-clean.mts

@@ -1,11 +1,11 @@
-#!/usr/bin/env -S npx tsx
+#!/usr/bin/env node
 
 import * as cmd from 'cmd-ts';
 import { assertRepoIsClean } from '../functions/index.mjs';
 
 const cmdDef = cmd.command({
   name: 'assert-repo-is-clean-cli',
-  version: '7.7.2',
+  version: '7.8.0',
   args: {
     silent: cmd.flag({
       long: 'silent',
@@ -14,7 +14,7 @@ const cmdDef = cmd.command({
     }),
   },
   handler: (args) => {
-    main(args).catch((error) => {
+    main(args).catch((error: unknown) => {
       console.error('An error occurred:', error);
       process.exit(1);
     });

package/src/cmd/check-should-run-type-checks.mts

@@ -1,11 +1,11 @@
-#!/usr/bin/env -S npx tsx
+#!/usr/bin/env node
 
 import * as cmd from 'cmd-ts';
 import { checkShouldRunTypeChecks } from '../functions/index.mjs';
 
 const cmdDef = cmd.command({
   name: 'check-should-run-type-checks-cli',
-  version: '7.7.2',
+  version: '7.8.0',
   args: {
     pathsIgnore: cmd.multioption({
       long: 'paths-ignore',
@@ -21,7 +21,7 @@ const cmdDef = cmd.command({
     }),
   },
   handler: (args) => {
-    main(args).catch((error) => {
+    main(args).catch((error: unknown) => {
       console.error('An error occurred:', error);
       process.exit(1);
     });

package/src/cmd/format-diff-from.mts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S npx tsx
+#!/usr/bin/env node
 
 import * as cmd from 'cmd-ts';
 import { Result } from 'ts-data-forge';
@@ -6,7 +6,7 @@ import { formatDiffFrom } from '../functions/index.mjs';
 
 const cmdDef = cmd.command({
   name: 'format-diff-from-cli',
-  version: '7.7.2',
+  version: '7.8.0',
   args: {
     base: cmd.positional({
       type: cmd.string,
@@ -50,7 +50,7 @@ const cmdDef = cmd.command({
       excludeStaged: args.excludeStaged ?? false,
       ignoreUnknown: args.ignoreUnknown ?? true,
       silent: args.silent ?? false,
-    }).catch((error) => {
+    }).catch((error: unknown) => {
       console.error('An error occurred:', error);
       process.exit(1);
     });

package/src/cmd/format-uncommitted.mts

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S npx tsx
+#!/usr/bin/env node
 
 import * as cmd from 'cmd-ts';
 import { Result } from 'ts-data-forge';
@@ -6,7 +6,7 @@ import { formatUncommittedFiles } from '../functions/index.mjs';
 
 const cmdDef = cmd.command({
   name: 'format-uncommitted-cli',
-  version: '7.7.2',
+  version: '7.8.0',
   args: {
     excludeUntracked: cmd.flag({
       long: 'exclude-untracked',
@@ -44,7 +44,7 @@ const cmdDef = cmd.command({
       excludeStaged: args.excludeStaged ?? false,
       ignoreUnknown: args.ignoreUnknown ?? true,
       silent: args.silent ?? false,
-    }).catch((error) => {
+    }).catch((error: unknown) => {
       console.error('An error occurred:', error);
       process.exit(1);
     });

package/src/cmd/gen-index-ts.mts

@@ -1,8 +1,8 @@
-#!/usr/bin/env -S npx tsx
+#!/usr/bin/env node
 
 import * as cmd from 'cmd-ts';
 
-// eslint-disable-next-line import/no-internal-modules
+// eslint-disable-next-line import-x/no-internal-modules
 import { type InputOf, type OutputOf } from 'cmd-ts/dist/esm/from.js';
 import { expectType } from 'ts-data-forge';
 import { genIndex } from '../functions/index.mjs';
@@ -40,7 +40,7 @@ const nonEmptyArray = <T extends cmd.Type<any, any>>(
 
 const cmdDef = cmd.command({
   name: 'gen-index-ts-cli',
-  version: '7.7.2',
+  version: '7.8.0',
   args: {
     // required args
     targetDirectory: cmd.positional({
@@ -109,7 +109,7 @@ const cmdDef = cmd.command({
     expectType<typeof args.formatCommand, string | undefined>('=');
     expectType<typeof args.silent, boolean | undefined>('=');
 
-    main(args).catch((error) => {
+    main(args).catch((error: unknown) => {
       console.error('An error occurred:', error);
       process.exit(1);
     });

package/src/functions/assert-ext.mts

@@ -1,6 +1,7 @@
-import { Arr, type IMap, isString } from 'ts-data-forge';
+import { Arr, type IMap, isString, Result } from 'ts-data-forge';
 import '../node-global.mjs';
 import { assertPathExists } from './assert-path-exists.mjs';
+import { createResultAssert } from './create-result-assert.mjs';
 
 /** Configuration for directory extension checking. */
 export type CheckExtConfig = DeepReadonly<{
@@ -23,13 +24,21 @@ export type CheckExtConfig = DeepReadonly<{
   }[];
 }>;
 
+export type CheckExtError = Readonly<{
+  message: string;
+  files: readonly string[];
+}>;
+
 /**
  * Validates that all files in specified directories have the correct
- * extensions. Exits with code 1 if any files have incorrect extensions.
+ * extensions.
  *
  * @param config - Configuration specifying directories and expected extensions.
+ * @returns Result.ok when all files pass, otherwise Result.err with details.
  */
-export const assertExt = async (config: CheckExtConfig): Promise<void> => {
+export const checkExt = async (
+  config: CheckExtConfig,
+): Promise<Result<undefined, CheckExtError>> => {
   // Check all directories in parallel
   const results = await Promise.all(
     config.directories.map(async ({ path: dir, extension, ignorePatterns }) => {
@@ -49,59 +58,43 @@ export const assertExt = async (config: CheckExtConfig): Promise<void> => {
   // Collect all incorrect files
   const allIncorrectFiles: readonly string[] = results.flat();
 
-  if (allIncorrectFiles.length > 0) {
-    const generateErrorMessage = (): string => {
-      // Group directories by extension for a cleaner message
-      const extensionGroups: IMap<
-        string,
-        readonly Readonly<{
-          relativePath: string;
-          extKey: string;
-        }>[]
-      > = Arr.groupBy(
-        config.directories.map(({ path: dirPath, extension }) => {
-          const relativePath = path.relative(process.cwd(), dirPath);
-          const extKey = isString(extension)
-            ? extension
-            : extension.join(' or ');
-
-          return {
-            relativePath,
-            extKey,
-          };
-        }),
-        ({ extKey }) => extKey,
-      );
-
-      // Generate message parts for each extension
-      const messageParts = Array.from(
-        extensionGroups.entries(),
-        ([ext, dirs]) => {
-          const dirList =
-            dirs.length === 1
-              ? dirs[0]?.relativePath
-              : dirs.map((d) => d.relativePath).join(', ');
-          return `${dirList} should have ${ext} extension`;
-        },
-      );
-
-      return `All files in ${messageParts.join(' and ')}.`;
-    };
-
-    const errorMessage = [
-      'Files with incorrect extensions found:',
-      ...allIncorrectFiles.map((file) => `  - ${file}`),
-      '',
-      generateErrorMessage(),
-    ].join('\n');
-
-    echo(errorMessage);
-    process.exit(1);
+  if (allIncorrectFiles.length === 0) {
+    return Result.ok(undefined);
   }
 
-  echo('✓ All files have correct extensions');
+  const message = [
+    'Files with incorrect extensions found:',
+    ...allIncorrectFiles.map((file) => `  - ${file}`),
+    '',
+    describeExpectedExtensions(config),
+  ].join('\n');
+
+  return Result.err({
+    message,
+    files: allIncorrectFiles,
+  });
 };
 
+/**
+ * Validates that all files in specified directories have the correct
+ * extensions. Exits with code 1 if any files have incorrect extensions.
+ *
+ * @param config - Configuration specifying directories and expected extensions.
+ */
+export const assertExt = createResultAssert<
+  CheckExtConfig,
+  undefined,
+  CheckExtError
+>({
+  run: checkExt,
+  onError: (error) => {
+    echo(error.message);
+  },
+  onSuccess: () => {
+    echo('✓ All files have correct extensions');
+  },
+});
+
 /**
  * Checks if all files in a directory have the expected extension.
  *
@@ -134,3 +127,36 @@ const getFilesWithIncorrectExtension = async (
     (file) => !expectedExtensions.some((ext) => file.endsWith(ext)),
   );
 };
+
+const describeExpectedExtensions = (config: CheckExtConfig): string => {
+  // Group directories by extension for a cleaner message
+  const extensionGroups: IMap<
+    string,
+    readonly Readonly<{
+      relativePath: string;
+      extKey: string;
+    }>[]
+  > = Arr.groupBy(
+    config.directories.map(({ path: dirPath, extension }) => {
+      const relativePath = path.relative(process.cwd(), dirPath);
+      const extKey = isString(extension) ? extension : extension.join(' or ');
+
+      return {
+        relativePath,
+        extKey,
+      };
+    }),
+    ({ extKey }) => extKey,
+  );
+
+  // Generate message parts for each extension
+  const messageParts = Array.from(extensionGroups.entries(), ([ext, dirs]) => {
+    const dirList =
+      dirs.length === 1
+        ? dirs[0]?.relativePath
+        : dirs.map((d) => d.relativePath).join(', ');
+    return `${dirList} should have ${ext} extension`;
+  });
+
+  return `All files in ${messageParts.join(' and ')}.`;
+};

package/src/functions/create-result-assert.mts

@@ -0,0 +1,59 @@
+import { hasKey, isRecord, isString, Result } from 'ts-data-forge';
+import '../node-global.mjs';
+
+type ResultProducer<TConfig, TOk, TErr> = (
+  config: TConfig,
+) => Promise<Result<TOk, TErr>>;
+
+export type CreateResultAssertOptions<Config, Ok, Err> = Readonly<{
+  run: ResultProducer<Config, Ok, Err>;
+  onSuccess?: (value: Ok, config: Config) => void | Promise<void>;
+  onError?: (error: Err, config: Config) => void | Promise<void>;
+  exitCode?: number;
+}>;
+
+/**
+ * Converts a function that returns a Result into an assert-style variant that
+ * exits the process when the Result is Err. This is useful for building CLI
+ * commands that should stop execution on failure but remain composable when a
+ * Result is preferred.
+ */
+export const createResultAssert = <Config, Ok, Err>({
+  run,
+  onSuccess,
+  onError,
+  exitCode = 1,
+}: CreateResultAssertOptions<Config, Ok, Err>): ((
+  config: Config,
+) => Promise<Ok>) => {
+  const defaultOnError = (error: Err): void => {
+    if (
+      isRecord(error) &&
+      hasKey(error, 'message') &&
+      isString(error.message)
+    ) {
+      echo(error.message);
+    } else {
+      console.error(error);
+    }
+  };
+
+  return async (config: Config): Promise<Ok> => {
+    const result = await run(config);
+
+    if (Result.isErr(result)) {
+      if (onError !== undefined) {
+        await onError(result.value, config);
+      } else {
+        defaultOnError(result.value);
+      }
+      process.exit(exitCode);
+    }
+
+    if (onSuccess !== undefined) {
+      await onSuccess(result.value, config);
+    }
+
+    return result.value;
+  };
+};

package/src/functions/exec-async.mts

@@ -5,6 +5,18 @@ type ExecOptionsCustom = Readonly<{
   silent?: boolean;
 }>;
 
+type ExecOptionsWithStringEncoding = Readonly<
+  childProcess.ExecOptionsWithStringEncoding & ExecOptionsCustom
+>;
+
+type ExecOptionsWithBufferEncoding = Readonly<
+  childProcess.ExecOptionsWithBufferEncoding & ExecOptionsCustom
+>;
+
+type NormalizedExecOptions = Readonly<
+  childProcess.ExecOptions & { encoding?: BufferEncoding | 'buffer' | null }
+>;
+
 export type ExecOptions = childProcess.ExecOptions & ExecOptionsCustom;
 
 export type ExecResult<T extends string | Buffer> = Result<
@@ -23,47 +35,92 @@ export type ExecResult<T extends string | Buffer> = Result<
 export function $(
   command: string,
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  options?:
-    | ExecOptionsCustom
-    | Readonly<{ encoding: BufferEncoding } & ExecOptions>,
+  options?: ExecOptionsWithStringEncoding,
 ): Promise<ExecResult<string>>;
 
 export function $(
   command: string,
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  options?: Readonly<{ encoding: 'buffer' | null } & ExecOptions>,
+  options: ExecOptionsWithBufferEncoding,
 ): Promise<ExecResult<Buffer>>;
 
+export function $<
+  TOptions extends
+    | ExecOptionsWithBufferEncoding
+    | ExecOptionsWithStringEncoding
+    | undefined = undefined,
+>(
+  command: string,
+  options?: TOptions,
+): Promise<
+  ExecResult<TOptions extends ExecOptionsWithBufferEncoding ? Buffer : string>
+>;
+
 export function $(
   command: string,
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  options?: Readonly<
-    { encoding?: BufferEncoding | 'buffer' | null } & ExecOptions
-  >,
+  options?: ExecOptionsWithStringEncoding | ExecOptionsWithBufferEncoding,
 ): Promise<ExecResult<string | Buffer>> {
   const { silent = false, ...restOptions } = options ?? {};
+  const normalizedOptions: NormalizedExecOptions = restOptions;
 
   if (!silent) {
     echo(`$ ${command}`);
   }
 
   return new Promise((resolve) => {
-    // eslint-disable-next-line security/detect-child-process
-    childProcess.exec(command, restOptions, (error, stdout, stderr) => {
+    const handleResult = <T extends string | Buffer>(
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+      error: childProcess.ExecException | null,
+      stdout: T,
+      stderr: T,
+    ): void => {
       if (!silent) {
-        if (stdout !== '') {
+        if (!isEmpty(stdout)) {
           echo(stdout);
         }
-        if (stderr !== '') {
+        if (!isEmpty(stderr)) {
           console.error(stderr);
         }
       }
 
       if (error !== null) {
         resolve(Result.err(error));
-      } else {
-        resolve(Result.ok({ stdout, stderr }));
+        return;
       }
-    });
+
+      resolve(
+        Result.ok<Readonly<{ stdout: T; stderr: T }>>({ stdout, stderr }),
+      );
+    };
+
+    const encoding = normalizedOptions.encoding;
+
+    if (encoding === 'buffer' || encoding === null) {
+      // eslint-disable-next-line security/detect-child-process
+      childProcess.exec(
+        command,
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        normalizedOptions as childProcess.ExecOptionsWithBufferEncoding,
+        (error, stdout, stderr) => {
+          handleResult(error, stdout, stderr);
+        },
+      );
+      return;
+    }
+
+    // eslint-disable-next-line security/detect-child-process
+    childProcess.exec(
+      command,
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      normalizedOptions as childProcess.ExecOptionsWithStringEncoding,
+      (error, stdout, stderr) => {
+        handleResult(error, stdout, stderr);
+      },
+    );
   });
 }
+
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const isEmpty = (value: string | Buffer): boolean =>
+  typeof value === 'string' ? value === '' : value.length === 0;

package/src/functions/exec-async.test.mts

@@ -368,8 +368,8 @@ describe('exec-async', () => {
       // Type check for native exec with buffer encoding
       exec('echo "test"', { encoding: 'buffer' }, (error, stdout, stderr) => {
         expectType<ExecException | null, typeof error>('=');
-        expectType<Buffer, typeof stdout>('=');
-        expectType<Buffer, typeof stderr>('=');
+        expectType<Buffer, typeof stdout>('>=');
+        expectType<Buffer, typeof stderr>('>=');
       });
 
       // The $ function should produce the same types wrapped in Result (suppressed for clean output)
@@ -381,15 +381,15 @@ describe('exec-async', () => {
         Promise<
           Result<Readonly<{ stdout: Buffer; stderr: Buffer }>, ExecException>
         >
-      >('=');
+      >('~=');
     });
 
     test('should match exec callback types for null encoding', () => {
       // Type check for native exec with null encoding
       exec('echo "test"', { encoding: null }, (error, stdout, stderr) => {
         expectType<ExecException | null, typeof error>('=');
-        expectType<Buffer, typeof stdout>('=');
-        expectType<Buffer, typeof stderr>('=');
+        expectType<Buffer, typeof stdout>('>=');
+        expectType<Buffer, typeof stderr>('>=');
       });
 
       // The $ function should produce the same types wrapped in Result (suppressed for clean output)

package/src/functions/index.mts

@@ -1,6 +1,7 @@
 export * from './assert-ext.mjs';
 export * from './assert-path-exists.mjs';
 export * from './assert-repo-is-clean.mjs';
+export * from './create-result-assert.mjs';
 export * from './diff.mjs';
 export * from './exec-async.mjs';
 export * from './format.mjs';