@naturalcycles/dev-lib 20.24.1 → 20.26.0

package/cfg/tsconfig.src.json

@@ -44,6 +44,8 @@
     "noUncheckedIndexedAccess": true,
     "noUncheckedSideEffectImports": true,
     "noPropertyAccessFromIndexSignature": true,
+    "noUnusedLocals": false, // doesn't support _prefixed vars
+    "noUnusedParameters": true,
 
     // Enabled should be faster, but will catch less errors
     // "skipLibCheck": true,

package/dist/bin/dev-lib.js

@@ -3,7 +3,7 @@ import { _by } from '@naturalcycles/js-lib/array/array.util.js';
 import { _assert } from '@naturalcycles/js-lib/error/assert.js';
 import { fs2 } from '@naturalcycles/nodejs-lib/fs2';
 import { runScript } from '@naturalcycles/nodejs-lib/runScript';
-import { buildCopy, buildProd, eslintAll, lintStagedCommand, requireOxlintConfig, runBiome, runCheck, runOxlint, runPrettier, runTest, stylelintAll, typecheckWithTSC, } from '../check.util.js';
+import { buildCopy, buildProd, eslintAll, lintStagedCommand, requireOxlintConfig, runBiome, runCheck, runOxlint, runPrettier, runTest, stylelintAll, typecheckWithTS, typecheckWithTSC, typecheckWithTSGO, } from '../check.util.js';
 import { runCommitlint } from '../commitlint.js';
 const commands = [
     { name: 'check', fn: runCheck, desc: '"Run all possible checks": lint, typecheck, then test.' },
@@ -12,17 +12,21 @@ const commands = [
         fn: quickCheck,
         desc: 'Like check, but without slow parts, to perform preliminary checks',
     },
-    { name: 'bt', fn: bt, desc: 'Build & Test: run "typecheck" (via oxlint) and then "test".' },
+    { name: 'bt', fn: bt, desc: 'Build & Test: run "typecheck" and then "test".' },
     {
         name: 'typecheck',
-        // fn: typecheckWithOxlint,
-        fn: typecheckWithTSC, // todo: attempt tsgo
-        desc: 'Run typecheck via oxlint --type-aware',
+        fn: typecheckWithTS,
+        desc: 'Run typecheck via tsgo (if available) or tsc',
     },
     {
         name: 'typecheck-with-tsc',
         fn: typecheckWithTSC,
-        desc: 'Run typecheck (tsc) in folders (src, scripts, e2e) if there is tsconfig.json present. Deprecated, use oxlint type-checking instead.',
+        desc: 'Run typecheck (tsc) in folders (src, scripts, e2e) if there is tsconfig.json present.',
+    },
+    {
+        name: 'typecheck-with-tsgo',
+        fn: typecheckWithTSGO,
+        desc: 'Run typecheck (tsgo) in folders (src, scripts, e2e) if there is tsconfig.json present.',
     },
     {
         name: 'build',
@@ -63,7 +67,7 @@ const commands = [
     {
         name: 'lint',
         fn: () => runCheck({
-            typecheckWithTSC: false,
+            typecheck: false,
             test: false,
         }),
         desc: 'Run all linters: eslint, prettier, stylelint, ktlint, actionlint.',
@@ -162,14 +166,13 @@ async function quickCheck() {
         eslint: false,
         prettier: false,
         stylelint: false,
-        typecheckWithTSC: false,
+        typecheck: false,
     });
 }
 async function bt() {
-    // Still using tsc, as oxlint is found to fail in certain cases
-    // todo: attempt to use tsgo!
+    // Still using ts, as oxlint is found to fail in certain cases
     // await typecheckWithOxlint()
-    await typecheckWithTSC();
+    await typecheckWithTS();
     runTest();
 }
 async function _typecheckWithOxlint() {

package/dist/check.util.d.ts

@@ -1,4 +1,4 @@
-import type { SemVerString } from '@naturalcycles/js-lib/types';
+import { type SemVerString } from '@naturalcycles/js-lib/types';
 /**
  * Every boolean defaults to true, so, by default - everything is being run.
  * Pass false to skip it.
@@ -9,7 +9,13 @@ export interface CheckOptions {
     stylelint?: boolean;
     prettier?: boolean;
     ktlint?: boolean;
-    typecheckWithTSC?: boolean;
+    /**
+     * true - run tsgo, otherwise tsc
+     * tsgo - run tsgo
+     * tsc - run tsc
+     * false - skip
+     */
+    typecheck?: boolean | 'tsc' | 'tsgo';
     test?: boolean;
 }
 /**
@@ -24,27 +30,50 @@ interface EslintAllOptions {
 }
 /**
  * Runs `eslint` command for all predefined paths (e.g /src, /scripts, etc).
+ *
+ * Returns true if it ran
+ */
+export declare function eslintAll(opt?: EslintAllOptions): boolean;
+/**
+ * Returns true if it ran.
  */
-export declare function eslintAll(opt?: EslintAllOptions): void;
-export declare function runOxlint(fix?: boolean): void;
+export declare function runOxlint(fix?: boolean): boolean;
 export declare function requireOxlintConfig(): void;
 export declare function hasOxlintConfig(): boolean;
 interface RunPrettierOptions {
     experimentalCli?: boolean;
     fix?: boolean;
 }
-export declare function runPrettier(opt?: RunPrettierOptions): void;
-export declare function stylelintAll(fix?: boolean): void;
+/**
+ * Returns true if it ran.
+ */
+export declare function runPrettier(opt?: RunPrettierOptions): boolean;
+/**
+ * Returns true if it ran.
+ */
+export declare function stylelintAll(fix?: boolean): boolean;
 export declare function lintStagedCommand(): Promise<void>;
 export declare function requireActionlintVersion(): void;
 export declare function getActionLintVersion(): SemVerString | undefined;
-export declare function runBiome(fix?: boolean): void;
+/**
+ * Returns true if it ran.
+ */
+export declare function runBiome(fix?: boolean): boolean;
 export declare function buildProd(): Promise<void>;
+/**
+ * Uses tsgo if it's installed, otherwise tsc
+ */
+export declare function typecheckWithTS(): Promise<void>;
 export declare function typecheckWithTSC(): Promise<void>;
+export declare function typecheckWithTSGO(): Promise<void>;
 /**
  * Use 'src' to indicate root.
  */
 export declare function runTSCInFolders(dirs: string[], args?: string[], parallel?: boolean): Promise<void>;
+/**
+ * Use 'src' to indicate root.
+ */
+export declare function runTSGOInFolders(dirs: string[], args?: string[], parallel?: boolean): Promise<void>;
 export declare function runTSCProd(args?: string[]): Promise<void>;
 export declare function buildCopy(): void;
 interface RunTestOptions {
@@ -52,6 +81,9 @@ interface RunTestOptions {
     manual?: boolean;
     leaks?: boolean;
 }
-export declare function runTest(opt?: RunTestOptions): void;
+/**
+ * Returns true if it ran.
+ */
+export declare function runTest(opt?: RunTestOptions): boolean;
 export declare function findPackageBinPath(pkg: string, cmd: string): string;
 export {};

package/dist/check.util.js

@@ -4,10 +4,11 @@ import { createRequire } from 'node:module';
 import path from 'node:path';
 import { _isTruthy } from '@naturalcycles/js-lib';
 import { _uniq } from '@naturalcycles/js-lib/array';
-import { _since } from '@naturalcycles/js-lib/datetime/time.util.js';
+import { _ms, _since } from '@naturalcycles/js-lib/datetime/time.util.js';
 import { _assert } from '@naturalcycles/js-lib/error/assert.js';
 import { _filterFalsyValues } from '@naturalcycles/js-lib/object/object.util.js';
 import { semver2 } from '@naturalcycles/js-lib/semver';
+import { _stringMapEntries, } from '@naturalcycles/js-lib/types';
 import { dimGrey, white } from '@naturalcycles/nodejs-lib/colors';
 import { exec2 } from '@naturalcycles/nodejs-lib/exec2';
 import { fs2 } from '@naturalcycles/nodejs-lib/fs2';
@@ -22,8 +23,10 @@ const { CI, ESLINT_CONCURRENCY } = process.env;
  * If full=false - the "slow" linters are skipped.
  */
 export async function runCheck(opt = {}) {
-    const { fastLinters = true, eslint = true, stylelint = true, prettier = true, ktlint = true, typecheckWithTSC: runTSC = true, test = true, } = opt;
+    const { fastLinters = true, eslint = true, stylelint = true, prettier = true, ktlint = true, typecheck = true, test = true, } = opt;
     const started = Date.now();
+    let s;
+    const timings = {};
     // const { commitOnChanges, failOnChanges } = _yargs().options({
     //   commitOnChanges: {
     //     type: 'boolean',
@@ -47,34 +50,68 @@ export async function runCheck(opt = {}) {
     if (fastLinters) {
         // Fast linters (that run in <1 second) go first
         runActionLint();
-        runBiome(fix);
-        runOxlint(fix);
+        s = Date.now();
+        if (runBiome(fix)) {
+            timings['biome'] = Date.now() - s;
+        }
+        s = Date.now();
+        if (runOxlint(fix)) {
+            timings['oxlint'] = Date.now() - s;
+        }
     }
     // From this point we start the "slow" linters, with ESLint leading the way
     if (eslint) {
         // We run eslint BEFORE Prettier, because eslint can delete e.g unused imports.
-        eslintAll({
-            fix,
-        });
+        s = Date.now();
+        if (eslintAll({ fix })) {
+            timings['eslint'] = Date.now() - s;
+        }
     }
     if (stylelint &&
-        existsSync(`node_modules/stylelint`) &&
-        existsSync(`node_modules/stylelint-config-standard-scss`)) {
-        stylelintAll(fix);
+        hasDependencyInNodeModules('stylelint') &&
+        hasDependencyInNodeModules('stylelint-config-standard-scss')) {
+        s = Date.now();
+        if (stylelintAll(fix)) {
+            timings['stylelint'] = Date.now() - s;
+        }
     }
     if (prettier) {
-        runPrettier({ fix });
+        s = Date.now();
+        if (runPrettier({ fix })) {
+            timings['prettier'] = Date.now() - s;
+        }
     }
     if (ktlint) {
-        await runKTLint(fix);
+        s = Date.now();
+        if (await runKTLint(fix)) {
+            timings['ktlint'] = Date.now() - s;
+        }
     }
-    if (runTSC) {
-        await typecheckWithTSC();
+    if (typecheck) {
+        s = Date.now();
+        if (typecheck === 'tsgo') {
+            await typecheckWithTSGO();
+            timings['tsgo'] = Date.now() - s;
+        }
+        else if (typecheck === 'tsc') {
+            await typecheckWithTSC();
+            timings['tsc'] = Date.now() - s;
+        }
+        else {
+            await typecheckWithTS();
+            timings['typecheck'] = Date.now() - s;
+        }
     }
     if (test) {
-        runTest();
+        s = Date.now();
+        if (runTest()) {
+            timings['test'] = Date.now() - s;
+        }
     }
     console.log(`${check(true)}${white(`check`)} ${dimGrey(`took ` + _since(started))}`);
+    for (const [job, ms] of _stringMapEntries(timings)) {
+        console.log(`${job.padStart(12, ' ')}: ${String(_ms(ms)).padStart(10, ' ')}`);
+    }
     // if (needToTrackChanges) {
     //   const gitStatusAfter = gitStatus()
     //   const hasChanges = gitStatusAfter !== gitStatusAtStart
@@ -97,6 +134,8 @@ export async function runCheck(opt = {}) {
 }
 /**
  * Runs `eslint` command for all predefined paths (e.g /src, /scripts, etc).
+ *
+ * Returns true if it ran
  */
 export function eslintAll(opt) {
     const { argv } = _yargs().options({
@@ -114,13 +153,16 @@ export function eslintAll(opt) {
         ...opt,
     };
     const extensions = ext.split(',');
-    runESLint(extensions, fix);
+    return runESLint(extensions, fix);
 }
+/**
+ * Returns true if it ran.
+ */
 function runESLint(extensions = eslintExtensions.split(','), fix = true) {
     const eslintConfigPath = `eslint.config.js`;
     if (!existsSync(eslintConfigPath)) {
         // faster to bail-out like this
-        return;
+        return false;
     }
     // const tsconfigRootDir = [cwd, configDir !== '.' && configDir].filter(Boolean).join('/')
     const eslintPath = findPackageBinPath('eslint', 'eslint');
@@ -149,11 +191,15 @@ function runESLint(extensions = eslintExtensions.split(','), fix = true) {
             TIMING: CI ? 'true' : '',
         }),
     });
+    return true;
 }
+/**
+ * Returns true if it ran.
+ */
 export function runOxlint(fix = true) {
     if (!hasOxlintConfig()) {
         console.log('.oxlintrc.json is not found, skipping to run oxlint');
-        return;
+        return false;
     }
     const oxlintPath = findPackageBinPath('oxlint', 'oxlint');
     exec2.spawn(oxlintPath, {
@@ -169,6 +215,7 @@ export function runOxlint(fix = true) {
         ].filter(_isTruthy),
         shell: false,
     });
+    return true;
 }
 export function requireOxlintConfig() {
     _assert(hasOxlintConfig(), '.oxlintrc.json config is not found');
@@ -185,11 +232,15 @@ const prettierPaths = [
     // Exclude
     ...lintExclude.map((s) => `!${s}`),
 ];
+/**
+ * Returns true if it ran.
+ */
 export function runPrettier(opt = {}) {
     let { experimentalCli = true, fix = true } = opt;
     const prettierConfigPath = [`./prettier.config.js`].find(f => existsSync(f));
-    if (!prettierConfigPath)
-        return;
+    if (!prettierConfigPath) {
+        return false;
+    }
     const prettierPath = findPackageBinPath('prettier', 'prettier');
     const cacheLocation = 'node_modules/.cache/prettier';
     const cacheFound = existsSync(cacheLocation);
@@ -214,6 +265,7 @@ export function runPrettier(opt = {}) {
         ].filter(_isTruthy),
         shell: false,
     });
+    return true;
 }
 const stylelintPaths = [
     // Everything inside these folders
@@ -221,6 +273,9 @@ const stylelintPaths = [
     // Exclude
     ...lintExclude.map((s) => `!${s}`),
 ];
+/**
+ * Returns true if it ran.
+ */
 export function stylelintAll(fix) {
     const argv = _yargs().options({
         fix: {
@@ -230,14 +285,16 @@ export function stylelintAll(fix) {
     }).argv;
     fix ??= argv.fix;
     const config = [`./stylelint.config.js`].find(f => existsSync(f));
-    if (!config)
-        return;
+    if (!config) {
+        return false;
+    }
     // stylelint is never hoisted from dev-lib, so, no need to search for its path
     exec2.spawn('stylelint', {
         name: fix ? 'stylelint' : 'stylelint --no-fix',
         args: [fix ? `--fix` : '', `--allow-empty-input`, `--config`, config, ...stylelintPaths].filter(Boolean),
         shell: false,
     });
+    return true;
 }
 export async function lintStagedCommand() {
     const localConfig = `./lint-staged.config.js`;
@@ -250,24 +307,33 @@ export async function lintStagedCommand() {
     if (!success)
         process.exit(3);
 }
+/**
+ * Returns true if it ran.
+ */
 async function runKTLint(fix = true) {
-    if (!existsSync(`node_modules/@naturalcycles/ktlint`))
-        return;
+    if (!existsSync(`node_modules/@naturalcycles/ktlint`)) {
+        return false;
+    }
     // @ts-expect-error ktlint is not installed (due to size in node_modules), but it's ok
     const { ktlintAll } = await import('@naturalcycles/ktlint');
     await ktlintAll(fix ? ['-F'] : []);
+    return true;
 }
+/**
+ * Returns true if it ran.
+ */
 function runActionLint() {
     // Only run if there is a folder of `.github/workflows`, otherwise actionlint will fail
-    if (!existsSync('.github/workflows'))
-        return;
+    if (!existsSync('.github/workflows')) {
+        return false;
+    }
     if (canRunBinary('actionlint')) {
         requireActionlintVersion();
         exec2.spawn(`actionlint`);
+        return true;
     }
-    else {
-        console.log(`actionlint is not installed and won't be run.\nThis is how to install it: https://github.com/rhysd/actionlint/blob/main/docs/install.md`);
-    }
+    console.log(`actionlint is not installed and won't be run.\nThis is how to install it: https://github.com/rhysd/actionlint/blob/main/docs/install.md`);
+    return false;
 }
 export function requireActionlintVersion() {
     const version = getActionLintVersion();
@@ -281,11 +347,14 @@ export function getActionLintVersion() {
         return;
     return exec2.exec('actionlint --version').split('\n')[0];
 }
+/**
+ * Returns true if it ran.
+ */
 export function runBiome(fix = true) {
     const configPath = `biome.jsonc`;
     if (!existsSync(configPath)) {
         console.log(`biome is skipped, because ./biome.jsonc is not present`);
-        return;
+        return false;
     }
     const biomePath = findPackageBinPath('@biomejs/biome', 'biome');
     const dirs = [`src`, `scripts`, `e2e`].filter(d => existsSync(d));
@@ -294,16 +363,28 @@ export function runBiome(fix = true) {
         args: [`lint`, fix && '--write', fix && '--unsafe', '--no-errors-on-unmatched', ...dirs].filter(_isTruthy),
         shell: false,
     });
+    return true;
 }
 export async function buildProd() {
     // fs2.emptyDir('./dist') // it doesn't delete the dir itself, to prevent IDE jumping
     buildCopy();
     await runTSCProd();
 }
+/**
+ * Uses tsgo if it's installed, otherwise tsc
+ */
+export async function typecheckWithTS() {
+    if (hasDependencyInNodeModules('@typescript/native-preview')) {
+        await typecheckWithTSGO();
+    }
+    await typecheckWithTSC();
+}
 export async function typecheckWithTSC() {
-    // todo: try tsgo
     await runTSCInFolders(['src', 'scripts', 'e2e'], ['--noEmit']);
 }
+export async function typecheckWithTSGO() {
+    await runTSGOInFolders(['src', 'scripts', 'e2e'], ['--noEmit', '--incremental', 'false']);
+}
 /**
  * Use 'src' to indicate root.
  */
@@ -339,6 +420,38 @@ async function runTSCInFolder(dir, args = []) {
         shell: false,
     });
 }
+/**
+ * Use 'src' to indicate root.
+ */
+export async function runTSGOInFolders(dirs, args = [], parallel = true) {
+    if (parallel) {
+        await Promise.all(dirs.map(dir => runTSGOInFolder(dir, args)));
+    }
+    else {
+        for (const dir of dirs) {
+            await runTSGOInFolder(dir, args);
+        }
+    }
+}
+/**
+ * Pass 'src' to run in root.
+ */
+async function runTSGOInFolder(dir, args = []) {
+    let configDir = dir;
+    if (dir === 'src') {
+        configDir = '';
+    }
+    const tsconfigPath = [configDir, 'tsconfig.json'].filter(Boolean).join('/');
+    if (!fs2.pathExists(tsconfigPath) || !fs2.pathExists(dir)) {
+        // console.log(`Skipping to run tsgo for ${tsconfigPath}, as it doesn't exist`)
+        return;
+    }
+    const tsgoPath = findPackageBinPath('@typescript/native-preview', 'tsgo');
+    await exec2.spawnAsync(tsgoPath, {
+        args: ['-P', tsconfigPath, ...args],
+        shell: false,
+    });
+}
 export async function runTSCProd(args = []) {
     const tsconfigPath = [`./tsconfig.prod.json`].find(p => fs2.pathExists(p)) || 'tsconfig.json';
     const tscPath = findPackageBinPath('typescript', 'tsc');
@@ -365,13 +478,17 @@ export function buildCopy() {
         dotfiles: true,
     });
 }
+/**
+ * Returns true if it ran.
+ */
 export function runTest(opt = {}) {
     // if (nodeModuleExists('vitest')) {
     if (fs2.pathExists('vitest.config.ts')) {
         runVitest(opt);
-        return;
+        return true;
     }
     console.log(dimGrey(`vitest.config.ts not found, skipping tests`));
+    return false;
 }
 function runVitest(opt) {
     const { integration, manual } = opt;
@@ -411,6 +528,9 @@ function canRunBinary(name) {
         return false;
     }
 }
+function hasDependencyInNodeModules(name) {
+    return existsSync(`node_modules/${name}`);
+}
 // function gitStatus(): string | undefined {
 //   try {
 //     return execSync('git status -s', {

package/dist/testing/testOffline.js

@@ -1,6 +1,6 @@
 import { AppError } from '@naturalcycles/js-lib/error/error.util.js';
 import { red } from '@naturalcycles/nodejs-lib/colors';
-import createMitm from 'mitm';
+import { createMitm } from '../vendor/mitm.js';
 const LOCAL_HOSTS = new Set(['localhost', '127.0.0.1']);
 const detectLeaks = process.argv.some(a => a.includes('detectLeaks'));
 let mitm;

package/dist/vendor/mitm.d.ts

@@ -0,0 +1,19 @@
+import type * as NetType from 'node:net';
+export interface SocketOptions {
+    port: number;
+    host?: string;
+    localAddress?: string;
+    localPort?: string;
+    family?: number;
+    allowHalfOpen?: boolean;
+}
+export interface BypassableSocket extends NetType.Socket {
+    bypass: () => void;
+    bypassed?: boolean;
+}
+export type ConnectCallback = (socket: BypassableSocket, opts: SocketOptions) => void;
+export interface Mitm {
+    on: (event: 'connect', callback: ConnectCallback) => void;
+    disable: () => void;
+}
+export declare function createMitm(): Mitm;

package/dist/vendor/mitm.js

@@ -0,0 +1,98 @@
+import { createRequire } from 'node:module';
+// Use require() to get mutable module objects (ESM namespace objects are frozen)
+const require = createRequire(import.meta.url);
+/* eslint-disable @typescript-eslint/naming-convention -- vendored code uses PascalCase for modules */
+const Net = require('node:net');
+const Tls = require('node:tls');
+const Http = require('node:http');
+const Https = require('node:https');
+export function createMitm() {
+    const stubs = [];
+    const listeners = [];
+    function stub(obj, prop, value) {
+        stubs.push([obj, prop, obj[prop]]);
+        obj[prop] = value;
+    }
+    function restore() {
+        let s;
+        while ((s = stubs.pop())) {
+            s[0][s[1]] = s[2];
+        }
+    }
+    function connect(orig, opts, done) {
+        // Create a bypassable socket that we'll pass to listeners
+        const socket = new Net.Socket();
+        socket.bypassed = false;
+        socket.bypass = function () {
+            this.bypassed = true;
+        };
+        // Emit connect event to all listeners
+        for (const listener of listeners) {
+            listener(socket, opts);
+        }
+        // If bypassed, call the original connect function
+        if (socket.bypassed) {
+            return orig.call(Net, opts, done);
+        }
+        // Not bypassed - return the socket that will never actually connect.
+        // testOffline throws an error before we get here, so this is just a fallback.
+        return socket;
+    }
+    function normalizeArgs(args) {
+        // Handle the various signatures of Net.connect:
+        // connect(port, host?, callback?)
+        // connect(options, callback?)
+        // connect(path, callback?) - Unix socket
+        if (typeof args[0] === 'number') {
+            const opts = { port: args[0] };
+            if (typeof args[1] === 'string') {
+                opts.host = args[1];
+                return [opts, args[2]];
+            }
+            return [opts, args[1]];
+        }
+        if (typeof args[0] === 'object' && args[0] !== null) {
+            return [args[0], args[1]];
+        }
+        // Fallback for other cases (e.g., Unix socket path)
+        return [{ port: 0 }, args[1]];
+    }
+    function createNetConnect(orig) {
+        return function (...args) {
+            const [opts, done] = normalizeArgs(args);
+            return connect(orig, opts, done);
+        };
+    }
+    function createTlsConnect(orig) {
+        return function (...args) {
+            const [opts, done] = normalizeArgs(args);
+            return connect(orig, opts, done);
+        };
+    }
+    // Stub network functions
+    const netConnect = createNetConnect(Net.connect);
+    const tlsConnect = createTlsConnect(Tls.connect);
+    stub(Net, 'connect', netConnect);
+    stub(Net, 'createConnection', netConnect);
+    stub(Http.Agent.prototype, 'createConnection', netConnect);
+    stub(Tls, 'connect', tlsConnect);
+    // Disable keep-alive on global agents to force new connections
+    const httpAgent = Http.globalAgent;
+    const httpsAgent = Https.globalAgent;
+    if (httpAgent['keepAlive']) {
+        stub(httpAgent, 'keepAlive', false);
+    }
+    if (httpsAgent['keepAlive']) {
+        stub(httpsAgent, 'keepAlive', false);
+    }
+    return {
+        on(event, callback) {
+            if (event === 'connect') {
+                listeners.push(callback);
+            }
+        },
+        disable() {
+            restore();
+        },
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/dev-lib",
   "type": "module",
-  "version": "20.24.1",
+  "version": "20.26.0",
   "dependencies": {
     "@biomejs/biome": "^2",
     "@eslint/js": "^9",
@@ -16,19 +16,22 @@
     "globals": "^17",
     "lint-staged": "^16",
     "micromatch": "^4",
-    "mitm": "^1",
     "oxlint": "^1",
     "oxlint-tsgolint": "*",
     "prettier": "^3",
     "typescript-eslint": "^8"
   },
   "peerDependencies": {
+    "@typescript/native-preview": "^7.0.0-0",
     "husky": "^9",
     "stylelint": "^16",
     "stylelint-config-standard-scss": "^16",
     "typescript": "^5"
   },
   "peerDependenciesMeta": {
+    "@typescript/native-preview": {
+      "optional": true
+    },
     "stylelint": {
       "optional": true
     },
@@ -37,7 +40,6 @@
     }
   },
   "devDependencies": {
-    "@types/mitm": "^1",
     "@types/node": "^25",
     "@types/prompts": "^2"
   },