refactor(packages/stdlib): refactor template function, fresh collections get function

.github/workflows/ci.yaml

@@ -1,9 +1,7 @@
 name: CI
 
 on:
-  pull_request:
+  - pull_request
-    branches:
-      - master
 
 env:
   NODE_VERSION: 22.x
@@ -16,14 +14,14 @@ jobs:
       contents: read
       pull-requests: write
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
 
       - name: Install pnpm
         uses: pnpm/action-setup@v4
         with:
           run_install: false
 
-      - uses: actions/setup-node@v6
+      - uses: actions/setup-node@v4
         with:
           node-version: ${{ env.NODE_VERSION }}
           cache: pnpm
@@ -31,11 +29,5 @@ jobs:
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
-      - name: Build
-        run: pnpm build
-
-      - name: Lint
-        run: pnpm lint
-
       - name: Test
-        run: pnpm test
+        run: pnpm all:build && pnpm all:test

.github/workflows/publish.yaml

@@ -1,78 +0,0 @@
-name: Publish to NPM
-
-on:
-  push:
-    branches:
-      - master
-
-env:
-  NODE_VERSION: 22.x
-
-jobs:
-  check-and-publish:
-    name: Check version changes and publish
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          run_install: false
-
-      - uses: actions/setup-node@v6
-        with:
-          node-version: ${{ env.NODE_VERSION }}
-          cache: pnpm
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Build & Test
-        run: pnpm build && pnpm test
-
-      - name: Check for version changes and publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: |
-          # Find all package.json files (excluding node_modules)
-          PACKAGE_FILES=$(find . -path "*/package.json" -not -path "*/node_modules/*")
-          
-          for file in $PACKAGE_FILES; do
-            PACKAGE_DIR=$(dirname $file)
-            echo "Checking $PACKAGE_DIR for version changes..."
-            
-            # Get package details
-            PACKAGE_NAME=$(node -p "require('$file').name")
-            CURRENT_VERSION=$(node -p "require('$file').version")
-            IS_PRIVATE=$(node -p "require('$file').private || false")
-            
-            # Skip private packages
-            if [ "$IS_PRIVATE" == "true" ]; then
-              echo "Skipping private package $PACKAGE_NAME"
-              continue
-            fi
-            
-            # Skip root package
-            if [ "$PACKAGE_DIR" == "." ]; then
-              echo "Skipping root package"
-              continue
-            fi
-            
-            # Check if package exists on npm
-            NPM_VERSION=$(npm view $PACKAGE_NAME version 2>/dev/null || echo "0.0.0")
-            
-            # Compare versions
-            if [ "$CURRENT_VERSION" != "$NPM_VERSION" ]; then
-              echo "Version changed for $PACKAGE_NAME: $NPM_VERSION → $CURRENT_VERSION"
-              echo "Publishing $PACKAGE_NAME@$CURRENT_VERSION"
-              cd $PACKAGE_DIR
-              pnpm publish --access public --no-git-checks
-              cd -
-            else
-              echo "No version change detected for $PACKAGE_NAME"
-            fi
-          done

CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+
+## v0.0.1
+
+
+### 🚀 Enhancements
+
+- **repo:** Cli tool, base tscofig ([3fcc42e](https://github.com/robonen/tools/commit/3fcc42e))
+- **repo:** Drop node_modules ([7dba5ac](https://github.com/robonen/tools/commit/7dba5ac))
+- **repo:** Global gitignore ([00c2736](https://github.com/robonen/tools/commit/00c2736))
+- **packages/tsconfig:** Readme ([afa15cd](https://github.com/robonen/tools/commit/afa15cd))
+- **docs:** Add auto generated doc based on readme ([3960f86](https://github.com/robonen/tools/commit/3960f86))
+- **packages/stdlib:** Create stdlib ([c985b95](https://github.com/robonen/tools/commit/c985b95))
+- **packages/stdlib:** Base vite config ([0434725](https://github.com/robonen/tools/commit/0434725))
+- **packages/stdlib:** Math/clamp util ([8515bff](https://github.com/robonen/tools/commit/8515bff))
+- **packages/stdlib:** MapRange util ([d8a9a62](https://github.com/robonen/tools/commit/d8a9a62))
+- **packages/stdlib:** Levenshtein distance util ([0022153](https://github.com/robonen/tools/commit/0022153))
+- **packages/stdlib:** Add trigram distance utill ([5045852](https://github.com/robonen/tools/commit/5045852))
+
+### 🩹 Fixes
+
+- **repo:** Workspaces -> workspace ([80b87d7](https://github.com/robonen/tools/commit/80b87d7))
+
+### 💅 Refactors
+
+- **repo:** Cleanup ([bc2ebfc](https://github.com/robonen/tools/commit/bc2ebfc))
+- **packages/tsconfig:** Readme remove extra spaces ([565e7d8](https://github.com/robonen/tools/commit/565e7d8))
+- **docs:** Drop docs cache and dist ([03f755d](https://github.com/robonen/tools/commit/03f755d))
+- **repo:** Add vitepress to gitignore ([cf71b8e](https://github.com/robonen/tools/commit/cf71b8e))
+- **repo:** Add pathe lib to cli tool ([d7a2d15](https://github.com/robonen/tools/commit/d7a2d15))
+- **packages/tsconfig:** Add description and publishConfig ([37d25bf](https://github.com/robonen/tools/commit/37d25bf))
+- **repo:** Change cli generated exports in package.json ([a5d33ea](https://github.com/robonen/tools/commit/a5d33ea))
+- **packages/tsconfig:** Disable declaration and source maps ([3f1d16b](https://github.com/robonen/tools/commit/3f1d16b))
+- **packages/stdlib:** Add doc, update tests ([5280ace](https://github.com/robonen/tools/commit/5280ace))
+- **packages/stdlib:** Add comments for math utils ([65ba312](https://github.com/robonen/tools/commit/65ba312))
+- **packages/stdlib:** Levensthein fn replate to module export ([92721b3](https://github.com/robonen/tools/commit/92721b3))
+- **packages/stdlib:** Rename arguments to left and right ([7d8f5be](https://github.com/robonen/tools/commit/7d8f5be))
+- **packages/stdlib:** Reformat test files ([9031430](https://github.com/robonen/tools/commit/9031430))
+- **packages/tsconfig:** Add exclude for .output  and coverage folders ([769476d](https://github.com/robonen/tools/commit/769476d))
+- **packages/stdlib:** Remove private from package.json ([5dadb50](https://github.com/robonen/tools/commit/5dadb50))
+
+### 🏡 Chore
+
+- **packages/stdlib:** Add bench script, add vscode workspace ([e9b8b0c](https://github.com/robonen/tools/commit/e9b8b0c))
+- **release:** V0.0.1 ([725b73d](https://github.com/robonen/tools/commit/725b73d))
+- **packages/stdlib:** Set 0.0.1 version ([c65113e](https://github.com/robonen/tools/commit/c65113e))
+- **release:** V0.0.1 ([f77716a](https://github.com/robonen/tools/commit/f77716a))
+
+### ✅ Tests
+
+- **packages/stdlib:** Trigram distance tests ([4c10d38](https://github.com/robonen/tools/commit/4c10d38))
+
+### ❤️ Contributors
+
+- Robonen ([@robonen](http://github.com/robonen))
+

apps/vhs/.gitignore

@@ -0,0 +1,2 @@
+bin/**
+!bin/.gitkeep

apps/vhs/README.md

@@ -0,0 +1 @@
+# @robonen/vhs

apps/vhs/jsr.json

@@ -0,0 +1,5 @@
+{
+  "name": "@robonen/vhs",
+  "version": "0.0.0",
+  "exports": "./src/index.ts"
+}

apps/vhs/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@robonen/vhs",
+  "private": true,
+  "version": "0.0.1",
+  "license": "UNLICENSED",
+  "description": "",
+  "keywords": [],
+  "author": "Robonen Andrew <robonenandrew@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/robonen/tools.git",
+    "directory": "./apps/vhs"
+  },
+  "packageManager": "pnpm@9.15.4",
+  "engines": {
+    "bun": ">=1.1.27"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "bun run src/index.ts"
+  },
+  "devDependencies": {
+    "@robonen/tsconfig": "workspace:*",
+    "@types/bun": "^1.1.17"
+  }
+}

apps/vhs/src/index.ts

@@ -0,0 +1,36 @@
+import { version } from '../package.json';
+import { resolve } from 'path';
+import { $, Glob } from 'bun';
+
+async function ffmpegMergeAndTranscodeAvi(files: Set<string>) {
+  const ffmpeg = resolve('bin/ffmpeg');
+  const output = resolve('output.mp4');
+  const input = Array.from(files).toSorted((a, b) => a.localeCompare(b)).join('|');
+
+  const shell = $`${ffmpeg} -i "concat:${input}" -stats -c:v libx264 -crf 23 -preset veryfast -c:a aac ${output}`;
+
+  for await (const line of shell.lines()) {
+    console.log(line);
+  }
+}
+
+const path = Bun.argv[2];
+
+if (!path) {
+  console.error('Please provide a path to a file or directory');
+  process.exit(1);
+}
+
+console.info(`Welcome to VHS v${version} 📼`);
+console.info(`Scanning ${path}...`);
+
+const glob = new Glob(resolve(path));
+const files = new Set<string>();
+
+for await (const file of glob.scan({ followSymlinks: false })) {
+  files.add(file);
+}
+
+console.info(`Found ${files.size} files`);
+
+console.info(await ffmpegMergeAndTranscodeAvi(files));

cli.ts

@@ -1,53 +1,16 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { defineCommand, runMain } from 'citty';
-import { resolve } from 'node:path';
+import { resolve } from 'pathe';
 import { splitByCase } from 'scule';
 
-async function getLatestPackageVersion(packageName: string) {
+const PACKAGE_MANAGER = 'pnpm@9.11.0';
-  try {
+const NODE_VERSION = '>=20.17.0';
-    const response = await fetch(`https://registry.npmjs.org/${packageName}`);
+const VITE_VERSION = '^5.4.8';
-    const data = await response.json();
+const VITE_DTS_VERSION = '^4.2.2';
-    
+const PATHE_VERSION = '^1.1.2'
-    if (!response.ok) {
-      console.warn(`Failed to fetch latest version for ${packageName}, using fallback`);
-      return null;
-    }
-    
-    const latestVersion = data['dist-tags']?.latest as string | undefined;
-
-    if (!latestVersion)
-        return null;
-
-    return {
-      version: latestVersion,
-      versionRange: `^${latestVersion}`,
-    };
-  } catch (error) {
-    console.warn(`Error fetching version for ${packageName}: ${error.message}`);
-    return null;
-  }
-}
-
-const PACKAGE_MANAGER_DEFAULT = 'pnpm@10.10.0';
-const NODE_VERSION = '>=22.15.0';
-const VITE_VERSION_DEFAULT = '^5.4.8';
-const VITE_DTS_VERSION_DEFAULT = '^4.2.2';
-const PATHE_VERSION_DEFAULT = '^1.1.2';
 const DEFAULT_DIR = 'packages';
 
-const generatePackageJson = async (name: string, path: string, hasVite: boolean) => {
+const generatePackageJson = (name: string, path: string, hasVite: boolean) => {
-    const [
-        packageManagerVersion,
-        viteVersion,
-        viteDtsVersion,
-        patheVersion,
-    ] = await Promise.all([
-      getLatestPackageVersion('pnpm').then(v => v?.version || PACKAGE_MANAGER_DEFAULT),
-      hasVite ? getLatestPackageVersion('vite').then(v => v?.versionRange || VITE_VERSION_DEFAULT) : VITE_VERSION_DEFAULT,
-      hasVite ? getLatestPackageVersion('vite-plugin-dts').then(v => v?.versionRange || VITE_DTS_VERSION_DEFAULT) : VITE_DTS_VERSION_DEFAULT,
-      hasVite ? getLatestPackageVersion('pathe').then(v => v?.versionRange || PATHE_VERSION_DEFAULT) : PATHE_VERSION_DEFAULT,
-    ]);
-
     const data = {
         name,
         private: true,
@@ -61,17 +24,20 @@ const generatePackageJson = async (name: string, path: string, hasVite: boolean)
             url: 'git+https://github.com/robonen/tools.git',
             directory: path,
         },
-        packageManager: `pnpm@${packageManagerVersion}`,
+        packageManager: PACKAGE_MANAGER,
         engines: {
             node: NODE_VERSION,
         },
         type: 'module',
         files: ['dist'],
+        main: './dist/index.umd.js',
+        module: './dist/index.js',
+        types: './dist/index.d.ts',
         exports: {
             '.': {
-                types: './dist/index.d.ts',
                 import: './dist/index.js',
                 require: './dist/index.umd.js',
+                types: './dist/index.d.ts',
             },
         },
         scripts: {
@@ -85,9 +51,9 @@ const generatePackageJson = async (name: string, path: string, hasVite: boolean)
         devDependencies: {
             '@robonen/tsconfig': 'workspace:*',
             ...(hasVite && {
-              vite: viteVersion,
+              vite: VITE_VERSION,
-              'vite-plugin-dts': viteDtsVersion,
+              'vite-plugin-dts': VITE_DTS_VERSION,
-               pathe: patheVersion,
+               pathe: PATHE_VERSION,
             }),
         },
     };
@@ -166,15 +132,14 @@ const createCommand = defineCommand({
 
         await mkdir(resolvedPath, { recursive: true });
         
-        const packageJson = await generatePackageJson(args.name, path, hasVite);
+        writeFile(`${resolvedPath}/package.json`, generatePackageJson(args.name, path, hasVite));
-        await writeFile(`${resolvedPath}/package.json`, packageJson);
+        writeFile(`${resolvedPath}/jsr.json`, generateJsrJson(args.name));
-        await writeFile(`${resolvedPath}/jsr.json`, generateJsrJson(args.name));
+        writeFile(`${resolvedPath}/tsconfig.json`, generateTsConfig());
-        await writeFile(`${resolvedPath}/tsconfig.json`, generateTsConfig());
+        writeFile(`${resolvedPath}/README.md`, generateReadme(args.name));
-        await writeFile(`${resolvedPath}/README.md`, generateReadme(args.name));
 
         if (hasVite) {
-            await mkdir(`${resolvedPath}/src`, { recursive: true });
+            mkdir(`${resolvedPath}/src`, { recursive: true });
-            await writeFile(`${resolvedPath}/vite.config.ts`, generateViteConfig());
+            writeFile(`${resolvedPath}/vite.config.ts`, generateViteConfig());
         }
 
         console.log(`Project created successfully`);

configs/oxlint/README.md

@@ -1,54 +0,0 @@
-# @robonen/oxlint
-
-Composable [oxlint](https://oxc.rs/docs/guide/usage/linter.html) configuration presets.
-
-## Install
-
-```bash
-pnpm install -D @robonen/oxlint oxlint
-```
-
-## Usage
-
-Create `oxlint.config.ts` in your project root:
-
-```ts
-import { defineConfig } from 'oxlint';
-import { compose, base, typescript, vue, vitest, imports } from '@robonen/oxlint';
-
-export default defineConfig(
-  compose(base, typescript, vue, vitest, imports),
-);
-```
-
-Append custom rules after presets to override them:
-
-```ts
-compose(base, typescript, {
-  rules: { 'eslint/no-console': 'off' },
-  ignorePatterns: ['dist'],
-});
-```
-
-## Presets
-
-| Preset       | Description                                        |
-| ------------ | -------------------------------------------------- |
-| `base`       | Core eslint, oxc, unicorn rules                    |
-| `typescript` | TypeScript-specific rules (via overrides)           |
-| `vue`        | Vue 3 Composition API / `<script setup>` rules     |
-| `vitest`     | Test file rules (via overrides)                    |
-| `imports`    | Import rules (cycles, duplicates, ordering)        |
-| `node`       | Node.js-specific rules                             |
-
-## API
-
-### `compose(...configs: OxlintConfig[]): OxlintConfig`
-
-Merges multiple configs into one:
-
-- **plugins** — union (deduplicated)
-- **rules / categories** — last wins
-- **overrides / ignorePatterns** — concatenated
-- **env / globals** — shallow merge
-- **settings** — deep merge

configs/oxlint/oxlint.config.ts

@@ -1,4 +0,0 @@
-import { defineConfig } from 'oxlint';
-import { compose, base, typescript, imports } from '@robonen/oxlint';
-
-export default defineConfig(compose(base, typescript, imports));

configs/oxlint/package.json

@@ -1,53 +0,0 @@
-{
-  "name": "@robonen/oxlint",
-  "version": "0.0.2",
-  "license": "Apache-2.0",
-  "description": "Composable oxlint configuration presets",
-  "keywords": [
-    "oxlint",
-    "oxc",
-    "linter",
-    "config",
-    "presets"
-  ],
-  "author": "Robonen Andrew <robonenandrew@gmail.com>",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/robonen/tools.git",
-    "directory": "configs/oxlint"
-  },
-  "packageManager": "pnpm@10.29.3",
-  "engines": {
-    "node": ">=24.13.1"
-  },
-  "type": "module",
-  "files": [
-    "dist"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
-  },
-  "scripts": {
-    "lint": "oxlint -c oxlint.config.ts",
-    "test": "vitest run",
-    "dev": "vitest dev",
-    "build": "tsdown"
-  },
-  "devDependencies": {
-    "@robonen/oxlint": "workspace:*",
-    "@robonen/tsconfig": "workspace:*",
-    "@robonen/tsdown": "workspace:*",
-    "oxlint": "catalog:",
-    "tsdown": "catalog:"
-  },
-  "peerDependencies": {
-    "oxlint": ">=1.47.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}

configs/oxlint/src/compose.ts

@@ -1,103 +0,0 @@
-import type { OxlintConfig } from './types';
-
-/**
- * Deep merge two objects. Arrays are concatenated, objects are recursively merged.
- */
-function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown> {
-  const result = { ...target };
-
-  for (const key of Object.keys(source)) {
-    const targetValue = target[key];
-    const sourceValue = source[key];
-
-    if (
-      typeof targetValue === 'object' && targetValue !== null && !Array.isArray(targetValue)
-      && typeof sourceValue === 'object' && sourceValue !== null && !Array.isArray(sourceValue)
-    ) {
-      result[key] = deepMerge(
-        targetValue as Record<string, unknown>,
-        sourceValue as Record<string, unknown>,
-      );
-    }
-    else {
-      result[key] = sourceValue;
-    }
-  }
-
-  return result;
-}
-
-/**
- * Compose multiple oxlint configurations into a single config.
- *
- * - `plugins` — union (deduplicated)
- * - `categories` — later configs override earlier
- * - `rules` — later configs override earlier
- * - `overrides` — concatenated
- * - `env` — merged (later overrides earlier)
- * - `globals` — merged (later overrides earlier)
- * - `settings` — deep-merged
- * - `ignorePatterns` — concatenated
- *
- * @example
- * ```ts
- * import { compose, base, typescript, vue } from '@robonen/oxlint';
- * import { defineConfig } from 'oxlint';
- *
- * export default defineConfig(
- *   compose(base, typescript, vue, {
- *     rules: { 'eslint/no-console': 'off' },
- *   }),
- * );
- * ```
- */
-export function compose(...configs: OxlintConfig[]): OxlintConfig {
-  const result: OxlintConfig = {};
-
-  for (const config of configs) {
-    // Plugins — union with dedup
-    if (config.plugins?.length) {
-      result.plugins = Array.from(new Set([...(result.plugins ?? []), ...config.plugins]));
-    }
-
-    // Categories — shallow merge
-    if (config.categories) {
-      result.categories = { ...result.categories, ...config.categories };
-    }
-
-    // Rules — shallow merge (later overrides earlier)
-    if (config.rules) {
-      result.rules = { ...result.rules, ...config.rules };
-    }
-
-    // Overrides — concatenate
-    if (config.overrides?.length) {
-      result.overrides = [...(result.overrides ?? []), ...config.overrides];
-    }
-
-    // Env — shallow merge
-    if (config.env) {
-      result.env = { ...result.env, ...config.env };
-    }
-
-    // Globals — shallow merge
-    if (config.globals) {
-      result.globals = { ...result.globals, ...config.globals };
-    }
-
-    // Settings — deep merge
-    if (config.settings) {
-      result.settings = deepMerge(
-        (result.settings ?? {}) as Record<string, unknown>,
-        config.settings as Record<string, unknown>,
-      );
-    }
-
-    // Ignore patterns — concatenate
-    if (config.ignorePatterns?.length) {
-      result.ignorePatterns = [...(result.ignorePatterns ?? []), ...config.ignorePatterns];
-    }
-  }
-
-  return result;
-}

configs/oxlint/src/index.ts

@@ -1,17 +0,0 @@
-/* Compose */
-export { compose } from './compose';
-
-/* Presets */
-export { base, typescript, vue, vitest, imports, node } from './presets';
-
-/* Types */
-export type {
-  OxlintConfig,
-  OxlintOverride,
-  OxlintEnv,
-  OxlintGlobals,
-  AllowWarnDeny,
-  DummyRule,
-  DummyRuleMap,
-  RuleCategories,
-} from './types';

configs/oxlint/src/presets/base.ts

@@ -1,73 +0,0 @@
-import type { OxlintConfig } from '../types';
-
-/**
- * Base configuration for any JavaScript/TypeScript project.
- *
- * Enables `correctness` category and opinionated rules from
- * `eslint`, `oxc`, and `unicorn` plugins.
- */
-export const base: OxlintConfig = {
-  plugins: ['eslint', 'oxc', 'unicorn'],
-
-  categories: {
-    correctness: 'error',
-  },
-
-  rules: {
-    /* ── eslint core ──────────────────────────────────────── */
-    'eslint/eqeqeq': 'error',
-    'eslint/no-console': 'warn',
-    'eslint/no-debugger': 'error',
-    'eslint/no-eval': 'error',
-    'eslint/no-var': 'error',
-    'eslint/prefer-const': 'error',
-    'eslint/prefer-template': 'warn',
-    'eslint/no-useless-constructor': 'warn',
-    'eslint/no-useless-rename': 'warn',
-    'eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }],
-    'eslint/no-self-compare': 'error',
-    'eslint/no-template-curly-in-string': 'warn',
-    'eslint/no-throw-literal': 'error',
-    'eslint/no-return-assign': 'warn',
-    'eslint/no-else-return': 'warn',
-    'eslint/no-lonely-if': 'warn',
-    'eslint/no-unneeded-ternary': 'warn',
-    'eslint/prefer-object-spread': 'warn',
-    'eslint/prefer-exponentiation-operator': 'warn',
-    'eslint/no-useless-computed-key': 'warn',
-    'eslint/no-useless-concat': 'warn',
-    'eslint/curly': 'off',
-
-    /* ── unicorn ──────────────────────────────────────────── */
-    'unicorn/prefer-node-protocol': 'error',
-    'unicorn/no-instanceof-array': 'error',
-    'unicorn/no-new-array': 'error',
-    'unicorn/prefer-array-flat-map': 'warn',
-    'unicorn/prefer-array-flat': 'warn',
-    'unicorn/prefer-includes': 'warn',
-    'unicorn/prefer-string-slice': 'warn',
-    'unicorn/prefer-string-starts-ends-with': 'warn',
-    'unicorn/throw-new-error': 'error',
-    'unicorn/error-message': 'warn',
-    'unicorn/no-useless-spread': 'warn',
-    'unicorn/no-useless-undefined': 'off',
-    'unicorn/prefer-optional-catch-binding': 'warn',
-    'unicorn/prefer-type-error': 'warn',
-    'unicorn/no-thenable': 'error',
-    'unicorn/prefer-number-properties': 'warn',
-    'unicorn/prefer-global-this': 'warn',
-
-    /* ── oxc ──────────────────────────────────────────────── */
-    'oxc/no-accumulating-spread': 'warn',
-    'oxc/bad-comparison-sequence': 'error',
-    'oxc/bad-min-max-func': 'error',
-    'oxc/bad-object-literal-comparison': 'error',
-    'oxc/const-comparisons': 'error',
-    'oxc/double-comparisons': 'error',
-    'oxc/erasing-op': 'error',
-    'oxc/missing-throw': 'error',
-    'oxc/bad-bitwise-operator': 'error',
-    'oxc/bad-char-at-comparison': 'error',
-    'oxc/bad-replace-all-arg': 'error',
-  },
-};

configs/oxlint/src/presets/imports.ts

@@ -1,20 +0,0 @@
-import type { OxlintConfig } from '../types';
-
-/**
- * Import plugin rules for clean module boundaries.
- */
-export const imports: OxlintConfig = {
-  plugins: ['import'],
-
-  rules: {
-    'import/no-duplicates': 'error',
-    'import/no-self-import': 'error',
-    'import/no-cycle': 'warn',
-    'import/first': 'warn',
-    'import/no-mutable-exports': 'error',
-    'import/no-amd': 'error',
-    'import/no-commonjs': 'warn',
-    'import/no-empty-named-blocks': 'warn',
-    'import/consistent-type-specifier-style': ['warn', 'prefer-top-level'],
-  },
-};

configs/oxlint/src/presets/index.ts

@@ -1,6 +0,0 @@
-export { base } from './base';
-export { typescript } from './typescript';
-export { vue } from './vue';
-export { vitest } from './vitest';
-export { imports } from './imports';
-export { node } from './node';

configs/oxlint/src/presets/node.ts

@@ -1,17 +0,0 @@
-import type { OxlintConfig } from '../types';
-
-/**
- * Node.js-specific rules.
- */
-export const node: OxlintConfig = {
-  plugins: ['node'],
-
-  env: {
-    node: true,
-  },
-
-  rules: {
-    'node/no-exports-assign': 'error',
-    'node/no-new-require': 'error',
-  },
-};

configs/oxlint/src/presets/typescript.ts

@@ -1,39 +0,0 @@
-import type { OxlintConfig } from '../types';
-
-/**
- * TypeScript-specific rules.
- *
- * Applied via `overrides` for `*.ts`, `*.tsx`, `*.mts`, `*.cts` files.
- */
-export const typescript: OxlintConfig = {
-  plugins: ['typescript'],
-
-  overrides: [
-    {
-      files: ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'],
-      rules: {
-        'typescript/consistent-type-imports': 'error',
-        'typescript/no-explicit-any': 'off',
-        'typescript/no-non-null-assertion': 'off',
-        'typescript/prefer-as-const': 'error',
-        'typescript/no-empty-object-type': 'warn',
-        'typescript/no-wrapper-object-types': 'error',
-        'typescript/no-duplicate-enum-values': 'error',
-        'typescript/no-unsafe-declaration-merging': 'error',
-        'typescript/no-import-type-side-effects': 'error',
-        'typescript/no-useless-empty-export': 'warn',
-        'typescript/no-inferrable-types': 'warn',
-        'typescript/prefer-function-type': 'warn',
-        'typescript/ban-tslint-comment': 'error',
-        'typescript/consistent-type-definitions': ['warn', 'interface'],
-        'typescript/prefer-for-of': 'warn',
-        'typescript/no-unnecessary-type-constraint': 'warn',
-        'typescript/adjacent-overload-signatures': 'warn',
-        'typescript/array-type': ['warn', { default: 'array-simple' }],
-        'typescript/no-this-alias': 'error',
-        'typescript/triple-slash-reference': 'error',
-        'typescript/no-namespace': 'error',
-      },
-    },
-  ],
-};

configs/oxlint/src/presets/vitest.ts

@@ -1,35 +0,0 @@
-import type { OxlintConfig } from '../types';
-
-/**
- * Vitest rules for test files.
- *
- * Applied via `overrides` for common test file patterns.
- */
-export const vitest: OxlintConfig = {
-  plugins: ['vitest'],
-
-  overrides: [
-    {
-      files: [
-        '**/*.test.{ts,tsx,js,jsx}',
-        '**/*.spec.{ts,tsx,js,jsx}',
-        '**/test/**/*.{ts,tsx,js,jsx}',
-        '**/__tests__/**/*.{ts,tsx,js,jsx}',
-      ],
-      rules: {
-        'vitest/no-conditional-tests': 'warn',
-        'vitest/no-import-node-test': 'error',
-        'vitest/prefer-to-be-truthy': 'warn',
-        'vitest/prefer-to-be-falsy': 'warn',
-        'vitest/prefer-to-be-object': 'warn',
-        'vitest/prefer-to-have-length': 'warn',
-        'vitest/consistent-test-filename': 'warn',
-        'vitest/prefer-describe-function-title': 'warn',
-
-        /* relax strict rules in tests */
-        'eslint/no-unused-vars': 'off',
-        'typescript/no-explicit-any': 'off',
-      },
-    },
-  ],
-};

configs/oxlint/src/presets/vue.ts

@@ -1,26 +0,0 @@
-import type { OxlintConfig } from '../types';
-
-/**
- * Vue.js-specific rules.
- *
- * Enforces Composition API with `<script setup>` and type-based declarations.
- */
-export const vue: OxlintConfig = {
-  plugins: ['vue'],
-
-  rules: {
-    'vue/no-arrow-functions-in-watch': 'error',
-    'vue/no-deprecated-destroyed-lifecycle': 'error',
-    'vue/no-export-in-script-setup': 'error',
-    'vue/no-lifecycle-after-await': 'error',
-    'vue/no-multiple-slot-args': 'error',
-    'vue/no-import-compiler-macros': 'error',
-    'vue/define-emits-declaration': ['error', 'type-based'],
-    'vue/define-props-declaration': ['error', 'type-based'],
-    'vue/prefer-import-from-vue': 'error',
-    'vue/no-required-prop-with-default': 'warn',
-    'vue/valid-define-emits': 'error',
-    'vue/valid-define-props': 'error',
-    'vue/require-typed-ref': 'warn',
-  },
-};

configs/oxlint/src/types.ts

@@ -1,18 +0,0 @@
-/**
- * Re-exported configuration types from `oxlint`.
- *
- * Keeps the preset API in sync with the oxlint CLI without
- * maintaining a separate copy of the types.
- *
- * @see https://oxc.rs/docs/guide/usage/linter/config-file-reference.html
- */
-export type {
-  OxlintConfig,
-  OxlintOverride,
-  OxlintEnv,
-  OxlintGlobals,
-  AllowWarnDeny,
-  DummyRule,
-  DummyRuleMap,
-  RuleCategories,
-} from 'oxlint';

configs/oxlint/test/compose.test.ts

@@ -1,146 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { compose } from '../src/compose';
-import type { OxlintConfig } from '../src/types';
-
-describe('compose', () => {
-  it('should return empty config when no configs provided', () => {
-    expect(compose()).toEqual({});
-  });
-
-  it('should return the same config when one config provided', () => {
-    const config: OxlintConfig = {
-      plugins: ['eslint'],
-      rules: { 'eslint/no-console': 'warn' },
-    };
-    const result = compose(config);
-    expect(result.plugins).toEqual(['eslint']);
-    expect(result.rules).toEqual({ 'eslint/no-console': 'warn' });
-  });
-
-  it('should merge plugins with dedup', () => {
-    const a: OxlintConfig = { plugins: ['eslint', 'oxc'] };
-    const b: OxlintConfig = { plugins: ['oxc', 'typescript'] };
-
-    const result = compose(a, b);
-    expect(result.plugins).toEqual(['eslint', 'oxc', 'typescript']);
-  });
-
-  it('should override rules from later configs', () => {
-    const a: OxlintConfig = { rules: { 'eslint/no-console': 'error', 'eslint/eqeqeq': 'warn' } };
-    const b: OxlintConfig = { rules: { 'eslint/no-console': 'off' } };
-
-    const result = compose(a, b);
-    expect(result.rules).toEqual({
-      'eslint/no-console': 'off',
-      'eslint/eqeqeq': 'warn',
-    });
-  });
-
-  it('should override categories from later configs', () => {
-    const a: OxlintConfig = { categories: { correctness: 'error', suspicious: 'warn' } };
-    const b: OxlintConfig = { categories: { suspicious: 'off' } };
-
-    const result = compose(a, b);
-    expect(result.categories).toEqual({
-      correctness: 'error',
-      suspicious: 'off',
-    });
-  });
-
-  it('should concatenate overrides', () => {
-    const a: OxlintConfig = {
-      overrides: [{ files: ['**/*.ts'], rules: { 'typescript/no-explicit-any': 'warn' } }],
-    };
-    const b: OxlintConfig = {
-      overrides: [{ files: ['**/*.test.ts'], rules: { 'eslint/no-unused-vars': 'off' } }],
-    };
-
-    const result = compose(a, b);
-    expect(result.overrides).toHaveLength(2);
-    expect(result.overrides?.[0]?.files).toEqual(['**/*.ts']);
-    expect(result.overrides?.[1]?.files).toEqual(['**/*.test.ts']);
-  });
-
-  it('should merge env', () => {
-    const a: OxlintConfig = { env: { browser: true } };
-    const b: OxlintConfig = { env: { node: true } };
-
-    const result = compose(a, b);
-    expect(result.env).toEqual({ browser: true, node: true });
-  });
-
-  it('should merge globals', () => {
-    const a: OxlintConfig = { globals: { MY_VAR: 'readonly' } };
-    const b: OxlintConfig = { globals: { ANOTHER: 'writable' } };
-
-    const result = compose(a, b);
-    expect(result.globals).toEqual({ MY_VAR: 'readonly', ANOTHER: 'writable' });
-  });
-
-  it('should deep merge settings', () => {
-    const a: OxlintConfig = {
-      settings: {
-        react: { version: '18.2.0' },
-        next: { rootDir: 'apps/' },
-      },
-    };
-    const b: OxlintConfig = {
-      settings: {
-        react: { linkComponents: [{ name: 'Link', linkAttribute: 'to', attributes: ['to'] }] },
-      },
-    };
-
-    const result = compose(a, b);
-    expect(result.settings).toEqual({
-      react: {
-        version: '18.2.0',
-        linkComponents: [{ name: 'Link', linkAttribute: 'to', attributes: ['to'] }],
-      },
-      next: { rootDir: 'apps/' },
-    });
-  });
-
-  it('should concatenate ignorePatterns', () => {
-    const a: OxlintConfig = { ignorePatterns: ['dist'] };
-    const b: OxlintConfig = { ignorePatterns: ['node_modules', 'coverage'] };
-
-    const result = compose(a, b);
-    expect(result.ignorePatterns).toEqual(['dist', 'node_modules', 'coverage']);
-  });
-
-  it('should handle composing all presets together', () => {
-    const base: OxlintConfig = {
-      plugins: ['eslint', 'oxc'],
-      categories: { correctness: 'error' },
-      rules: { 'eslint/no-console': 'warn' },
-    };
-    const ts: OxlintConfig = {
-      plugins: ['typescript'],
-      overrides: [{ files: ['**/*.ts'], rules: { 'typescript/no-explicit-any': 'warn' } }],
-    };
-    const custom: OxlintConfig = {
-      rules: { 'eslint/no-console': 'off' },
-      ignorePatterns: ['dist'],
-    };
-
-    const result = compose(base, ts, custom);
-
-    expect(result.plugins).toEqual(['eslint', 'oxc', 'typescript']);
-    expect(result.categories).toEqual({ correctness: 'error' });
-    expect(result.rules).toEqual({ 'eslint/no-console': 'off' });
-    expect(result.overrides).toHaveLength(1);
-    expect(result.ignorePatterns).toEqual(['dist']);
-  });
-
-  it('should skip undefined/empty fields', () => {
-    const a: OxlintConfig = { plugins: ['eslint'] };
-    const b: OxlintConfig = { rules: { 'eslint/no-console': 'warn' } };
-
-    const result = compose(a, b);
-    expect(result.plugins).toEqual(['eslint']);
-    expect(result.rules).toEqual({ 'eslint/no-console': 'warn' });
-    expect(result.overrides).toBeUndefined();
-    expect(result.env).toBeUndefined();
-    expect(result.settings).toBeUndefined();
-  });
-});

configs/oxlint/tsdown.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from 'tsdown';
-import { sharedConfig } from '@robonen/tsdown';
-
-export default defineConfig({
-  ...sharedConfig,
-  entry: ['src/index.ts'],
-});

configs/oxlint/vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-  },
-});

configs/tsconfig/README.md

@@ -1,27 +0,0 @@
-# @robonen/tsconfig
-
-Shared base TypeScript configuration.
-
-## Install
-
-```bash
-pnpm install -D @robonen/tsconfig
-```
-
-## Usage
-
-Extend from it in your `tsconfig.json`:
-
-```json
-{
-  "extends": "@robonen/tsconfig/tsconfig.json"
-}
-```
-
-## What's Included
-
-- **Target / Module**: ESNext with Bundler resolution
-- **Strict mode**: `strict`, `noUncheckedIndexedAccess`
-- **Module safety**: `verbatimModuleSyntax`, `isolatedModules`
-- **Declarations**: `declaration` enabled
-- **Interop**: `esModuleInterop`, `allowJs`, `resolveJsonModule`

configs/tsdown/package.json

@@ -1,30 +0,0 @@
-{
-  "name": "@robonen/tsdown",
-  "version": "0.0.1",
-  "private": true,
-  "license": "Apache-2.0",
-  "description": "Shared tsdown configuration for @robonen packages",
-  "keywords": [
-    "tsdown",
-    "config",
-    "build"
-  ],
-  "author": "Robonen Andrew <robonenandrew@gmail.com>",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/robonen/tools.git",
-    "directory": "configs/tsdown"
-  },
-  "packageManager": "pnpm@10.29.3",
-  "engines": {
-    "node": ">=24.13.1"
-  },
-  "type": "module",
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "devDependencies": {
-    "@robonen/tsconfig": "workspace:*",
-    "tsdown": "catalog:"
-  }
-}

configs/tsdown/src/index.ts

@@ -1,13 +0,0 @@
-import type { Options } from 'tsdown';
-
-const BANNER = '/*! @robonen/tools | (c) 2026 Robonen Andrew | Apache-2.0 */';
-
-export const sharedConfig = {
-  format: ['esm', 'cjs'],
-  dts: true,
-  clean: true,
-  hash: false,
-  outputOptions: {
-    banner: BANNER,
-  },
-} satisfies Options;

configs/tsdown/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "@robonen/tsconfig/tsconfig.json"
-}

core/platform/README.md

@@ -1,23 +0,0 @@
-# @robonen/platform
-
-Platform-dependent utilities for browser & multi-runtime environments.
-
-## Install
-
-```bash
-pnpm install @robonen/platform
-```
-
-## Modules
-
-| Entry              | Utilities     | Description                      |
-| ------------------ | ------------- | -------------------------------- |
-| `@robonen/platform/browsers` | `focusGuard`  | Browser-specific helpers         |
-| `@robonen/platform/multi`    | `global`      | Cross-runtime (Node/Bun/Deno) utilities |
-
-## Usage
-
-```ts
-import { focusGuard } from '@robonen/platform/browsers';
-import { global } from '@robonen/platform/multi';
-```

core/platform/oxlint.config.ts

@@ -1,15 +0,0 @@
-import { defineConfig } from 'oxlint';
-import { compose, base, typescript, imports } from '@robonen/oxlint';
-
-export default defineConfig(
-	compose(base, typescript, imports, {
-		overrides: [
-			{
-				files: ['src/multi/global/index.ts'],
-				rules: {
-					'unicorn/prefer-global-this': 'off',
-				},
-			},
-		],
-	}),
-);

core/platform/tsdown.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'tsdown';
-import { sharedConfig } from '@robonen/tsdown';
-
-export default defineConfig({
-  ...sharedConfig,
-  entry: {
-    browsers: 'src/browsers/index.ts',
-    multi: 'src/multi/index.ts',
-  },
-});

core/stdlib/README.md

@@ -1,32 +0,0 @@
-# @robonen/stdlib
-
-Standard library of platform-independent utilities for TypeScript.
-
-## Install
-
-```bash
-pnpm install @robonen/stdlib
-```
-
-## Modules
-
-| Module          | Utilities                                                       |
-| --------------- | --------------------------------------------------------------- |
-| **arrays**      | `cluster`, `first`, `last`, `sum`, `unique`                     |
-| **async**       | `sleep`, `tryIt`                                                |
-| **bits**        | `flags`                                                         |
-| **collections** | `get`                                                           |
-| **math**        | `clamp`, `lerp`, `remap` + BigInt variants                      |
-| **objects**     | `omit`, `pick`                                                  |
-| **patterns**    | `pubsub`                                                        |
-| **structs**     | `stack`                                                         |
-| **sync**        | `mutex`                                                         |
-| **text**        | `levenshteinDistance`, `trigramDistance`                         |
-| **types**       | JS & TS type utilities                                          |
-| **utils**       | `timestamp`, `noop`                                             |
-
-## Usage
-
-```ts
-import { first, sleep, clamp } from '@robonen/stdlib';
-```

core/stdlib/oxlint.config.ts

@@ -1,4 +0,0 @@
-import { defineConfig } from 'oxlint';
-import { compose, base, typescript, imports } from '@robonen/oxlint';
-
-export default defineConfig(compose(base, typescript, imports));

core/stdlib/src/async/pool/index.ts

@@ -1,3 +0,0 @@
-export interface AsyncPoolOptions {
-  concurrency?: number;
-}

core/stdlib/src/async/retry/index.ts

@@ -1,39 +0,0 @@
-// eslint-disable
-export interface RetryOptions {
-  times?: number;
-  delay?: number;
-  backoff: (options: RetryOptions & { count: number }) => number;
-}
-
-/**
- * @name retry
- * @category Async
- * @description Retries a function a specified number of times with a delay between each retry
- * 
- * @param {Promise<unknown>} fn - The function to retry
- * @param {RetryOptions} options - The options for the retry
- * @returns {Promise<unknown>} - The result of the function
- * 
- * @example
- * const result = await retry(() => {
- *  return fetch('https://jsonplaceholder.typicode.com/todos/1')
- *   .then(response => response.json())
- * });
- * 
- * @example
- * const result = await retry(() => {
- *  return fetch('https://jsonplaceholder.typicode.com/todos/1')
- *    .then(response => response.json())
- * }, { times: 3, delay: 1000 });
- * 
- */
-export async function retry<Return>(
-  fn: () => Promise<Return>,
-  options: RetryOptions
-) {
-  const {
-    times = 3,
-  } = options;
-
-  let count = 0;
-}

core/stdlib/src/patterns/behavioral/Command/async.ts

@@ -1,55 +0,0 @@
-import { BaseCommandHistory } from './base';
-import type { AsyncCommand } from './types';
-
-/**
- * @name AsyncCommandHistory
- * @category Patterns
- * @description Async command history with undo/redo/batch support
- *
- * @since 0.0.8
- */
-export class AsyncCommandHistory extends BaseCommandHistory<AsyncCommand> {
-  async execute(command: AsyncCommand): Promise<void> {
-    await command.execute();
-    this.pushUndo(command);
-  }
-
-  async undo(): Promise<boolean> {
-    const command = this.undoStack.pop();
-
-    if (!command)
-      return false;
-
-    await command.undo();
-    this.moveToRedo(command);
-
-    return true;
-  }
-
-  async redo(): Promise<boolean> {
-    const command = this.redoStack.pop();
-
-    if (!command)
-      return false;
-
-    await command.execute();
-    this.moveToUndo(command);
-
-    return true;
-  }
-
-  async batch(commands: AsyncCommand[]): Promise<void> {
-    const macro: AsyncCommand = {
-      execute: async () => {
-        for (const c of commands)
-          await c.execute();
-      },
-      undo: async () => {
-        for (let i = commands.length - 1; i >= 0; i--)
-          await commands[i]!.undo();
-      },
-    };
-
-    await this.execute(macro);
-  }
-}

core/stdlib/src/patterns/behavioral/Command/base.ts

@@ -1,49 +0,0 @@
-/**
- * @name BaseCommandHistory
- * @category Patterns
- * @description Base class with shared undo/redo stack management
- *
- * @since 0.0.8
- */
-export abstract class BaseCommandHistory<C> {
-  protected undoStack: C[] = [];
-  protected redoStack: C[] = [];
-  protected readonly maxSize: number;
-
-  constructor(options?: { maxSize?: number }) {
-    this.maxSize = options?.maxSize ?? Infinity;
-  }
-
-  get size(): number {
-    return this.undoStack.length;
-  }
-
-  get canUndo(): boolean {
-    return this.undoStack.length > 0;
-  }
-
-  get canRedo(): boolean {
-    return this.redoStack.length > 0;
-  }
-
-  clear(): void {
-    this.undoStack.length = 0;
-    this.redoStack.length = 0;
-  }
-
-  protected pushUndo(command: C): void {
-    this.undoStack.push(command);
-    this.redoStack.length = 0;
-
-    if (this.undoStack.length > this.maxSize)
-      this.undoStack.splice(0, this.undoStack.length - this.maxSize);
-  }
-
-  protected moveToRedo(command: C): void {
-    this.redoStack.push(command);
-  }
-
-  protected moveToUndo(command: C): void {
-    this.undoStack.push(command);
-  }
-}

core/stdlib/src/patterns/behavioral/Command/index.test.ts

@@ -1,281 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { CommandHistory, AsyncCommandHistory } from '.';
-import type { Command, AsyncCommand } from '.';
-
-describe('commandHistory', () => {
-  let history: CommandHistory;
-  let items: string[];
-
-  function addItem(item: string): Command {
-    return {
-      execute: () => { items.push(item); },
-      undo: () => { items.pop(); },
-    };
-  }
-
-  beforeEach(() => {
-    history = new CommandHistory();
-    items = [];
-  });
-
-  describe('execute', () => {
-    it('executes a command', () => {
-      history.execute(addItem('a'));
-
-      expect(items).toEqual(['a']);
-    });
-
-    it('tracks size', () => {
-      history.execute(addItem('a'));
-      history.execute(addItem('b'));
-
-      expect(history.size).toBe(2);
-    });
-
-    it('clears redo stack on new execute', () => {
-      history.execute(addItem('a'));
-      history.undo();
-
-      expect(history.canRedo).toBe(true);
-
-      history.execute(addItem('b'));
-
-      expect(history.canRedo).toBe(false);
-    });
-  });
-
-  describe('undo', () => {
-    it('undoes the last command', () => {
-      history.execute(addItem('a'));
-      history.execute(addItem('b'));
-      history.undo();
-
-      expect(items).toEqual(['a']);
-    });
-
-    it('returns true when undo was performed', () => {
-      history.execute(addItem('a'));
-
-      expect(history.undo()).toBe(true);
-    });
-
-    it('returns false when nothing to undo', () => {
-      expect(history.undo()).toBe(false);
-    });
-
-    it('multiple undos', () => {
-      history.execute(addItem('a'));
-      history.execute(addItem('b'));
-      history.execute(addItem('c'));
-      history.undo();
-      history.undo();
-      history.undo();
-
-      expect(items).toEqual([]);
-      expect(history.canUndo).toBe(false);
-    });
-  });
-
-  describe('redo', () => {
-    it('redoes the last undone command', () => {
-      history.execute(addItem('a'));
-      history.undo();
-      history.redo();
-
-      expect(items).toEqual(['a']);
-    });
-
-    it('returns true when redo was performed', () => {
-      history.execute(addItem('a'));
-      history.undo();
-
-      expect(history.redo()).toBe(true);
-    });
-
-    it('returns false when nothing to redo', () => {
-      expect(history.redo()).toBe(false);
-    });
-
-    it('undo then redo multiple times', () => {
-      history.execute(addItem('a'));
-      history.execute(addItem('b'));
-      history.undo();
-      history.undo();
-      history.redo();
-      history.redo();
-
-      expect(items).toEqual(['a', 'b']);
-    });
-  });
-
-  describe('batch', () => {
-    it('executes multiple commands', () => {
-      history.batch([addItem('a'), addItem('b'), addItem('c')]);
-
-      expect(items).toEqual(['a', 'b', 'c']);
-    });
-
-    it('undoes all batched commands in one step', () => {
-      history.batch([addItem('a'), addItem('b'), addItem('c')]);
-      history.undo();
-
-      expect(items).toEqual([]);
-    });
-
-    it('counts as single history entry', () => {
-      history.batch([addItem('a'), addItem('b'), addItem('c')]);
-
-      expect(history.size).toBe(1);
-    });
-
-    it('undoes batch in reverse order', () => {
-      const order: string[] = [];
-
-      history.batch([
-        { execute: () => order.push('exec-1'), undo: () => order.push('undo-1') },
-        { execute: () => order.push('exec-2'), undo: () => order.push('undo-2') },
-        { execute: () => order.push('exec-3'), undo: () => order.push('undo-3') },
-      ]);
-      history.undo();
-
-      expect(order).toEqual(['exec-1', 'exec-2', 'exec-3', 'undo-3', 'undo-2', 'undo-1']);
-    });
-  });
-
-  describe('maxSize', () => {
-    it('limits undo stack', () => {
-      const limited = new CommandHistory({ maxSize: 2 });
-      items = [];
-
-      limited.execute(addItem('a'));
-      limited.execute(addItem('b'));
-      limited.execute(addItem('c'));
-
-      expect(limited.size).toBe(2);
-      expect(limited.canUndo).toBe(true);
-
-      limited.undo();
-      limited.undo();
-
-      expect(limited.canUndo).toBe(false);
-      expect(items).toEqual(['a']);
-    });
-  });
-
-  describe('clear', () => {
-    it('clears all history', () => {
-      history.execute(addItem('a'));
-      history.execute(addItem('b'));
-      history.undo();
-      history.clear();
-
-      expect(history.canUndo).toBe(false);
-      expect(history.canRedo).toBe(false);
-      expect(history.size).toBe(0);
-    });
-  });
-
-  describe('canUndo / canRedo', () => {
-    it('initially false', () => {
-      expect(history.canUndo).toBe(false);
-      expect(history.canRedo).toBe(false);
-    });
-
-    it('canUndo after execute', () => {
-      history.execute(addItem('a'));
-
-      expect(history.canUndo).toBe(true);
-      expect(history.canRedo).toBe(false);
-    });
-
-    it('canRedo after undo', () => {
-      history.execute(addItem('a'));
-      history.undo();
-
-      expect(history.canUndo).toBe(false);
-      expect(history.canRedo).toBe(true);
-    });
-  });
-});
-
-describe('asyncCommandHistory', () => {
-  let history: AsyncCommandHistory;
-  let items: string[];
-
-  function addItemAsync(item: string): AsyncCommand {
-    return {
-      execute: async () => {
-        await new Promise((r) => setTimeout(r, 5));
-        items.push(item);
-      },
-      undo: async () => {
-        await new Promise((r) => setTimeout(r, 5));
-        items.pop();
-      },
-    };
-  }
-
-  beforeEach(() => {
-    history = new AsyncCommandHistory();
-    items = [];
-  });
-
-  it('executes async command', async () => {
-    await history.execute(addItemAsync('a'));
-
-    expect(items).toEqual(['a']);
-  });
-
-  it('undoes async command', async () => {
-    await history.execute(addItemAsync('a'));
-    await history.undo();
-
-    expect(items).toEqual([]);
-  });
-
-  it('redoes async command', async () => {
-    await history.execute(addItemAsync('a'));
-    await history.undo();
-    await history.redo();
-
-    expect(items).toEqual(['a']);
-  });
-
-  it('batches async commands', async () => {
-    await history.batch([addItemAsync('a'), addItemAsync('b'), addItemAsync('c')]);
-
-    expect(items).toEqual(['a', 'b', 'c']);
-    expect(history.size).toBe(1);
-  });
-
-  it('undoes async batch', async () => {
-    await history.batch([addItemAsync('a'), addItemAsync('b')]);
-    await history.undo();
-
-    expect(items).toEqual([]);
-  });
-
-  it('works with sync commands too', async () => {
-    await history.execute({
-      execute: () => { items.push('sync'); },
-      undo: () => { items.pop(); },
-    });
-
-    expect(items).toEqual(['sync']);
-
-    await history.undo();
-
-    expect(items).toEqual([]);
-  });
-
-  it('respects maxSize', async () => {
-    const limited = new AsyncCommandHistory({ maxSize: 2 });
-    items = [];
-
-    await limited.execute(addItemAsync('a'));
-    await limited.execute(addItemAsync('b'));
-    await limited.execute(addItemAsync('c'));
-
-    expect(limited.size).toBe(2);
-  });
-});

core/stdlib/src/patterns/behavioral/Command/index.ts

@@ -1,3 +0,0 @@
-export type * from './types';
-export * from './sync';
-export * from './async';

core/stdlib/src/patterns/behavioral/Command/sync.ts

@@ -1,52 +0,0 @@
-import { BaseCommandHistory } from './base';
-import type { Command } from './types';
-
-/**
- * @name CommandHistory
- * @category Patterns
- * @description Command history with undo/redo/batch support
- *
- * @since 0.0.8
- */
-export class CommandHistory extends BaseCommandHistory<Command> {
-  execute(command: Command): void {
-    command.execute();
-    this.pushUndo(command);
-  }
-
-  undo(): boolean {
-    const command = this.undoStack.pop();
-
-    if (!command)
-      return false;
-
-    command.undo();
-    this.moveToRedo(command);
-
-    return true;
-  }
-
-  redo(): boolean {
-    const command = this.redoStack.pop();
-
-    if (!command)
-      return false;
-
-    command.execute();
-    this.moveToUndo(command);
-
-    return true;
-  }
-
-  batch(commands: Command[]): void {
-    const macro: Command = {
-      execute: () => commands.forEach((c) => c.execute()),
-      undo: () => {
-        for (let i = commands.length - 1; i >= 0; i--)
-          commands[i]!.undo();
-      },
-    };
-
-    this.execute(macro);
-  }
-}

core/stdlib/src/patterns/behavioral/Command/types.ts

@@ -1,11 +0,0 @@
-import type { MaybePromise } from '../../../types';
-
-export interface Command {
-  execute: () => void;
-  undo: () => void;
-}
-
-export interface AsyncCommand {
-  execute: () => MaybePromise<void>;
-  undo: () => MaybePromise<void>;
-}

core/stdlib/src/patterns/behavioral/StateMachine/async.ts

@@ -1,133 +0,0 @@
-import { isString } from '../../../types';
-import { BaseStateMachine } from './base';
-import type { AsyncStateNodeConfig, ExtractStates, ExtractEvents } from './types';
-
-/**
- * @name AsyncStateMachine
- * @category Patterns
- * @description Async finite state machine with support for async guards, actions, and hooks
- *
- * @since 0.0.8
- *
- * @template States - Union of state names
- * @template Events - Union of event names
- * @template Context - Machine context type
- */
-export class AsyncStateMachine<
-  States extends string = string,
-  Events extends string = string,
-  Context = undefined,
-> extends BaseStateMachine<States, Events, Context, AsyncStateNodeConfig<Context>> {
-  /**
-   * Send an event to the machine, awaiting async guards, actions, and hooks
-   *
-   * @param event - Event name
-   * @returns The current state after processing the event
-   */
-  async send(event: Events): Promise<States> {
-    const stateNode = this.states[this.currentState];
-
-    if (!stateNode?.on)
-      return this.currentState;
-
-    const transition = stateNode.on[event];
-
-    if (transition === undefined)
-      return this.currentState;
-
-    let target: string;
-
-    if (isString(transition)) {
-      target = transition;
-    } else {
-      if (transition.guard && !(await transition.guard(this.context)))
-        return this.currentState;
-
-      await transition.action?.(this.context);
-      target = transition.target;
-    }
-
-    await stateNode.exit?.(this.context);
-    this.currentState = target as States;
-    await this.states[this.currentState]?.entry?.(this.context);
-
-    return this.currentState;
-  }
-
-  /**
-   * Check if an event can trigger a transition, awaiting async guards
-   *
-   * @param event - Event to check
-   */
-  async can(event: Events): Promise<boolean> {
-    const stateNode = this.states[this.currentState];
-
-    if (!stateNode?.on)
-      return false;
-
-    const transition = stateNode.on[event];
-
-    if (transition === undefined)
-      return false;
-
-    if (!isString(transition) && transition.guard)
-      return await transition.guard(this.context);
-
-    return true;
-  }
-}
-
-/**
- * Create a type-safe async finite state machine with context
- *
- * @example
- * ```ts
- * const machine = createAsyncMachine({
- *   initial: 'idle',
- *   context: { data: '' },
- *   states: {
- *     idle: {
- *       on: {
- *         FETCH: {
- *           target: 'loaded',
- *           guard: async () => await hasPermission(),
- *           action: async (ctx) => { ctx.data = await fetchData(); },
- *         },
- *       },
- *     },
- *     loaded: {
- *       entry: async (ctx) => { await saveToCache(ctx.data); },
- *     },
- *   },
- * });
- *
- * await machine.send('FETCH'); // 'loaded'
- * ```
- */
-export function createAsyncMachine<
-  const States extends Record<string, AsyncStateNodeConfig<Context>>,
-  Context,
->(config: {
-  initial: NoInfer<ExtractStates<States>>;
-  context: Context;
-  states: States;
-}): AsyncStateMachine<ExtractStates<States>, ExtractEvents<States>, Context>;
-
-export function createAsyncMachine<
-  const States extends Record<string, AsyncStateNodeConfig<undefined>>,
->(config: {
-  initial: NoInfer<ExtractStates<States>>;
-  states: States;
-}): AsyncStateMachine<ExtractStates<States>, ExtractEvents<States>, undefined>;
-
-export function createAsyncMachine(config: {
-  initial: string;
-  context?: unknown;
-  states: Record<string, AsyncStateNodeConfig<any>>;
-}): AsyncStateMachine {
-  return new AsyncStateMachine(
-    config.initial,
-    config.states,
-    config.context as undefined,
-  );
-}

core/stdlib/src/patterns/behavioral/StateMachine/base.ts

@@ -1,44 +0,0 @@
-/**
- * Base class for state machines — holds shared state, getters, and matches()
- *
- * @template States - Union of state names
- * @template Events - Union of event names
- * @template Context - Machine context type
- * @template NodeConfig - State node configuration type
- */
-export class BaseStateMachine<
-  States extends string,
-  _Events extends string,
-  Context,
-  NodeConfig,
-> {
-  protected currentState: States;
-  protected readonly states: Record<string, NodeConfig>;
-
-  /** Machine context */
-  readonly context: Context;
-
-  constructor(
-    initial: States,
-    states: Record<string, NodeConfig>,
-    context: Context,
-  ) {
-    this.currentState = initial;
-    this.context = context;
-    this.states = states;
-  }
-
-  /** Current state of the machine */
-  get current(): States {
-    return this.currentState;
-  }
-
-  /**
-   * Check if the machine is in a specific state
-   *
-   * @param state - State to check
-   */
-  matches(state: States): boolean {
-    return this.currentState === state;
-  }
-}

core/stdlib/src/patterns/behavioral/StateMachine/index.test.ts

@@ -1,688 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { createMachine, createAsyncMachine, StateMachine, AsyncStateMachine } from '.';
-
-describe('stateMachine', () => {
-  describe('createMachine (without context)', () => {
-    let machine: ReturnType<typeof createSimpleMachine>;
-
-    function createSimpleMachine() {
-      return createMachine({
-        initial: 'idle',
-        states: {
-          idle: {
-            on: {
-              START: 'running',
-            },
-          },
-          running: {
-            on: {
-              STOP: 'idle',
-              PAUSE: 'paused',
-            },
-          },
-          paused: {
-            on: {
-              RESUME: 'running',
-              STOP: 'idle',
-            },
-          },
-        },
-      });
-    }
-
-    beforeEach(() => {
-      machine = createSimpleMachine();
-    });
-
-    it('initializes with the initial state', () => {
-      expect(machine.current).toBe('idle');
-    });
-
-    it('transitions on send', () => {
-      machine.send('START');
-
-      expect(machine.current).toBe('running');
-    });
-
-    it('returns new state from send', () => {
-      const result = machine.send('START');
-
-      expect(result).toBe('running');
-    });
-
-    it('handles multiple transitions', () => {
-      machine.send('START');
-      machine.send('PAUSE');
-      machine.send('RESUME');
-      machine.send('STOP');
-
-      expect(machine.current).toBe('idle');
-    });
-
-    it('ignores unhandled events', () => {
-      machine.send('STOP');
-
-      expect(machine.current).toBe('idle');
-    });
-
-    it('ignores events not defined in current state', () => {
-      machine.send('PAUSE');
-
-      expect(machine.current).toBe('idle');
-    });
-
-    it('matches current state', () => {
-      expect(machine.matches('idle')).toBe(true);
-      expect(machine.matches('running')).toBe(false);
-
-      machine.send('START');
-
-      expect(machine.matches('idle')).toBe(false);
-      expect(machine.matches('running')).toBe(true);
-    });
-
-    it('checks if event can be handled', () => {
-      expect(machine.can('START')).toBe(true);
-      expect(machine.can('STOP')).toBe(false);
-      expect(machine.can('PAUSE')).toBe(false);
-
-      machine.send('START');
-
-      expect(machine.can('START')).toBe(false);
-      expect(machine.can('STOP')).toBe(true);
-      expect(machine.can('PAUSE')).toBe(true);
-    });
-  });
-
-  describe('createMachine (with context)', () => {
-    function createContextMachine() {
-      return createMachine({
-        initial: 'idle',
-        context: { count: 0, log: '' },
-        states: {
-          idle: {
-            on: {
-              START: {
-                target: 'running',
-                action: (ctx) => { ctx.count = 0; },
-              },
-            },
-          },
-          running: {
-            on: {
-              INCREMENT: {
-                target: 'running',
-                action: (ctx) => { ctx.count++; },
-              },
-              STOP: 'idle',
-            },
-          },
-        },
-      });
-    }
-
-    it('provides typed context', () => {
-      const machine = createContextMachine();
-
-      expect(machine.context).toEqual({ count: 0, log: '' });
-    });
-
-    it('runs action on transition', () => {
-      const machine = createContextMachine();
-
-      machine.send('START');
-      machine.send('INCREMENT');
-      machine.send('INCREMENT');
-      machine.send('INCREMENT');
-
-      expect(machine.context.count).toBe(3);
-    });
-
-    it('resets context via action', () => {
-      const machine = createContextMachine();
-
-      machine.send('START');
-      machine.send('INCREMENT');
-      machine.send('INCREMENT');
-      machine.send('STOP');
-      machine.send('START');
-
-      expect(machine.context.count).toBe(0);
-    });
-  });
-
-  describe('guards', () => {
-    function createGuardedMachine() {
-      return createMachine({
-        initial: 'idle',
-        context: { retries: 0 },
-        states: {
-          idle: {
-            on: {
-              TRY: {
-                target: 'attempting',
-                action: (ctx) => { ctx.retries++; },
-              },
-            },
-          },
-          attempting: {
-            on: {
-              FAIL: {
-                target: 'idle',
-                guard: (ctx) => ctx.retries < 3,
-              },
-              SUCCESS: 'done',
-            },
-          },
-          done: {},
-        },
-      });
-    }
-
-    it('allows transition when guard returns true', () => {
-      const machine = createGuardedMachine();
-
-      machine.send('TRY');
-      machine.send('FAIL');
-
-      expect(machine.current).toBe('idle');
-      expect(machine.context.retries).toBe(1);
-    });
-
-    it('blocks transition when guard returns false', () => {
-      const machine = createGuardedMachine();
-
-      machine.send('TRY');
-      machine.send('FAIL');
-      machine.send('TRY');
-      machine.send('FAIL');
-      machine.send('TRY');
-      machine.send('FAIL');
-
-      expect(machine.current).toBe('attempting');
-      expect(machine.context.retries).toBe(3);
-    });
-
-    it('reflects guard in can()', () => {
-      const machine = createGuardedMachine();
-
-      machine.send('TRY');
-      expect(machine.can('FAIL')).toBe(true);
-
-      machine.send('FAIL');
-      machine.send('TRY');
-      machine.send('FAIL');
-      machine.send('TRY');
-
-      expect(machine.can('FAIL')).toBe(false);
-    });
-  });
-
-  describe('entry/exit hooks', () => {
-    it('calls exit on previous state and entry on next state', () => {
-      const exitIdle = vi.fn();
-      const enterRunning = vi.fn();
-
-      const machine = createMachine({
-        initial: 'idle',
-        states: {
-          idle: {
-            on: { START: 'running' },
-            exit: exitIdle,
-          },
-          running: {
-            on: { STOP: 'idle' },
-            entry: enterRunning,
-          },
-        },
-      });
-
-      machine.send('START');
-
-      expect(exitIdle).toHaveBeenCalledOnce();
-      expect(enterRunning).toHaveBeenCalledOnce();
-    });
-
-    it('does not call hooks when transition is blocked by guard', () => {
-      const exitHook = vi.fn();
-      const entryHook = vi.fn();
-
-      const machine = createMachine({
-        initial: 'locked',
-        context: { unlocked: false },
-        states: {
-          locked: {
-            on: {
-              UNLOCK: {
-                target: 'unlocked',
-                guard: (ctx) => ctx.unlocked,
-              },
-            },
-            exit: exitHook,
-          },
-          unlocked: {
-            entry: entryHook,
-          },
-        },
-      });
-
-      machine.send('UNLOCK');
-
-      expect(exitHook).not.toHaveBeenCalled();
-      expect(entryHook).not.toHaveBeenCalled();
-      expect(machine.current).toBe('locked');
-    });
-
-    it('calls hooks with context', () => {
-      const entryHook = vi.fn();
-
-      const machine = createMachine({
-        initial: 'idle',
-        context: { value: 42 },
-        states: {
-          idle: {
-            on: { GO: 'active' },
-          },
-          active: {
-            entry: entryHook,
-          },
-        },
-      });
-
-      machine.send('GO');
-
-      expect(entryHook).toHaveBeenCalledWith({ value: 42 });
-    });
-
-    it('calls exit and entry on self-transitions', () => {
-      const exitHook = vi.fn();
-      const entryHook = vi.fn();
-
-      const machine = createMachine({
-        initial: 'active',
-        states: {
-          active: {
-            on: { REFRESH: 'active' },
-            entry: entryHook,
-            exit: exitHook,
-          },
-        },
-      });
-
-      machine.send('REFRESH');
-
-      expect(exitHook).toHaveBeenCalledOnce();
-      expect(entryHook).toHaveBeenCalledOnce();
-    });
-  });
-
-  describe('StateMachine class', () => {
-    it('can be instantiated directly', () => {
-      const machine = new StateMachine<'on' | 'off', 'TOGGLE'>(
-        'off',
-        {
-          off: { on: { TOGGLE: 'on' } },
-          on: { on: { TOGGLE: 'off' } },
-        },
-        undefined,
-      );
-
-      expect(machine.current).toBe('off');
-
-      machine.send('TOGGLE');
-
-      expect(machine.current).toBe('on');
-
-      machine.send('TOGGLE');
-
-      expect(machine.current).toBe('off');
-    });
-  });
-
-  describe('edge cases', () => {
-    it('handles state with no transitions', () => {
-      const machine = createMachine({
-        initial: 'start',
-        states: {
-          start: {
-            on: { GO: 'end' },
-          },
-          end: {},
-        },
-      });
-
-      machine.send('GO');
-
-      expect(machine.current).toBe('end');
-      expect(machine.send('GO')).toBe('end');
-    });
-
-    it('handles action that modifies context before guard on next transition', () => {
-      const machine = createMachine({
-        initial: 'a',
-        context: { step: 0 },
-        states: {
-          a: {
-            on: {
-              NEXT: {
-                target: 'b',
-                action: (ctx) => { ctx.step = 1; },
-              },
-            },
-          },
-          b: {
-            on: {
-              NEXT: {
-                target: 'c',
-                guard: (ctx) => ctx.step === 1,
-                action: (ctx) => { ctx.step = 2; },
-              },
-            },
-          },
-          c: {},
-        },
-      });
-
-      machine.send('NEXT');
-      machine.send('NEXT');
-
-      expect(machine.current).toBe('c');
-      expect(machine.context.step).toBe(2);
-    });
-  });
-});
-
-describe('asyncStateMachine', () => {
-  describe('createAsyncMachine (without context)', () => {
-    it('handles simple string transitions', async () => {
-      const machine = createAsyncMachine({
-        initial: 'idle',
-        states: {
-          idle: { on: { START: 'running' } },
-          running: { on: { STOP: 'idle' } },
-        },
-      });
-
-      const result = await machine.send('START');
-
-      expect(result).toBe('running');
-      expect(machine.current).toBe('running');
-    });
-
-    it('ignores unhandled events', async () => {
-      const machine = createAsyncMachine({
-        initial: 'idle',
-        states: {
-          idle: { on: { START: 'running' } },
-          running: {},
-        },
-      });
-
-      const result = await machine.send('STOP');
-
-      expect(result).toBe('idle');
-    });
-  });
-
-  describe('async guards', () => {
-    it('allows transition on async guard returning true', async () => {
-      const machine = createAsyncMachine({
-        initial: 'idle',
-        context: { allowed: true },
-        states: {
-          idle: {
-            on: {
-              GO: {
-                target: 'active',
-                guard: async (ctx) => ctx.allowed,
-              },
-            },
-          },
-          active: {},
-        },
-      });
-
-      await machine.send('GO');
-
-      expect(machine.current).toBe('active');
-    });
-
-    it('blocks transition on async guard returning false', async () => {
-      const machine = createAsyncMachine({
-        initial: 'idle',
-        context: { allowed: false },
-        states: {
-          idle: {
-            on: {
-              GO: {
-                target: 'active',
-                guard: async (ctx) => ctx.allowed,
-              },
-            },
-          },
-          active: {},
-        },
-      });
-
-      await machine.send('GO');
-
-      expect(machine.current).toBe('idle');
-    });
-  });
-
-  describe('async actions', () => {
-    it('awaits async action before entering target', async () => {
-      const order: string[] = [];
-
-      const machine = createAsyncMachine({
-        initial: 'idle',
-        context: { data: '' },
-        states: {
-          idle: {
-            on: {
-              FETCH: {
-                target: 'done',
-                action: async (ctx) => {
-                  await new Promise((r) => setTimeout(r, 10));
-                  ctx.data = 'fetched';
-                  order.push('action');
-                },
-              },
-            },
-          },
-          done: {
-            entry: () => { order.push('entry'); },
-          },
-        },
-      });
-
-      await machine.send('FETCH');
-
-      expect(machine.context.data).toBe('fetched');
-      expect(order).toEqual(['action', 'entry']);
-    });
-  });
-
-  describe('async entry/exit hooks', () => {
-    it('awaits async exit and entry hooks in order', async () => {
-      const order: string[] = [];
-
-      const machine = createAsyncMachine({
-        initial: 'a',
-        states: {
-          a: {
-            on: { GO: 'b' },
-            exit: async () => {
-              await new Promise((r) => setTimeout(r, 10));
-              order.push('exit-a');
-            },
-          },
-          b: {
-            entry: async () => {
-              await new Promise((r) => setTimeout(r, 10));
-              order.push('entry-b');
-            },
-          },
-        },
-      });
-
-      await machine.send('GO');
-
-      expect(machine.current).toBe('b');
-      expect(order).toEqual(['exit-a', 'entry-b']);
-    });
-
-    it('does not call hooks when async guard blocks', async () => {
-      const exitHook = vi.fn();
-      const entryHook = vi.fn();
-
-      const machine = createAsyncMachine({
-        initial: 'locked',
-        context: { unlocked: false },
-        states: {
-          locked: {
-            on: {
-              UNLOCK: {
-                target: 'unlocked',
-                guard: async (ctx) => ctx.unlocked,
-              },
-            },
-            exit: exitHook,
-          },
-          unlocked: {
-            entry: entryHook,
-          },
-        },
-      });
-
-      await machine.send('UNLOCK');
-
-      expect(exitHook).not.toHaveBeenCalled();
-      expect(entryHook).not.toHaveBeenCalled();
-      expect(machine.current).toBe('locked');
-    });
-  });
-
-  describe('can()', () => {
-    it('evaluates async guard', async () => {
-      const machine = createAsyncMachine({
-        initial: 'idle',
-        context: { ready: true },
-        states: {
-          idle: {
-            on: {
-              GO: {
-                target: 'active',
-                guard: async (ctx) => ctx.ready,
-              },
-            },
-          },
-          active: {},
-        },
-      });
-
-      expect(await machine.can('GO')).toBe(true);
-
-      machine.context.ready = false;
-
-      expect(await machine.can('GO')).toBe(false);
-    });
-
-    it('returns false for undefined events', async () => {
-      const machine = createAsyncMachine({
-        initial: 'idle',
-        states: {
-          idle: { on: { START: 'running' } },
-          running: {},
-        },
-      });
-
-      expect(await machine.can('STOP')).toBe(false);
-    });
-
-    it('returns true for transitions without guard', async () => {
-      const machine = createAsyncMachine({
-        initial: 'idle',
-        states: {
-          idle: { on: { START: 'running' } },
-          running: {},
-        },
-      });
-
-      expect(await machine.can('START')).toBe(true);
-    });
-  });
-
-  describe('matches()', () => {
-    it('checks current state synchronously', async () => {
-      const machine = createAsyncMachine({
-        initial: 'idle',
-        states: {
-          idle: { on: { GO: 'active' } },
-          active: {},
-        },
-      });
-
-      expect(machine.matches('idle')).toBe(true);
-
-      await machine.send('GO');
-
-      expect(machine.matches('active')).toBe(true);
-      expect(machine.matches('idle')).toBe(false);
-    });
-  });
-
-  describe('AsyncStateMachine class', () => {
-    it('can be instantiated directly', async () => {
-      const machine = new AsyncStateMachine<'on' | 'off', 'TOGGLE'>(
-        'off',
-        {
-          off: { on: { TOGGLE: 'on' } },
-          on: { on: { TOGGLE: 'off' } },
-        },
-        undefined,
-      );
-
-      expect(machine.current).toBe('off');
-
-      await machine.send('TOGGLE');
-
-      expect(machine.current).toBe('on');
-
-      await machine.send('TOGGLE');
-
-      expect(machine.current).toBe('off');
-    });
-  });
-
-  describe('sync callbacks work too', () => {
-    it('handles sync guard/action/hooks in async machine', async () => {
-      const entryHook = vi.fn();
-
-      const machine = createAsyncMachine({
-        initial: 'idle',
-        context: { count: 0 },
-        states: {
-          idle: {
-            on: {
-              GO: {
-                target: 'active',
-                guard: (ctx) => ctx.count === 0,
-                action: (ctx) => { ctx.count++; },
-              },
-            },
-          },
-          active: {
-            entry: entryHook,
-          },
-        },
-      });
-
-      await machine.send('GO');
-
-      expect(machine.current).toBe('active');
-      expect(machine.context.count).toBe(1);
-      expect(entryHook).toHaveBeenCalledOnce();
-    });
-  });
-});

core/stdlib/src/patterns/behavioral/StateMachine/index.ts

@@ -1,3 +0,0 @@
-export type * from './types';
-export * from './sync';
-export * from './async';

core/stdlib/src/patterns/behavioral/StateMachine/sync.ts

@@ -1,134 +0,0 @@
-import { isString } from '../../../types';
-import { BaseStateMachine } from './base';
-import type { SyncStateNodeConfig, ExtractStates, ExtractEvents } from './types';
-
-/**
- * @name StateMachine
- * @category Patterns
- * @description Simple, performant, and type-safe finite state machine
- *
- * @since 0.0.8
- *
- * @template States - Union of state names
- * @template Events - Union of event names
- * @template Context - Machine context type
- */
-export class StateMachine<
-  States extends string = string,
-  Events extends string = string,
-  Context = undefined,
-> extends BaseStateMachine<States, Events, Context, SyncStateNodeConfig<Context>> {
-  /**
-   * Send an event to the machine, potentially causing a state transition
-   *
-   * @param event - Event name
-   * @returns The current state after processing the event
-   */
-  send(event: Events): States {
-    const stateNode = this.states[this.currentState];
-
-    if (!stateNode?.on)
-      return this.currentState;
-
-    const transition = stateNode.on[event];
-
-    if (transition === undefined)
-      return this.currentState;
-
-    let target: string;
-
-    if (isString(transition)) {
-      target = transition;
-    } else {
-      if (transition.guard && !transition.guard(this.context))
-        return this.currentState;
-
-      transition.action?.(this.context);
-      target = transition.target;
-    }
-
-    stateNode.exit?.(this.context);
-    this.currentState = target as States;
-    this.states[this.currentState]?.entry?.(this.context);
-
-    return this.currentState;
-  }
-
-  /**
-   * Check if an event can trigger a transition from the current state
-   *
-   * @param event - Event to check
-   */
-  can(event: Events): boolean {
-    const stateNode = this.states[this.currentState];
-
-    if (!stateNode?.on)
-      return false;
-
-    const transition = stateNode.on[event];
-
-    if (transition === undefined)
-      return false;
-
-    if (!isString(transition) && transition.guard)
-      return transition.guard(this.context);
-
-    return true;
-  }
-}
-
-/**
- * Create a type-safe synchronous finite state machine with context
- *
- * @example
- * ```ts
- * const machine = createMachine({
- *   initial: 'idle',
- *   context: { retries: 0 },
- *   states: {
- *     idle: {
- *       on: { START: 'running' },
- *     },
- *     running: {
- *       on: {
- *         FAIL: {
- *           target: 'idle',
- *           guard: (ctx) => ctx.retries < 3,
- *           action: (ctx) => { ctx.retries++; },
- *         },
- *         STOP: 'idle',
- *       },
- *     },
- *   },
- * });
- *
- * machine.send('START'); // 'running'
- * ```
- */
-export function createMachine<
-  const States extends Record<string, SyncStateNodeConfig<Context>>,
-  Context,
->(config: {
-  initial: NoInfer<ExtractStates<States>>;
-  context: Context;
-  states: States;
-}): StateMachine<ExtractStates<States>, ExtractEvents<States>, Context>;
-
-export function createMachine<
-  const States extends Record<string, SyncStateNodeConfig<undefined>>,
->(config: {
-  initial: NoInfer<ExtractStates<States>>;
-  states: States;
-}): StateMachine<ExtractStates<States>, ExtractEvents<States>, undefined>;
-
-export function createMachine(config: {
-  initial: string;
-  context?: unknown;
-  states: Record<string, SyncStateNodeConfig<any>>;
-}): StateMachine {
-  return new StateMachine(
-    config.initial,
-    config.states,
-    config.context as undefined,
-  );
-}

core/stdlib/src/patterns/behavioral/StateMachine/types.ts

@@ -1,64 +0,0 @@
-import type { MaybePromise } from '../../../types';
-
-/**
- * Configuration for a state transition
- *
- * @template Context - Machine context type
- * @template Guard - Guard return type (boolean or MaybePromise\<boolean\>)
- * @template Action - Action return type (void or MaybePromise\<void\>)
- */
-export interface TransitionConfig<
-  Context,
-  Guard = boolean,
-  Action = void,
-> {
-  /** Target state to transition to */
-  target: string;
-  /** Guard condition — transition only occurs if this returns true */
-  guard?: (context: Context) => Guard;
-  /** Side effect executed during transition (before entering target state) */
-  action?: (context: Context) => Action;
-}
-
-/**
- * A transition can be a target state name or a detailed configuration
- */
-export type Transition<
-  Context,
-  Guard = boolean,
-  Action = void,
-> = string | TransitionConfig<Context, Guard, Action>;
-
-/**
- * Configuration for a state node
- *
- * @template Context - Machine context type
- * @template Guard - Guard return type
- * @template Hook - Hook return type (entry/exit/action)
- */
-export interface StateNodeConfig<
-  Context,
-  Guard = boolean,
-  Hook = void,
-> {
-  /** Map of event names to transitions */
-  on?: Record<string, Transition<Context, Guard, Hook>>;
-  /** Hook called when entering this state */
-  entry?: (context: Context) => Hook;
-  /** Hook called when exiting this state */
-  exit?: (context: Context) => Hook;
-}
-
-/** Sync state node config — guards return boolean, hooks return void */
-export type SyncStateNodeConfig<Context> = StateNodeConfig<Context, boolean, void>;
-
-/** Async state node config — guards return MaybePromise\<boolean\>, hooks return MaybePromise\<void\> */
-export type AsyncStateNodeConfig<Context> = StateNodeConfig<Context, MaybePromise<boolean>, MaybePromise<void>>;
-
-export type ExtractStates<T> = keyof T & string;
-
-export type ExtractEvents<T> = {
-  [K in keyof T]: T[K] extends { readonly on?: Readonly<Record<infer E extends string, any>> }
-    ? E
-    : never;
-}[keyof T];

core/stdlib/src/patterns/index.ts

@@ -1,3 +0,0 @@
-export * from './behavioral/Command';
-export * from './behavioral/PubSub';
-export * from './behavioral/StateMachine';

core/stdlib/src/structs/BinaryHeap/index.test.ts

@@ -1,229 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { BinaryHeap } from '.';
-
-describe('BinaryHeap', () => {
-    describe('constructor', () => {
-        it('should create an empty heap', () => {
-            const heap = new BinaryHeap<number>();
-
-            expect(heap.length).toBe(0);
-            expect(heap.isEmpty).toBe(true);
-        });
-
-        it('should create a heap from single value', () => {
-            const heap = new BinaryHeap(42);
-
-            expect(heap.length).toBe(1);
-            expect(heap.peek()).toBe(42);
-        });
-
-        it('should create a heap from array (heapify)', () => {
-            const heap = new BinaryHeap([5, 3, 8, 1, 4]);
-
-            expect(heap.length).toBe(5);
-            expect(heap.peek()).toBe(1);
-        });
-
-        it('should accept a custom comparator for max-heap', () => {
-            const heap = new BinaryHeap([5, 3, 8, 1, 4], {
-                comparator: (a, b) => b - a,
-            });
-
-            expect(heap.peek()).toBe(8);
-        });
-    });
-
-    describe('push', () => {
-        it('should insert elements maintaining heap property', () => {
-            const heap = new BinaryHeap<number>();
-
-            heap.push(5);
-            heap.push(3);
-            heap.push(8);
-            heap.push(1);
-
-            expect(heap.peek()).toBe(1);
-            expect(heap.length).toBe(4);
-        });
-
-        it('should handle duplicate values', () => {
-            const heap = new BinaryHeap<number>();
-
-            heap.push(3);
-            heap.push(3);
-            heap.push(3);
-
-            expect(heap.length).toBe(3);
-            expect(heap.peek()).toBe(3);
-        });
-    });
-
-    describe('pop', () => {
-        it('should return undefined for empty heap', () => {
-            const heap = new BinaryHeap<number>();
-
-            expect(heap.pop()).toBeUndefined();
-        });
-
-        it('should extract elements in min-heap order', () => {
-            const heap = new BinaryHeap([5, 3, 8, 1, 4, 2, 7, 6]);
-            const sorted: number[] = [];
-
-            while (!heap.isEmpty) {
-                sorted.push(heap.pop()!);
-            }
-
-            expect(sorted).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
-        });
-
-        it('should extract elements in max-heap order with custom comparator', () => {
-            const heap = new BinaryHeap([5, 3, 8, 1, 4], {
-                comparator: (a, b) => b - a,
-            });
-            const sorted: number[] = [];
-
-            while (!heap.isEmpty) {
-                sorted.push(heap.pop()!);
-            }
-
-            expect(sorted).toEqual([8, 5, 4, 3, 1]);
-        });
-
-        it('should handle single element', () => {
-            const heap = new BinaryHeap(42);
-
-            expect(heap.pop()).toBe(42);
-            expect(heap.isEmpty).toBe(true);
-        });
-    });
-
-    describe('peek', () => {
-        it('should return undefined for empty heap', () => {
-            const heap = new BinaryHeap<number>();
-
-            expect(heap.peek()).toBeUndefined();
-        });
-
-        it('should return root without removing it', () => {
-            const heap = new BinaryHeap([5, 3, 1]);
-
-            expect(heap.peek()).toBe(1);
-            expect(heap.length).toBe(3);
-        });
-    });
-
-    describe('clear', () => {
-        it('should remove all elements', () => {
-            const heap = new BinaryHeap([1, 2, 3]);
-
-            const result = heap.clear();
-
-            expect(heap.length).toBe(0);
-            expect(heap.isEmpty).toBe(true);
-            expect(result).toBe(heap);
-        });
-    });
-
-    describe('toArray', () => {
-        it('should return empty array for empty heap', () => {
-            const heap = new BinaryHeap<number>();
-
-            expect(heap.toArray()).toEqual([]);
-        });
-
-        it('should return a shallow copy', () => {
-            const heap = new BinaryHeap([3, 1, 2]);
-            const arr = heap.toArray();
-
-            arr.push(99);
-
-            expect(heap.length).toBe(3);
-        });
-    });
-
-    describe('toString', () => {
-        it('should return formatted string', () => {
-            const heap = new BinaryHeap([1, 2, 3]);
-
-            expect(heap.toString()).toBe('BinaryHeap(3)');
-        });
-    });
-
-    describe('iterator', () => {
-        it('should iterate over heap elements', () => {
-            const heap = new BinaryHeap([5, 3, 8, 1]);
-            const elements = [...heap];
-
-            expect(elements.length).toBe(4);
-            expect(elements[0]).toBe(1);
-        });
-    });
-
-    describe('custom comparator', () => {
-        it('should work with string length comparator', () => {
-            const heap = new BinaryHeap(['banana', 'apple', 'kiwi', 'fig'], {
-                comparator: (a, b) => a.length - b.length,
-            });
-
-            expect(heap.pop()).toBe('fig');
-            expect(heap.pop()).toBe('kiwi');
-        });
-
-        it('should work with object comparator', () => {
-            interface Task {
-                priority: number;
-                name: string;
-            }
-
-            const heap = new BinaryHeap<Task>(
-                [
-                    { priority: 3, name: 'low' },
-                    { priority: 1, name: 'high' },
-                    { priority: 2, name: 'medium' },
-                ],
-                { comparator: (a, b) => a.priority - b.priority },
-            );
-
-            expect(heap.pop()?.name).toBe('high');
-            expect(heap.pop()?.name).toBe('medium');
-            expect(heap.pop()?.name).toBe('low');
-        });
-    });
-
-    describe('heapify', () => {
-        it('should correctly heapify large arrays', () => {
-            const values = Array.from({ length: 1000 }, () => Math.random() * 1000 | 0);
-            const heap = new BinaryHeap(values);
-            const sorted: number[] = [];
-
-            while (!heap.isEmpty) {
-                sorted.push(heap.pop()!);
-            }
-
-            const expected = [...values].sort((a, b) => a - b);
-
-            expect(sorted).toEqual(expected);
-        });
-    });
-
-    describe('interleaved operations', () => {
-        it('should maintain heap property with mixed push and pop', () => {
-            const heap = new BinaryHeap<number>();
-
-            heap.push(10);
-            heap.push(5);
-            expect(heap.pop()).toBe(5);
-
-            heap.push(3);
-            heap.push(7);
-            expect(heap.pop()).toBe(3);
-
-            heap.push(1);
-            expect(heap.pop()).toBe(1);
-            expect(heap.pop()).toBe(7);
-            expect(heap.pop()).toBe(10);
-            expect(heap.pop()).toBeUndefined();
-        });
-    });
-});

core/stdlib/src/structs/BinaryHeap/index.ts

@@ -1,220 +0,0 @@
-import { first } from '../../arrays';
-import { isArray } from '../../types';
-import type { BinaryHeapLike, Comparator } from './types';
-
-export type { BinaryHeapLike, Comparator } from './types';
-
-export interface BinaryHeapOptions<T> {
-    comparator?: Comparator<T>;
-}
-
-/**
- * Default min-heap comparator for numeric values
- *
- * @param {number} a First element
- * @param {number} b Second element
- * @returns {number} Negative if a < b, positive if a > b, zero if equal
- */
-const defaultComparator: Comparator<any> = (a: number, b: number) => a - b;
-
-/**
- * @name BinaryHeap
- * @category Data Structures
- * @description Binary heap backed by a flat array with configurable comparator
- *
- * @since 0.0.8
- *
- * @template T The type of elements stored in the heap
- */
-export class BinaryHeap<T> implements BinaryHeapLike<T> {
-    /**
-     * The comparator function used to order elements
-     *
-     * @private
-     * @type {Comparator<T>}
-     */
-    private readonly comparator: Comparator<T>;
-
-    /**
-     * Internal flat array backing the heap
-     *
-     * @private
-     * @type {T[]}
-     */
-    private readonly heap: T[] = [];
-
-    /**
-     * Creates an instance of BinaryHeap
-     *
-     * @param {(T[] | T)} [initialValues] The initial values to heapify
-     * @param {BinaryHeapOptions<T>} [options] Heap configuration
-     */
-    constructor(initialValues?: T[] | T, options?: BinaryHeapOptions<T>) {
-        this.comparator = options?.comparator ?? defaultComparator;
-
-        if (initialValues !== null && initialValues !== undefined) {
-            const items = isArray(initialValues) ? initialValues : [initialValues];
-            this.heap.push(...items);
-            this.heapify();
-        }
-    }
-
-    /**
-     * Gets the number of elements in the heap
-     * @returns {number} The number of elements in the heap
-     */
-    public get length(): number {
-        return this.heap.length;
-    }
-
-    /**
-     * Checks if the heap is empty
-     * @returns {boolean} `true` if the heap is empty, `false` otherwise
-     */
-    public get isEmpty(): boolean {
-        return this.heap.length === 0;
-    }
-
-    /**
-     * Pushes an element into the heap
-     * @param {T} element The element to insert
-     */
-    public push(element: T): void {
-        this.heap.push(element);
-        this.siftUp(this.heap.length - 1);
-    }
-
-    /**
-     * Removes and returns the root element (min or max depending on comparator)
-     * @returns {T | undefined} The root element, or `undefined` if the heap is empty
-     */
-    public pop(): T | undefined {
-        if (this.heap.length === 0) return undefined;
-
-        const root = first(this.heap)!;
-        const last = this.heap.pop()!;
-
-        if (this.heap.length > 0) {
-            this.heap[0] = last;
-            this.siftDown(0);
-        }
-
-        return root;
-    }
-
-    /**
-     * Returns the root element without removing it
-     * @returns {T | undefined} The root element, or `undefined` if the heap is empty
-     */
-    public peek(): T | undefined {
-        return first(this.heap);
-    }
-
-    /**
-     * Removes all elements from the heap
-     * @returns {this} The heap instance for chaining
-     */
-    public clear(): this {
-        this.heap.length = 0;
-        return this;
-    }
-
-    /**
-     * Returns a shallow copy of the heap elements as an array (heap order, not sorted)
-     * @returns {T[]} Array of elements in heap order
-     */
-    public toArray(): T[] {
-        return this.heap.slice();
-    }
-
-    /**
-     * Returns a string representation of the heap
-     * @returns {string} String representation
-     */
-    public toString(): string {
-        return `BinaryHeap(${this.heap.length})`;
-    }
-
-    /**
-     * Iterator over heap elements in heap order
-     */
-    public *[Symbol.iterator](): Iterator<T> {
-        yield* this.heap;
-    }
-
-    /**
-     * Async iterator over heap elements in heap order
-     */
-    public async *[Symbol.asyncIterator](): AsyncIterator<T> {
-        for (const element of this.heap)
-            yield element;
-    }
-
-    /**
-     * Restores heap property by sifting an element up
-     *
-     * @private
-     * @param {number} index The index of the element to sift up
-     */
-    private siftUp(index: number): void {
-        const heap = this.heap;
-        const cmp = this.comparator;
-
-        while (index > 0) {
-            const parent = (index - 1) >> 1;
-
-            if (cmp(heap[index]!, heap[parent]!) >= 0) break;
-
-            const temp = heap[index]!;
-            heap[index] = heap[parent]!;
-            heap[parent] = temp;
-
-            index = parent;
-        }
-    }
-
-    /**
-     * Restores heap property by sifting an element down
-     *
-     * @private
-     * @param {number} index The index of the element to sift down
-     */
-    private siftDown(index: number): void {
-        const heap = this.heap;
-        const cmp = this.comparator;
-        const length = heap.length;
-
-        while (true) {
-            let smallest = index;
-            const left = 2 * index + 1;
-            const right = 2 * index + 2;
-
-            if (left < length && cmp(heap[left]!, heap[smallest]!) < 0) {
-                smallest = left;
-            }
-
-            if (right < length && cmp(heap[right]!, heap[smallest]!) < 0) {
-                smallest = right;
-            }
-
-            if (smallest === index) break;
-
-            const temp = heap[index]!;
-            heap[index] = heap[smallest]!;
-            heap[smallest] = temp;
-
-            index = smallest;
-        }
-    }
-
-    /**
-     * Builds heap from unordered array in O(n) using Floyd's algorithm
-     *
-     * @private
-     */
-    private heapify(): void {
-        for (let i = (this.heap.length >> 1) - 1; i >= 0; i--) {
-            this.siftDown(i);
-        }
-    }
-}

core/stdlib/src/structs/BinaryHeap/types.ts

@@ -1,13 +0,0 @@
-export type Comparator<T> = (a: T, b: T) => number;
-
-export interface BinaryHeapLike<T> extends Iterable<T>, AsyncIterable<T> {
-  readonly length: number;
-  readonly isEmpty: boolean;
-
-  push(element: T): void;
-  pop(): T | undefined;
-  peek(): T | undefined;
-  clear(): this;
-  toArray(): T[];
-  toString(): string;
-}

core/stdlib/src/structs/CircularBuffer/index.test.ts

@@ -1,247 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CircularBuffer } from '.';
-
-describe('circularBuffer', () => {
-  describe('constructor', () => {
-    it('create an empty buffer', () => {
-      const buf = new CircularBuffer<number>();
-
-      expect(buf.length).toBe(0);
-      expect(buf.isEmpty).toBe(true);
-      expect(buf.capacity).toBeGreaterThanOrEqual(4);
-    });
-
-    it('create a buffer with initial array', () => {
-      const buf = new CircularBuffer([1, 2, 3]);
-
-      expect(buf.length).toBe(3);
-      expect(buf.peekFront()).toBe(1);
-      expect(buf.peekBack()).toBe(3);
-    });
-
-    it('create a buffer with a single value', () => {
-      const buf = new CircularBuffer(42);
-
-      expect(buf.length).toBe(1);
-      expect(buf.peekFront()).toBe(42);
-    });
-
-    it('create a buffer with initial capacity hint', () => {
-      const buf = new CircularBuffer<number>(undefined, 32);
-
-      expect(buf.capacity).toBe(32);
-    });
-
-    it('round capacity up to next power of two', () => {
-      const buf = new CircularBuffer<number>(undefined, 5);
-
-      expect(buf.capacity).toBe(8);
-    });
-  });
-
-  describe('pushBack / popFront', () => {
-    it('FIFO order', () => {
-      const buf = new CircularBuffer<number>();
-      buf.pushBack(1);
-      buf.pushBack(2);
-      buf.pushBack(3);
-
-      expect(buf.popFront()).toBe(1);
-      expect(buf.popFront()).toBe(2);
-      expect(buf.popFront()).toBe(3);
-    });
-  });
-
-  describe('pushFront / popBack', () => {
-    it('LIFO order', () => {
-      const buf = new CircularBuffer<number>();
-      buf.pushFront(1);
-      buf.pushFront(2);
-      buf.pushFront(3);
-
-      expect(buf.popBack()).toBe(1);
-      expect(buf.popBack()).toBe(2);
-      expect(buf.popBack()).toBe(3);
-    });
-  });
-
-  describe('popFront', () => {
-    it('return undefined if empty', () => {
-      const buf = new CircularBuffer<number>();
-
-      expect(buf.popFront()).toBeUndefined();
-    });
-  });
-
-  describe('popBack', () => {
-    it('return undefined if empty', () => {
-      const buf = new CircularBuffer<number>();
-
-      expect(buf.popBack()).toBeUndefined();
-    });
-  });
-
-  describe('peekFront / peekBack', () => {
-    it('return elements without removing', () => {
-      const buf = new CircularBuffer([1, 2, 3]);
-
-      expect(buf.peekFront()).toBe(1);
-      expect(buf.peekBack()).toBe(3);
-      expect(buf.length).toBe(3);
-    });
-
-    it('return undefined if empty', () => {
-      const buf = new CircularBuffer<number>();
-
-      expect(buf.peekFront()).toBeUndefined();
-      expect(buf.peekBack()).toBeUndefined();
-    });
-  });
-
-  describe('get', () => {
-    it('access element by logical index', () => {
-      const buf = new CircularBuffer([10, 20, 30]);
-
-      expect(buf.get(0)).toBe(10);
-      expect(buf.get(1)).toBe(20);
-      expect(buf.get(2)).toBe(30);
-    });
-
-    it('return undefined for out-of-bounds', () => {
-      const buf = new CircularBuffer([1, 2]);
-
-      expect(buf.get(-1)).toBeUndefined();
-      expect(buf.get(2)).toBeUndefined();
-    });
-
-    it('work correctly after wrap-around', () => {
-      const buf = new CircularBuffer<number>(undefined, 4);
-
-      buf.pushBack(1);
-      buf.pushBack(2);
-      buf.pushBack(3);
-      buf.pushBack(4);
-      buf.popFront();
-      buf.popFront();
-      buf.pushBack(5);
-      buf.pushBack(6);
-
-      expect(buf.get(0)).toBe(3);
-      expect(buf.get(1)).toBe(4);
-      expect(buf.get(2)).toBe(5);
-      expect(buf.get(3)).toBe(6);
-    });
-  });
-
-  describe('clear', () => {
-    it('clear the buffer', () => {
-      const buf = new CircularBuffer([1, 2, 3]);
-      buf.clear();
-
-      expect(buf.length).toBe(0);
-      expect(buf.isEmpty).toBe(true);
-    });
-
-    it('return this for chaining', () => {
-      const buf = new CircularBuffer([1]);
-
-      expect(buf.clear()).toBe(buf);
-    });
-  });
-
-  describe('auto-grow', () => {
-    it('grow when capacity is exceeded', () => {
-      const buf = new CircularBuffer<number>();
-      const initialCapacity = buf.capacity;
-
-      for (let i = 0; i < initialCapacity + 1; i++)
-        buf.pushBack(i);
-
-      expect(buf.length).toBe(initialCapacity + 1);
-      expect(buf.capacity).toBe(initialCapacity * 2);
-    });
-
-    it('preserve order after grow', () => {
-      const buf = new CircularBuffer<number>(undefined, 4);
-
-      buf.pushBack(1);
-      buf.pushBack(2);
-      buf.popFront();
-      buf.pushBack(3);
-      buf.pushBack(4);
-      buf.pushBack(5);
-      buf.pushBack(6);
-
-      expect(buf.toArray()).toEqual([2, 3, 4, 5, 6]);
-    });
-  });
-
-  describe('wrap-around', () => {
-    it('handle wrap-around correctly', () => {
-      const buf = new CircularBuffer<number>(undefined, 4);
-
-      buf.pushBack(1);
-      buf.pushBack(2);
-      buf.pushBack(3);
-      buf.pushBack(4);
-      buf.popFront();
-      buf.popFront();
-      buf.pushBack(5);
-      buf.pushBack(6);
-
-      expect(buf.toArray()).toEqual([3, 4, 5, 6]);
-    });
-
-    it('handle alternating front/back', () => {
-      const buf = new CircularBuffer<number>();
-
-      buf.pushFront(3);
-      buf.pushBack(4);
-      buf.pushFront(2);
-      buf.pushBack(5);
-      buf.pushFront(1);
-
-      expect(buf.toArray()).toEqual([1, 2, 3, 4, 5]);
-    });
-  });
-
-  describe('toArray', () => {
-    it('return elements front to back', () => {
-      const buf = new CircularBuffer([1, 2, 3]);
-
-      expect(buf.toArray()).toEqual([1, 2, 3]);
-    });
-
-    it('return empty array if empty', () => {
-      const buf = new CircularBuffer<number>();
-
-      expect(buf.toArray()).toEqual([]);
-    });
-  });
-
-  describe('toString', () => {
-    it('return comma-separated string', () => {
-      const buf = new CircularBuffer([1, 2, 3]);
-
-      expect(buf.toString()).toBe('1,2,3');
-    });
-  });
-
-  describe('iteration', () => {
-    it('iterate front to back', () => {
-      const buf = new CircularBuffer([1, 2, 3]);
-
-      expect([...buf]).toEqual([1, 2, 3]);
-    });
-
-    it('iterate asynchronously', async () => {
-      const buf = new CircularBuffer([1, 2, 3]);
-      const elements: number[] = [];
-
-      for await (const element of buf)
-        elements.push(element);
-
-      expect(elements).toEqual([1, 2, 3]);
-    });
-  });
-});

core/stdlib/src/structs/CircularBuffer/index.ts

@@ -1,277 +0,0 @@
-import { isArray } from '../../types';
-import type { CircularBufferLike } from './types';
-
-export type { CircularBufferLike } from './types';
-
-const MIN_CAPACITY = 4;
-
-/**
- * @name CircularBuffer
- * @category Data Structures
- * @description A circular (ring) buffer with automatic growth, O(1) push/pop on both ends
- *
- * @since 0.0.8
- *
- * @template T The type of elements stored in the buffer
- */
-export class CircularBuffer<T> implements CircularBufferLike<T> {
-  /**
-   * The internal storage
-   *
-   * @private
-   * @type {(T | undefined)[]}
-   */
-  private buffer: Array<T | undefined>;
-
-  /**
-   * The index of the front element
-   *
-   * @private
-   * @type {number}
-   */
-  private head: number;
-
-  /**
-   * The number of elements in the buffer
-   *
-   * @private
-   * @type {number}
-   */
-  private count: number;
-
-  /**
-   * Creates an instance of CircularBuffer
-   *
-   * @param {(T[] | T)} [initialValues] The initial values to add to the buffer
-   * @param {number} [initialCapacity] The initial capacity hint (rounded up to next power of two)
-   */
-  constructor(initialValues?: T[] | T, initialCapacity?: number) {
-    this.head = 0;
-    this.count = 0;
-
-    const items = isArray(initialValues) ? initialValues : initialValues !== undefined ? [initialValues] : [];
-    const requested = Math.max(items.length, initialCapacity ?? 0);
-    const cap = Math.max(MIN_CAPACITY, nextPowerOfTwo(requested));
-
-    this.buffer = Array.from<T | undefined>({ length: cap });
-
-    for (const item of items)
-      this.pushBack(item);
-  }
-
-  /**
-   * Gets the number of elements in the buffer
-   * @returns {number}
-   */
-  get length() {
-    return this.count;
-  }
-
-  /**
-   * Gets the current capacity of the buffer
-   * @returns {number}
-   */
-  get capacity() {
-    return this.buffer.length;
-  }
-
-  /**
-   * Checks if the buffer is empty
-   * @returns {boolean}
-   */
-  get isEmpty() {
-    return this.count === 0;
-  }
-
-  /**
-   * Checks if the buffer is at capacity (before auto-grow)
-   * @returns {boolean}
-   */
-  get isFull() {
-    return this.count === this.buffer.length;
-  }
-
-  /**
-   * Adds an element to the back of the buffer
-   * @param {T} element The element to add
-   */
-  pushBack(element: T) {
-    if (this.count === this.buffer.length)
-      this.grow();
-
-    this.buffer[(this.head + this.count) & (this.buffer.length - 1)] = element;
-    this.count++;
-  }
-
-  /**
-   * Adds an element to the front of the buffer
-   * @param {T} element The element to add
-   */
-  pushFront(element: T) {
-    if (this.count === this.buffer.length)
-      this.grow();
-
-    this.head = (this.head - 1 + this.buffer.length) & (this.buffer.length - 1);
-    this.buffer[this.head] = element;
-    this.count++;
-  }
-
-  /**
-   * Removes and returns the back element
-   * @returns {T | undefined} The back element, or undefined if empty
-   */
-  popBack() {
-    if (this.isEmpty)
-      return undefined;
-
-    const index = (this.head + this.count - 1) & (this.buffer.length - 1);
-    const element = this.buffer[index];
-
-    this.buffer[index] = undefined;
-    this.count--;
-
-    return element;
-  }
-
-  /**
-   * Removes and returns the front element
-   * @returns {T | undefined} The front element, or undefined if empty
-   */
-  popFront() {
-    if (this.isEmpty)
-      return undefined;
-
-    const element = this.buffer[this.head];
-
-    this.buffer[this.head] = undefined;
-    this.head = (this.head + 1) & (this.buffer.length - 1);
-    this.count--;
-
-    return element;
-  }
-
-  /**
-   * Returns the back element without removing it
-   * @returns {T | undefined}
-   */
-  peekBack() {
-    if (this.isEmpty)
-      return undefined;
-
-    return this.buffer[(this.head + this.count - 1) & (this.buffer.length - 1)];
-  }
-
-  /**
-   * Returns the front element without removing it
-   * @returns {T | undefined}
-   */
-  peekFront() {
-    if (this.isEmpty)
-      return undefined;
-
-    return this.buffer[this.head];
-  }
-
-  /**
-   * Gets element at logical index (0 = front)
-   * @param {number} index The logical index
-   * @returns {T | undefined}
-   */
-  get(index: number) {
-    if (index < 0 || index >= this.count)
-      return undefined;
-
-    return this.buffer[(this.head + index) & (this.buffer.length - 1)];
-  }
-
-  /**
-   * Clears the buffer
-   *
-   * @returns {this}
-   */
-  clear() {
-    this.buffer = Array.from<T | undefined>({ length: MIN_CAPACITY });
-    this.head = 0;
-    this.count = 0;
-
-    return this;
-  }
-
-  /**
-   * Converts the buffer to an array from front to back
-   *
-   * @returns {T[]}
-   */
-  toArray() {
-    const result = Array.from<T>({ length: this.count });
-
-    for (let i = 0; i < this.count; i++)
-      result[i] = this.buffer[(this.head + i) & (this.buffer.length - 1)] as T;
-
-    return result;
-  }
-
-  /**
-   * Returns a string representation
-   *
-   * @returns {string}
-   */
-  toString() {
-    return this.toArray().toString();
-  }
-
-  /**
-   * Returns an iterator (front to back)
-   *
-   * @returns {IterableIterator<T>}
-   */
-  [Symbol.iterator]() {
-    return this.toArray()[Symbol.iterator]();
-  }
-
-  /**
-   * Returns an async iterator (front to back)
-   *
-   * @returns {AsyncIterableIterator<T>}
-   */
-  async *[Symbol.asyncIterator]() {
-    for (const element of this)
-      yield element;
-  }
-
-  /**
-   * Doubles the buffer capacity and linearizes elements
-   *
-   * @private
-   */
-  private grow() {
-    const newCapacity = this.buffer.length << 1;
-    const newBuffer = Array.from<T | undefined>({ length: newCapacity });
-
-    for (let i = 0; i < this.count; i++)
-      newBuffer[i] = this.buffer[(this.head + i) & (this.buffer.length - 1)];
-
-    this.buffer = newBuffer;
-    this.head = 0;
-  }
-}
-
-/**
- * Returns the next power of two >= n
- *
- * @param {number} n
- * @returns {number}
- */
-function nextPowerOfTwo(n: number): number {
-  if (n <= 0)
-    return 1;
-
-  n--;
-  n |= n >> 1;
-  n |= n >> 2;
-  n |= n >> 4;
-  n |= n >> 8;
-  n |= n >> 16;
-
-  return n + 1;
-}

core/stdlib/src/structs/CircularBuffer/types.ts

@@ -1,17 +0,0 @@
-export interface CircularBufferLike<T> extends Iterable<T>, AsyncIterable<T> {
-  readonly length: number;
-  readonly capacity: number;
-  readonly isEmpty: boolean;
-  readonly isFull: boolean;
-
-  pushBack(element: T): void;
-  pushFront(element: T): void;
-  popBack(): T | undefined;
-  popFront(): T | undefined;
-  peekBack(): T | undefined;
-  peekFront(): T | undefined;
-  get(index: number): T | undefined;
-  clear(): this;
-  toArray(): T[];
-  toString(): string;
-}

core/stdlib/src/structs/Deque/index.test.ts

@@ -1,288 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Deque } from '.';
-
-describe('deque', () => {
-  describe('constructor', () => {
-    it('create an empty deque if no initial values are provided', () => {
-      const deque = new Deque<number>();
-
-      expect(deque.length).toBe(0);
-      expect(deque.isEmpty).toBe(true);
-    });
-
-    it('create a deque with the provided initial values', () => {
-      const deque = new Deque([1, 2, 3]);
-
-      expect(deque.length).toBe(3);
-      expect(deque.peekFront()).toBe(1);
-      expect(deque.peekBack()).toBe(3);
-    });
-
-    it('create a deque with a single initial value', () => {
-      const deque = new Deque(42);
-
-      expect(deque.length).toBe(1);
-      expect(deque.peekFront()).toBe(42);
-    });
-
-    it('create a deque with the provided options', () => {
-      const deque = new Deque<number>(undefined, { maxSize: 5 });
-
-      expect(deque.length).toBe(0);
-      expect(deque.isFull).toBe(false);
-    });
-  });
-
-  describe('pushBack', () => {
-    it('add an element to the back', () => {
-      const deque = new Deque<number>();
-      deque.pushBack(1).pushBack(2);
-
-      expect(deque.peekFront()).toBe(1);
-      expect(deque.peekBack()).toBe(2);
-      expect(deque.length).toBe(2);
-    });
-
-    it('throw an error if the deque is full', () => {
-      const deque = new Deque<number>(undefined, { maxSize: 1 });
-      deque.pushBack(1);
-
-      expect(() => deque.pushBack(2)).toThrow(new RangeError('Deque is full'));
-    });
-
-    it('return this for chaining', () => {
-      const deque = new Deque<number>();
-
-      expect(deque.pushBack(1)).toBe(deque);
-    });
-  });
-
-  describe('pushFront', () => {
-    it('add an element to the front', () => {
-      const deque = new Deque<number>();
-      deque.pushFront(1).pushFront(2);
-
-      expect(deque.peekFront()).toBe(2);
-      expect(deque.peekBack()).toBe(1);
-      expect(deque.length).toBe(2);
-    });
-
-    it('throw an error if the deque is full', () => {
-      const deque = new Deque<number>(undefined, { maxSize: 1 });
-      deque.pushFront(1);
-
-      expect(() => deque.pushFront(2)).toThrow(new RangeError('Deque is full'));
-    });
-
-    it('return this for chaining', () => {
-      const deque = new Deque<number>();
-
-      expect(deque.pushFront(1)).toBe(deque);
-    });
-  });
-
-  describe('popBack', () => {
-    it('remove and return the back element', () => {
-      const deque = new Deque([1, 2, 3]);
-
-      expect(deque.popBack()).toBe(3);
-      expect(deque.length).toBe(2);
-    });
-
-    it('return undefined if the deque is empty', () => {
-      const deque = new Deque<number>();
-
-      expect(deque.popBack()).toBeUndefined();
-    });
-  });
-
-  describe('popFront', () => {
-    it('remove and return the front element', () => {
-      const deque = new Deque([1, 2, 3]);
-
-      expect(deque.popFront()).toBe(1);
-      expect(deque.length).toBe(2);
-    });
-
-    it('return undefined if the deque is empty', () => {
-      const deque = new Deque<number>();
-
-      expect(deque.popFront()).toBeUndefined();
-    });
-  });
-
-  describe('peekBack', () => {
-    it('return the back element without removing it', () => {
-      const deque = new Deque([1, 2, 3]);
-
-      expect(deque.peekBack()).toBe(3);
-      expect(deque.length).toBe(3);
-    });
-
-    it('return undefined if the deque is empty', () => {
-      const deque = new Deque<number>();
-
-      expect(deque.peekBack()).toBeUndefined();
-    });
-  });
-
-  describe('peekFront', () => {
-    it('return the front element without removing it', () => {
-      const deque = new Deque([1, 2, 3]);
-
-      expect(deque.peekFront()).toBe(1);
-      expect(deque.length).toBe(3);
-    });
-
-    it('return undefined if the deque is empty', () => {
-      const deque = new Deque<number>();
-
-      expect(deque.peekFront()).toBeUndefined();
-    });
-  });
-
-  describe('clear', () => {
-    it('clear the deque', () => {
-      const deque = new Deque([1, 2, 3]);
-      deque.clear();
-
-      expect(deque.length).toBe(0);
-      expect(deque.isEmpty).toBe(true);
-    });
-
-    it('return this for chaining', () => {
-      const deque = new Deque([1, 2, 3]);
-
-      expect(deque.clear()).toBe(deque);
-    });
-  });
-
-  describe('toArray', () => {
-    it('return elements from front to back', () => {
-      const deque = new Deque([1, 2, 3]);
-
-      expect(deque.toArray()).toEqual([1, 2, 3]);
-    });
-
-    it('return correct order after mixed operations', () => {
-      const deque = new Deque<number>();
-      deque.pushBack(2);
-      deque.pushBack(3);
-      deque.pushFront(1);
-      deque.pushFront(0);
-
-      expect(deque.toArray()).toEqual([0, 1, 2, 3]);
-    });
-  });
-
-  describe('toString', () => {
-    it('return comma-separated string', () => {
-      const deque = new Deque([1, 2, 3]);
-
-      expect(deque.toString()).toBe('1,2,3');
-    });
-  });
-
-  describe('iteration', () => {
-    it('iterate in front-to-back order', () => {
-      const deque = new Deque([1, 2, 3]);
-
-      expect([...deque]).toEqual([1, 2, 3]);
-    });
-
-    it('iterate asynchronously', async () => {
-      const deque = new Deque([1, 2, 3]);
-      const elements: number[] = [];
-
-      for await (const element of deque)
-        elements.push(element);
-
-      expect(elements).toEqual([1, 2, 3]);
-    });
-  });
-
-  describe('circular buffer behavior', () => {
-    it('handle wrap-around correctly', () => {
-      const deque = new Deque<number>();
-
-      for (let i = 0; i < 4; i++)
-        deque.pushBack(i);
-
-      deque.popFront();
-      deque.popFront();
-      deque.pushBack(4);
-      deque.pushBack(5);
-
-      expect(deque.toArray()).toEqual([2, 3, 4, 5]);
-    });
-
-    it('grow the buffer when needed', () => {
-      const deque = new Deque<number>();
-
-      for (let i = 0; i < 100; i++)
-        deque.pushBack(i);
-
-      expect(deque.length).toBe(100);
-      expect(deque.peekFront()).toBe(0);
-      expect(deque.peekBack()).toBe(99);
-    });
-
-    it('handle alternating front/back operations', () => {
-      const deque = new Deque<number>();
-
-      deque.pushFront(3);
-      deque.pushBack(4);
-      deque.pushFront(2);
-      deque.pushBack(5);
-      deque.pushFront(1);
-
-      expect(deque.toArray()).toEqual([1, 2, 3, 4, 5]);
-
-      expect(deque.popFront()).toBe(1);
-      expect(deque.popBack()).toBe(5);
-      expect(deque.toArray()).toEqual([2, 3, 4]);
-    });
-  });
-
-  describe('mixed operations', () => {
-    it('use as a stack (LIFO)', () => {
-      const deque = new Deque<number>();
-      deque.pushBack(1).pushBack(2).pushBack(3);
-
-      expect(deque.popBack()).toBe(3);
-      expect(deque.popBack()).toBe(2);
-      expect(deque.popBack()).toBe(1);
-    });
-
-    it('use as a queue (FIFO)', () => {
-      const deque = new Deque<number>();
-      deque.pushBack(1).pushBack(2).pushBack(3);
-
-      expect(deque.popFront()).toBe(1);
-      expect(deque.popFront()).toBe(2);
-      expect(deque.popFront()).toBe(3);
-    });
-
-    it('reuse deque after clear', () => {
-      const deque = new Deque([1, 2, 3]);
-      deque.clear();
-      deque.pushBack(4);
-
-      expect(deque.length).toBe(1);
-      expect(deque.peekFront()).toBe(4);
-    });
-
-    it('maxSize limits capacity', () => {
-      const deque = new Deque<number>(undefined, { maxSize: 3 });
-      deque.pushBack(1).pushBack(2).pushBack(3);
-
-      expect(deque.isFull).toBe(true);
-      expect(() => deque.pushFront(0)).toThrow(new RangeError('Deque is full'));
-
-      deque.popFront();
-      deque.pushFront(0);
-
-      expect(deque.toArray()).toEqual([0, 2, 3]);
-    });
-  });
-});

core/stdlib/src/structs/Deque/index.ts

@@ -1,180 +0,0 @@
-import { CircularBuffer } from '../CircularBuffer';
-import type { DequeLike } from './types';
-
-export type { DequeLike } from './types';
-
-export interface DequeOptions {
-  maxSize?: number;
-}
-
-/**
- * @name Deque
- * @category Data Structures
- * @description Represents a double-ended queue backed by a circular buffer
- *
- * @since 0.0.8
- *
- * @template T The type of elements stored in the deque
- */
-export class Deque<T> implements DequeLike<T> {
-  /**
-   * The maximum number of elements that the deque can hold
-   *
-   * @private
-   * @type {number}
-   */
-  private readonly maxSize: number;
-
-  /**
-   * The underlying circular buffer
-   *
-   * @private
-   * @type {CircularBuffer<T>}
-   */
-  private readonly buffer: CircularBuffer<T>;
-
-  /**
-   * Creates an instance of Deque
-   *
-   * @param {(T[] | T)} [initialValues] The initial values to add to the deque
-   * @param {DequeOptions} [options] The options for the deque
-   */
-  constructor(initialValues?: T[] | T, options?: DequeOptions) {
-    this.maxSize = options?.maxSize ?? Infinity;
-    this.buffer = new CircularBuffer(initialValues);
-  }
-
-  /**
-   * Gets the number of elements in the deque
-   * @returns {number} The number of elements in the deque
-   */
-  get length() {
-    return this.buffer.length;
-  }
-
-  /**
-   * Checks if the deque is empty
-   * @returns {boolean} `true` if the deque is empty, `false` otherwise
-   */
-  get isEmpty() {
-    return this.buffer.isEmpty;
-  }
-
-  /**
-   * Checks if the deque is full
-   * @returns {boolean} `true` if the deque is full, `false` otherwise
-   */
-  get isFull() {
-    return this.buffer.length === this.maxSize;
-  }
-
-  /**
-   * Adds an element to the back of the deque
-   * @param {T} element The element to add
-   * @returns {this}
-   * @throws {RangeError} If the deque is full
-   */
-  pushBack(element: T) {
-    if (this.isFull)
-      throw new RangeError('Deque is full');
-
-    this.buffer.pushBack(element);
-
-    return this;
-  }
-
-  /**
-   * Adds an element to the front of the deque
-   * @param {T} element The element to add
-   * @returns {this}
-   * @throws {RangeError} If the deque is full
-   */
-  pushFront(element: T) {
-    if (this.isFull)
-      throw new RangeError('Deque is full');
-
-    this.buffer.pushFront(element);
-
-    return this;
-  }
-
-  /**
-   * Removes and returns the back element of the deque
-   * @returns {T | undefined} The back element, or undefined if empty
-   */
-  popBack() {
-    return this.buffer.popBack();
-  }
-
-  /**
-   * Removes and returns the front element of the deque
-   * @returns {T | undefined} The front element, or undefined if empty
-   */
-  popFront() {
-    return this.buffer.popFront();
-  }
-
-  /**
-   * Returns the back element without removing it
-   * @returns {T | undefined} The back element, or undefined if empty
-   */
-  peekBack() {
-    return this.buffer.peekBack();
-  }
-
-  /**
-   * Returns the front element without removing it
-   * @returns {T | undefined} The front element, or undefined if empty
-   */
-  peekFront() {
-    return this.buffer.peekFront();
-  }
-
-  /**
-   * Clears the deque
-   *
-   * @returns {this}
-   */
-  clear() {
-    this.buffer.clear();
-
-    return this;
-  }
-
-  /**
-   * Converts the deque to an array from front to back
-   *
-   * @returns {T[]}
-   */
-  toArray() {
-    return this.buffer.toArray();
-  }
-
-  /**
-   * Returns a string representation of the deque
-   *
-   * @returns {string}
-   */
-  toString() {
-    return this.buffer.toString();
-  }
-
-  /**
-   * Returns an iterator for the deque (front to back)
-   *
-   * @returns {IterableIterator<T>}
-   */
-  [Symbol.iterator]() {
-    return this.buffer[Symbol.iterator]();
-  }
-
-  /**
-   * Returns an async iterator for the deque (front to back)
-   *
-   * @returns {AsyncIterableIterator<T>}
-   */
-  async *[Symbol.asyncIterator]() {
-    for (const element of this.buffer)
-      yield element;
-  }
-}

core/stdlib/src/structs/Deque/types.ts

@@ -1,15 +0,0 @@
-export interface DequeLike<T> extends Iterable<T>, AsyncIterable<T> {
-  readonly length: number;
-  readonly isEmpty: boolean;
-  readonly isFull: boolean;
-
-  pushBack(element: T): this;
-  pushFront(element: T): this;
-  popBack(): T | undefined;
-  popFront(): T | undefined;
-  peekBack(): T | undefined;
-  peekFront(): T | undefined;
-  clear(): this;
-  toArray(): T[];
-  toString(): string;
-}

core/stdlib/src/structs/LinkedList/index.test.ts

@@ -1,406 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { LinkedList } from '.';
-
-describe('LinkedList', () => {
-    describe('constructor', () => {
-        it('should create an empty list', () => {
-            const list = new LinkedList<number>();
-
-            expect(list.length).toBe(0);
-            expect(list.isEmpty).toBe(true);
-            expect(list.head).toBeUndefined();
-            expect(list.tail).toBeUndefined();
-        });
-
-        it('should create a list from single value', () => {
-            const list = new LinkedList(42);
-
-            expect(list.length).toBe(1);
-            expect(list.peekFront()).toBe(42);
-            expect(list.peekBack()).toBe(42);
-        });
-
-        it('should create a list from array', () => {
-            const list = new LinkedList([1, 2, 3]);
-
-            expect(list.length).toBe(3);
-            expect(list.peekFront()).toBe(1);
-            expect(list.peekBack()).toBe(3);
-        });
-    });
-
-    describe('pushBack', () => {
-        it('should append to empty list', () => {
-            const list = new LinkedList<number>();
-
-            const node = list.pushBack(1);
-
-            expect(list.length).toBe(1);
-            expect(node.value).toBe(1);
-            expect(list.head).toBe(node);
-            expect(list.tail).toBe(node);
-        });
-
-        it('should append to non-empty list', () => {
-            const list = new LinkedList([1, 2]);
-
-            list.pushBack(3);
-
-            expect(list.length).toBe(3);
-            expect(list.peekBack()).toBe(3);
-            expect(list.peekFront()).toBe(1);
-        });
-
-        it('should return the created node', () => {
-            const list = new LinkedList<number>();
-
-            const node = list.pushBack(5);
-
-            expect(node.value).toBe(5);
-            expect(node.prev).toBeUndefined();
-            expect(node.next).toBeUndefined();
-        });
-    });
-
-    describe('pushFront', () => {
-        it('should prepend to empty list', () => {
-            const list = new LinkedList<number>();
-
-            const node = list.pushFront(1);
-
-            expect(list.length).toBe(1);
-            expect(list.head).toBe(node);
-            expect(list.tail).toBe(node);
-        });
-
-        it('should prepend to non-empty list', () => {
-            const list = new LinkedList([2, 3]);
-
-            list.pushFront(1);
-
-            expect(list.length).toBe(3);
-            expect(list.peekFront()).toBe(1);
-            expect(list.peekBack()).toBe(3);
-        });
-    });
-
-    describe('popBack', () => {
-        it('should return undefined for empty list', () => {
-            const list = new LinkedList<number>();
-
-            expect(list.popBack()).toBeUndefined();
-        });
-
-        it('should remove and return last value', () => {
-            const list = new LinkedList([1, 2, 3]);
-
-            expect(list.popBack()).toBe(3);
-            expect(list.length).toBe(2);
-            expect(list.peekBack()).toBe(2);
-        });
-
-        it('should handle single element', () => {
-            const list = new LinkedList(1);
-
-            expect(list.popBack()).toBe(1);
-            expect(list.isEmpty).toBe(true);
-            expect(list.head).toBeUndefined();
-            expect(list.tail).toBeUndefined();
-        });
-    });
-
-    describe('popFront', () => {
-        it('should return undefined for empty list', () => {
-            const list = new LinkedList<number>();
-
-            expect(list.popFront()).toBeUndefined();
-        });
-
-        it('should remove and return first value', () => {
-            const list = new LinkedList([1, 2, 3]);
-
-            expect(list.popFront()).toBe(1);
-            expect(list.length).toBe(2);
-            expect(list.peekFront()).toBe(2);
-        });
-
-        it('should handle single element', () => {
-            const list = new LinkedList(1);
-
-            expect(list.popFront()).toBe(1);
-            expect(list.isEmpty).toBe(true);
-            expect(list.head).toBeUndefined();
-            expect(list.tail).toBeUndefined();
-        });
-    });
-
-    describe('peekBack', () => {
-        it('should return undefined for empty list', () => {
-            const list = new LinkedList<number>();
-
-            expect(list.peekBack()).toBeUndefined();
-        });
-
-        it('should return last value without removing', () => {
-            const list = new LinkedList([1, 2, 3]);
-
-            expect(list.peekBack()).toBe(3);
-            expect(list.length).toBe(3);
-        });
-    });
-
-    describe('peekFront', () => {
-        it('should return undefined for empty list', () => {
-            const list = new LinkedList<number>();
-
-            expect(list.peekFront()).toBeUndefined();
-        });
-
-        it('should return first value without removing', () => {
-            const list = new LinkedList([1, 2, 3]);
-
-            expect(list.peekFront()).toBe(1);
-            expect(list.length).toBe(3);
-        });
-    });
-
-    describe('insertBefore', () => {
-        it('should insert before head', () => {
-            const list = new LinkedList<number>();
-            const node = list.pushBack(2);
-
-            list.insertBefore(node, 1);
-
-            expect(list.peekFront()).toBe(1);
-            expect(list.peekBack()).toBe(2);
-            expect(list.length).toBe(2);
-        });
-
-        it('should insert before middle node', () => {
-            const list = new LinkedList([1, 3]);
-            const tail = list.tail!;
-
-            list.insertBefore(tail, 2);
-
-            expect(list.toArray()).toEqual([1, 2, 3]);
-        });
-
-        it('should return the created node', () => {
-            const list = new LinkedList<number>();
-            const existing = list.pushBack(2);
-
-            const newNode = list.insertBefore(existing, 1);
-
-            expect(newNode.value).toBe(1);
-            expect(newNode.next).toBe(existing);
-        });
-    });
-
-    describe('insertAfter', () => {
-        it('should insert after tail', () => {
-            const list = new LinkedList<number>();
-            const node = list.pushBack(1);
-
-            list.insertAfter(node, 2);
-
-            expect(list.peekFront()).toBe(1);
-            expect(list.peekBack()).toBe(2);
-            expect(list.length).toBe(2);
-        });
-
-        it('should insert after middle node', () => {
-            const list = new LinkedList([1, 3]);
-            const head = list.head!;
-
-            list.insertAfter(head, 2);
-
-            expect(list.toArray()).toEqual([1, 2, 3]);
-        });
-
-        it('should return the created node', () => {
-            const list = new LinkedList<number>();
-            const existing = list.pushBack(1);
-
-            const newNode = list.insertAfter(existing, 2);
-
-            expect(newNode.value).toBe(2);
-            expect(newNode.prev).toBe(existing);
-        });
-    });
-
-    describe('remove', () => {
-        it('should remove head node', () => {
-            const list = new LinkedList([1, 2, 3]);
-            const head = list.head!;
-
-            const value = list.remove(head);
-
-            expect(value).toBe(1);
-            expect(list.length).toBe(2);
-            expect(list.peekFront()).toBe(2);
-        });
-
-        it('should remove tail node', () => {
-            const list = new LinkedList([1, 2, 3]);
-            const tail = list.tail!;
-
-            const value = list.remove(tail);
-
-            expect(value).toBe(3);
-            expect(list.length).toBe(2);
-            expect(list.peekBack()).toBe(2);
-        });
-
-        it('should remove middle node', () => {
-            const list = new LinkedList([1, 2, 3]);
-            const middle = list.head!.next!;
-
-            const value = list.remove(middle);
-
-            expect(value).toBe(2);
-            expect(list.toArray()).toEqual([1, 3]);
-        });
-
-        it('should remove single element', () => {
-            const list = new LinkedList<number>();
-            const node = list.pushBack(1);
-
-            list.remove(node);
-
-            expect(list.isEmpty).toBe(true);
-            expect(list.head).toBeUndefined();
-            expect(list.tail).toBeUndefined();
-        });
-
-        it('should detach the removed node', () => {
-            const list = new LinkedList([1, 2, 3]);
-            const middle = list.head!.next!;
-
-            list.remove(middle);
-
-            expect(middle.prev).toBeUndefined();
-            expect(middle.next).toBeUndefined();
-        });
-    });
-
-    describe('clear', () => {
-        it('should remove all elements', () => {
-            const list = new LinkedList([1, 2, 3]);
-
-            const result = list.clear();
-
-            expect(list.length).toBe(0);
-            expect(list.isEmpty).toBe(true);
-            expect(list.head).toBeUndefined();
-            expect(list.tail).toBeUndefined();
-            expect(result).toBe(list);
-        });
-    });
-
-    describe('toArray', () => {
-        it('should return empty array for empty list', () => {
-            const list = new LinkedList<number>();
-
-            expect(list.toArray()).toEqual([]);
-        });
-
-        it('should return values from head to tail', () => {
-            const list = new LinkedList([1, 2, 3]);
-
-            expect(list.toArray()).toEqual([1, 2, 3]);
-        });
-    });
-
-    describe('toString', () => {
-        it('should return comma-separated values', () => {
-            const list = new LinkedList([1, 2, 3]);
-
-            expect(list.toString()).toBe('1,2,3');
-        });
-    });
-
-    describe('iterator', () => {
-        it('should iterate from head to tail', () => {
-            const list = new LinkedList([1, 2, 3]);
-
-            expect([...list]).toEqual([1, 2, 3]);
-        });
-
-        it('should yield nothing for empty list', () => {
-            const list = new LinkedList<number>();
-
-            expect([...list]).toEqual([]);
-        });
-    });
-
-    describe('async iterator', () => {
-        it('should async iterate from head to tail', async () => {
-            const list = new LinkedList([1, 2, 3]);
-            const result: number[] = [];
-
-            for await (const value of list)
-                result.push(value);
-
-            expect(result).toEqual([1, 2, 3]);
-        });
-    });
-
-    describe('node linking', () => {
-        it('should maintain correct prev/next references', () => {
-            const list = new LinkedList<number>();
-            const a = list.pushBack(1);
-            const b = list.pushBack(2);
-            const c = list.pushBack(3);
-
-            expect(a.next).toBe(b);
-            expect(b.prev).toBe(a);
-            expect(b.next).toBe(c);
-            expect(c.prev).toBe(b);
-            expect(a.prev).toBeUndefined();
-            expect(c.next).toBeUndefined();
-        });
-
-        it('should update links after removal', () => {
-            const list = new LinkedList<number>();
-            const a = list.pushBack(1);
-            const b = list.pushBack(2);
-            const c = list.pushBack(3);
-
-            list.remove(b);
-
-            expect(a.next).toBe(c);
-            expect(c.prev).toBe(a);
-        });
-    });
-
-    describe('interleaved operations', () => {
-        it('should handle mixed push/pop from both ends', () => {
-            const list = new LinkedList<number>();
-
-            list.pushBack(1);
-            list.pushBack(2);
-            list.pushFront(0);
-
-            expect(list.popFront()).toBe(0);
-            expect(list.popBack()).toBe(2);
-            expect(list.popFront()).toBe(1);
-            expect(list.isEmpty).toBe(true);
-        });
-
-        it('should handle insert and remove by node reference', () => {
-            const list = new LinkedList<number>();
-            const a = list.pushBack(1);
-            const c = list.pushBack(3);
-            const b = list.insertAfter(a, 2);
-            const d = list.insertBefore(c, 2.5);
-
-            expect(list.toArray()).toEqual([1, 2, 2.5, 3]);
-
-            list.remove(b);
-            list.remove(d);
-
-            expect(list.toArray()).toEqual([1, 3]);
-        });
-    });
-});

core/stdlib/src/structs/LinkedList/index.ts

@@ -1,324 +0,0 @@
-import { isArray } from '../../types';
-import type { LinkedListLike, LinkedListNode } from './types';
-
-export type { LinkedListLike, LinkedListNode } from './types';
-
-/**
- * Creates a new doubly linked list node
- *
- * @template T The type of the value
- * @param {T} value The value to store
- * @returns {LinkedListNode<T>} The created node
- */
-function createNode<T>(value: T): LinkedListNode<T> {
-    return { value, prev: undefined, next: undefined };
-}
-
-/**
- * @name LinkedList
- * @category Data Structures
- * @description Doubly linked list with O(1) push/pop on both ends and O(1) insert/remove by node reference
- *
- * @since 0.0.8
- *
- * @template T The type of elements stored in the list
- */
-export class LinkedList<T> implements LinkedListLike<T> {
-    /**
-     * The number of elements in the list
-     *
-     * @private
-     * @type {number}
-     */
-    private count = 0;
-
-    /**
-     * The first node in the list
-     *
-     * @private
-     * @type {LinkedListNode<T> | undefined}
-     */
-    private first: LinkedListNode<T> | undefined;
-
-    /**
-     * The last node in the list
-     *
-     * @private
-     * @type {LinkedListNode<T> | undefined}
-     */
-    private last: LinkedListNode<T> | undefined;
-
-    /**
-     * Creates an instance of LinkedList
-     *
-     * @param {(T[] | T)} [initialValues] The initial values to add to the list
-     */
-    constructor(initialValues?: T[] | T) {
-        if (initialValues !== null && initialValues !== undefined) {
-            const items = isArray(initialValues) ? initialValues : [initialValues];
-
-            for (const item of items)
-                this.pushBack(item);
-        }
-    }
-
-    /**
-     * Gets the number of elements in the list
-     * @returns {number} The number of elements in the list
-     */
-    public get length(): number {
-        return this.count;
-    }
-
-    /**
-     * Checks if the list is empty
-     * @returns {boolean} `true` if the list is empty, `false` otherwise
-     */
-    public get isEmpty(): boolean {
-        return this.count === 0;
-    }
-
-    /**
-     * Gets the first node
-     * @returns {LinkedListNode<T> | undefined} The first node, or `undefined` if the list is empty
-     */
-    public get head(): LinkedListNode<T> | undefined {
-        return this.first;
-    }
-
-    /**
-     * Gets the last node
-     * @returns {LinkedListNode<T> | undefined} The last node, or `undefined` if the list is empty
-     */
-    public get tail(): LinkedListNode<T> | undefined {
-        return this.last;
-    }
-
-    /**
-     * Appends a value to the end of the list
-     * @param {T} value The value to append
-     * @returns {LinkedListNode<T>} The created node
-     */
-    public pushBack(value: T): LinkedListNode<T> {
-        const node = createNode(value);
-
-        if (this.last) {
-            node.prev = this.last;
-            this.last.next = node;
-            this.last = node;
-        } else {
-            this.first = node;
-            this.last = node;
-        }
-
-        this.count++;
-
-        return node;
-    }
-
-    /**
-     * Prepends a value to the beginning of the list
-     * @param {T} value The value to prepend
-     * @returns {LinkedListNode<T>} The created node
-     */
-    public pushFront(value: T): LinkedListNode<T> {
-        const node = createNode(value);
-
-        if (this.first) {
-            node.next = this.first;
-            this.first.prev = node;
-            this.first = node;
-        } else {
-            this.first = node;
-            this.last = node;
-        }
-
-        this.count++;
-
-        return node;
-    }
-
-    /**
-     * Removes and returns the last value
-     * @returns {T | undefined} The last value, or `undefined` if the list is empty
-     */
-    public popBack(): T | undefined {
-        if (!this.last) return undefined;
-
-        const node = this.last;
-
-        this.detach(node);
-
-        return node.value;
-    }
-
-    /**
-     * Removes and returns the first value
-     * @returns {T | undefined} The first value, or `undefined` if the list is empty
-     */
-    public popFront(): T | undefined {
-        if (!this.first) return undefined;
-
-        const node = this.first;
-
-        this.detach(node);
-
-        return node.value;
-    }
-
-    /**
-     * Returns the last value without removing it
-     * @returns {T | undefined} The last value, or `undefined` if the list is empty
-     */
-    public peekBack(): T | undefined {
-        return this.last?.value;
-    }
-
-    /**
-     * Returns the first value without removing it
-     * @returns {T | undefined} The first value, or `undefined` if the list is empty
-     */
-    public peekFront(): T | undefined {
-        return this.first?.value;
-    }
-
-    /**
-     * Inserts a value before the given node
-     * @param {LinkedListNode<T>} node The reference node
-     * @param {T} value The value to insert
-     * @returns {LinkedListNode<T>} The created node
-     */
-    public insertBefore(node: LinkedListNode<T>, value: T): LinkedListNode<T> {
-        const newNode = createNode(value);
-
-        newNode.next = node;
-        newNode.prev = node.prev;
-
-        if (node.prev) {
-            node.prev.next = newNode;
-        } else {
-            this.first = newNode;
-        }
-
-        node.prev = newNode;
-        this.count++;
-
-        return newNode;
-    }
-
-    /**
-     * Inserts a value after the given node
-     * @param {LinkedListNode<T>} node The reference node
-     * @param {T} value The value to insert
-     * @returns {LinkedListNode<T>} The created node
-     */
-    public insertAfter(node: LinkedListNode<T>, value: T): LinkedListNode<T> {
-        const newNode = createNode(value);
-
-        newNode.prev = node;
-        newNode.next = node.next;
-
-        if (node.next) {
-            node.next.prev = newNode;
-        } else {
-            this.last = newNode;
-        }
-
-        node.next = newNode;
-        this.count++;
-
-        return newNode;
-    }
-
-    /**
-     * Removes a node from the list by reference in O(1)
-     * @param {LinkedListNode<T>} node The node to remove
-     * @returns {T} The value of the removed node
-     */
-    public remove(node: LinkedListNode<T>): T {
-        this.detach(node);
-
-        return node.value;
-    }
-
-    /**
-     * Removes all elements from the list
-     * @returns {this} The list instance for chaining
-     */
-    public clear(): this {
-        this.first = undefined;
-        this.last = undefined;
-        this.count = 0;
-
-        return this;
-    }
-
-    /**
-     * Returns a shallow copy of the list values as an array
-     * @returns {T[]} Array of values from head to tail
-     */
-    public toArray(): T[] {
-        const result = Array.from<T>({ length: this.count });
-        let current = this.first;
-        let i = 0;
-
-        while (current) {
-            result[i++] = current.value;
-            current = current.next;
-        }
-
-        return result;
-    }
-
-    /**
-     * Returns a string representation of the list
-     * @returns {string} String representation
-     */
-    public toString(): string {
-        return this.toArray().toString();
-    }
-
-    /**
-     * Iterator over list values from head to tail
-     */
-    public *[Symbol.iterator](): Iterator<T> {
-        let current = this.first;
-
-        while (current) {
-            yield current.value;
-            current = current.next;
-        }
-    }
-
-    /**
-     * Async iterator over list values from head to tail
-     */
-    public async *[Symbol.asyncIterator](): AsyncIterator<T> {
-        for (const value of this)
-            yield value;
-    }
-
-    /**
-     * Detaches a node from the list, updating head/tail and count
-     *
-     * @private
-     * @param {LinkedListNode<T>} node The node to detach
-     */
-    private detach(node: LinkedListNode<T>): void {
-        if (node.prev) {
-            node.prev.next = node.next;
-        } else {
-            this.first = node.next;
-        }
-
-        if (node.next) {
-            node.next.prev = node.prev;
-        } else {
-            this.last = node.prev;
-        }
-
-        node.prev = undefined;
-        node.next = undefined;
-        this.count--;
-    }
-}

core/stdlib/src/structs/LinkedList/types.ts

@@ -1,28 +0,0 @@
-export interface LinkedListNode<T> {
-    value: T;
-    prev: LinkedListNode<T> | undefined;
-    next: LinkedListNode<T> | undefined;
-}
-
-export interface LinkedListLike<T> extends Iterable<T>, AsyncIterable<T> {
-    readonly length: number;
-    readonly isEmpty: boolean;
-
-    readonly head: LinkedListNode<T> | undefined;
-    readonly tail: LinkedListNode<T> | undefined;
-
-    pushBack(value: T): LinkedListNode<T>;
-    pushFront(value: T): LinkedListNode<T>;
-    popBack(): T | undefined;
-    popFront(): T | undefined;
-    peekBack(): T | undefined;
-    peekFront(): T | undefined;
-
-    insertBefore(node: LinkedListNode<T>, value: T): LinkedListNode<T>;
-    insertAfter(node: LinkedListNode<T>, value: T): LinkedListNode<T>;
-    remove(node: LinkedListNode<T>): T;
-
-    clear(): this;
-    toArray(): T[];
-    toString(): string;
-}

core/stdlib/src/structs/PriorityQueue/index.test.ts

@@ -1,213 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { PriorityQueue } from '.';
-
-describe('PriorityQueue', () => {
-    describe('constructor', () => {
-        it('should create an empty queue', () => {
-            const pq = new PriorityQueue<number>();
-
-            expect(pq.length).toBe(0);
-            expect(pq.isEmpty).toBe(true);
-            expect(pq.isFull).toBe(false);
-        });
-
-        it('should create a queue from single value', () => {
-            const pq = new PriorityQueue(42);
-
-            expect(pq.length).toBe(1);
-            expect(pq.peek()).toBe(42);
-        });
-
-        it('should create a queue from array', () => {
-            const pq = new PriorityQueue([5, 3, 8, 1, 4]);
-
-            expect(pq.length).toBe(5);
-            expect(pq.peek()).toBe(1);
-        });
-
-        it('should throw if initial values exceed maxSize', () => {
-            expect(() => new PriorityQueue([1, 2, 3], { maxSize: 2 }))
-                .toThrow('Initial values exceed maxSize');
-        });
-    });
-
-    describe('enqueue', () => {
-        it('should enqueue elements by priority', () => {
-            const pq = new PriorityQueue<number>();
-
-            pq.enqueue(5);
-            pq.enqueue(1);
-            pq.enqueue(3);
-
-            expect(pq.peek()).toBe(1);
-            expect(pq.length).toBe(3);
-        });
-
-        it('should throw when queue is full', () => {
-            const pq = new PriorityQueue<number>(undefined, { maxSize: 2 });
-
-            pq.enqueue(1);
-            pq.enqueue(2);
-
-            expect(() => pq.enqueue(3)).toThrow('PriorityQueue is full');
-        });
-    });
-
-    describe('dequeue', () => {
-        it('should return undefined for empty queue', () => {
-            const pq = new PriorityQueue<number>();
-
-            expect(pq.dequeue()).toBeUndefined();
-        });
-
-        it('should dequeue elements in priority order (min-heap)', () => {
-            const pq = new PriorityQueue([5, 3, 8, 1, 4]);
-            const result: number[] = [];
-
-            while (!pq.isEmpty) {
-                result.push(pq.dequeue()!);
-            }
-
-            expect(result).toEqual([1, 3, 4, 5, 8]);
-        });
-
-        it('should dequeue elements in priority order (max-heap)', () => {
-            const pq = new PriorityQueue([5, 3, 8, 1, 4], {
-                comparator: (a, b) => b - a,
-            });
-            const result: number[] = [];
-
-            while (!pq.isEmpty) {
-                result.push(pq.dequeue()!);
-            }
-
-            expect(result).toEqual([8, 5, 4, 3, 1]);
-        });
-    });
-
-    describe('peek', () => {
-        it('should return undefined for empty queue', () => {
-            const pq = new PriorityQueue<number>();
-
-            expect(pq.peek()).toBeUndefined();
-        });
-
-        it('should return highest-priority element without removing', () => {
-            const pq = new PriorityQueue([5, 1, 3]);
-
-            expect(pq.peek()).toBe(1);
-            expect(pq.length).toBe(3);
-        });
-    });
-
-    describe('isFull', () => {
-        it('should be false when no maxSize', () => {
-            const pq = new PriorityQueue([1, 2, 3]);
-
-            expect(pq.isFull).toBe(false);
-        });
-
-        it('should be true when at maxSize', () => {
-            const pq = new PriorityQueue([1, 2], { maxSize: 2 });
-
-            expect(pq.isFull).toBe(true);
-        });
-
-        it('should become false after dequeue', () => {
-            const pq = new PriorityQueue([1, 2], { maxSize: 2 });
-
-            pq.dequeue();
-
-            expect(pq.isFull).toBe(false);
-        });
-    });
-
-    describe('clear', () => {
-        it('should remove all elements', () => {
-            const pq = new PriorityQueue([1, 2, 3]);
-
-            const result = pq.clear();
-
-            expect(pq.length).toBe(0);
-            expect(pq.isEmpty).toBe(true);
-            expect(result).toBe(pq);
-        });
-    });
-
-    describe('toArray', () => {
-        it('should return empty array for empty queue', () => {
-            const pq = new PriorityQueue<number>();
-
-            expect(pq.toArray()).toEqual([]);
-        });
-
-        it('should return a shallow copy', () => {
-            const pq = new PriorityQueue([3, 1, 2]);
-            const arr = pq.toArray();
-
-            arr.push(99);
-
-            expect(pq.length).toBe(3);
-        });
-    });
-
-    describe('toString', () => {
-        it('should return formatted string', () => {
-            const pq = new PriorityQueue([1, 2, 3]);
-
-            expect(pq.toString()).toBe('PriorityQueue(3)');
-        });
-    });
-
-    describe('iterator', () => {
-        it('should iterate over elements', () => {
-            const pq = new PriorityQueue([5, 3, 1]);
-            const elements = [...pq];
-
-            expect(elements.length).toBe(3);
-        });
-    });
-
-    describe('custom comparator', () => {
-        it('should work with object priority', () => {
-            interface Job {
-                priority: number;
-                name: string;
-            }
-
-            const pq = new PriorityQueue<Job>(
-                [
-                    { priority: 3, name: 'low' },
-                    { priority: 1, name: 'critical' },
-                    { priority: 2, name: 'normal' },
-                ],
-                { comparator: (a, b) => a.priority - b.priority },
-            );
-
-            expect(pq.dequeue()?.name).toBe('critical');
-            expect(pq.dequeue()?.name).toBe('normal');
-            expect(pq.dequeue()?.name).toBe('low');
-        });
-    });
-
-    describe('interleaved operations', () => {
-        it('should maintain priority with mixed enqueue and dequeue', () => {
-            const pq = new PriorityQueue<number>();
-
-            pq.enqueue(10);
-            pq.enqueue(5);
-            expect(pq.dequeue()).toBe(5);
-
-            pq.enqueue(3);
-            pq.enqueue(7);
-            expect(pq.dequeue()).toBe(3);
-
-            pq.enqueue(1);
-            expect(pq.dequeue()).toBe(1);
-            expect(pq.dequeue()).toBe(7);
-            expect(pq.dequeue()).toBe(10);
-            expect(pq.dequeue()).toBeUndefined();
-        });
-    });
-});

core/stdlib/src/structs/PriorityQueue/index.ts

@@ -1,144 +0,0 @@
-import { BinaryHeap } from '../BinaryHeap';
-import type { Comparator, PriorityQueueLike } from './types';
-
-export type { PriorityQueueLike } from './types';
-export type { Comparator } from './types';
-
-export interface PriorityQueueOptions<T> {
-    comparator?: Comparator<T>;
-    maxSize?: number;
-}
-
-/**
- * @name PriorityQueue
- * @category Data Structures
- * @description Priority queue backed by a binary heap with configurable comparator and optional max size
- *
- * @since 0.0.8
- *
- * @template T The type of elements stored in the queue
- */
-export class PriorityQueue<T> implements PriorityQueueLike<T> {
-    /**
-     * The maximum number of elements the queue can hold
-     *
-     * @private
-     * @type {number}
-     */
-    private readonly maxSize: number;
-
-    /**
-     * Internal binary heap backing the queue
-     *
-     * @private
-     * @type {BinaryHeap<T>}
-     */
-    private readonly heap: BinaryHeap<T>;
-
-    /**
-     * Creates an instance of PriorityQueue
-     *
-     * @param {(T[] | T)} [initialValues] The initial values to add to the queue
-     * @param {PriorityQueueOptions<T>} [options] Queue configuration
-     */
-    constructor(initialValues?: T[] | T, options?: PriorityQueueOptions<T>) {
-        this.maxSize = options?.maxSize ?? Infinity;
-        this.heap = new BinaryHeap(initialValues, { comparator: options?.comparator });
-
-        if (this.heap.length > this.maxSize) {
-            throw new RangeError('Initial values exceed maxSize');
-        }
-    }
-
-    /**
-     * Gets the number of elements in the queue
-     * @returns {number} The number of elements in the queue
-     */
-    public get length(): number {
-        return this.heap.length;
-    }
-
-    /**
-     * Checks if the queue is empty
-     * @returns {boolean} `true` if the queue is empty, `false` otherwise
-     */
-    public get isEmpty(): boolean {
-        return this.heap.isEmpty;
-    }
-
-    /**
-     * Checks if the queue is full
-     * @returns {boolean} `true` if the queue has reached maxSize, `false` otherwise
-     */
-    public get isFull(): boolean {
-        return this.heap.length >= this.maxSize;
-    }
-
-    /**
-     * Enqueues an element by priority
-     * @param {T} element The element to enqueue
-     * @throws {RangeError} If the queue is full
-     */
-    public enqueue(element: T): void {
-        if (this.isFull)
-            throw new RangeError('PriorityQueue is full');
-
-        this.heap.push(element);
-    }
-
-    /**
-     * Dequeues the highest-priority element
-     * @returns {T | undefined} The highest-priority element, or `undefined` if empty
-     */
-    public dequeue(): T | undefined {
-        return this.heap.pop();
-    }
-
-    /**
-     * Returns the highest-priority element without removing it
-     * @returns {T | undefined} The highest-priority element, or `undefined` if empty
-     */
-    public peek(): T | undefined {
-        return this.heap.peek();
-    }
-
-    /**
-     * Removes all elements from the queue
-     * @returns {this} The queue instance for chaining
-     */
-    public clear(): this {
-        this.heap.clear();
-        return this;
-    }
-
-    /**
-     * Returns a shallow copy of elements in heap order
-     * @returns {T[]} Array of elements
-     */
-    public toArray(): T[] {
-        return this.heap.toArray();
-    }
-
-    /**
-     * Returns a string representation of the queue
-     * @returns {string} String representation
-     */
-    public toString(): string {
-        return `PriorityQueue(${this.heap.length})`;
-    }
-
-    /**
-     * Iterator over queue elements in heap order
-     */
-    public *[Symbol.iterator](): Iterator<T> {
-        yield* this.heap;
-    }
-
-    /**
-     * Async iterator over queue elements in heap order
-     */
-    public async *[Symbol.asyncIterator](): AsyncIterator<T> {
-        for (const element of this.heap)
-            yield element;
-    }
-}

core/stdlib/src/structs/PriorityQueue/types.ts

@@ -1,16 +0,0 @@
-import type { Comparator } from '../BinaryHeap';
-
-export interface PriorityQueueLike<T> extends Iterable<T>, AsyncIterable<T> {
-    readonly length: number;
-    readonly isEmpty: boolean;
-    readonly isFull: boolean;
-
-    enqueue(element: T): void;
-    dequeue(): T | undefined;
-    peek(): T | undefined;
-    clear(): this;
-    toArray(): T[];
-    toString(): string;
-}
-
-export type { Comparator };

core/stdlib/src/structs/Queue/index.test.ts

@@ -1,207 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Queue } from '.';
-
-describe('queue', () => {
-  describe('constructor', () => {
-    it('create an empty queue if no initial values are provided', () => {
-      const queue = new Queue<number>();
-
-      expect(queue.length).toBe(0);
-      expect(queue.isEmpty).toBe(true);
-    });
-
-    it('create a queue with the provided initial values', () => {
-      const queue = new Queue([1, 2, 3]);
-
-      expect(queue.length).toBe(3);
-      expect(queue.peek()).toBe(1);
-    });
-
-    it('create a queue with a single initial value', () => {
-      const queue = new Queue(42);
-
-      expect(queue.length).toBe(1);
-      expect(queue.peek()).toBe(42);
-    });
-
-    it('create a queue with the provided options', () => {
-      const queue = new Queue<number>(undefined, { maxSize: 5 });
-
-      expect(queue.length).toBe(0);
-      expect(queue.isFull).toBe(false);
-    });
-  });
-
-  describe('enqueue', () => {
-    it('add an element to the back of the queue', () => {
-      const queue = new Queue<number>();
-      queue.enqueue(1);
-
-      expect(queue.length).toBe(1);
-      expect(queue.peek()).toBe(1);
-    });
-
-    it('maintain FIFO order', () => {
-      const queue = new Queue<number>();
-      queue.enqueue(1).enqueue(2).enqueue(3);
-
-      expect(queue.peek()).toBe(1);
-    });
-
-    it('throw an error if the queue is full', () => {
-      const queue = new Queue<number>(undefined, { maxSize: 1 });
-      queue.enqueue(1);
-
-      expect(() => queue.enqueue(2)).toThrow(new RangeError('Queue is full'));
-    });
-
-    it('return this for chaining', () => {
-      const queue = new Queue<number>();
-      const result = queue.enqueue(1);
-
-      expect(result).toBe(queue);
-    });
-  });
-
-  describe('dequeue', () => {
-    it('remove and return the front element', () => {
-      const queue = new Queue([1, 2, 3]);
-      const element = queue.dequeue();
-
-      expect(element).toBe(1);
-      expect(queue.length).toBe(2);
-    });
-
-    it('return undefined if the queue is empty', () => {
-      const queue = new Queue<number>();
-
-      expect(queue.dequeue()).toBeUndefined();
-    });
-
-    it('maintain FIFO order across multiple dequeues', () => {
-      const queue = new Queue([1, 2, 3]);
-
-      expect(queue.dequeue()).toBe(1);
-      expect(queue.dequeue()).toBe(2);
-      expect(queue.dequeue()).toBe(3);
-      expect(queue.dequeue()).toBeUndefined();
-    });
-
-    it('compact internal storage after many dequeues', () => {
-      const queue = new Queue<number>();
-
-      for (let i = 0; i < 100; i++)
-        queue.enqueue(i);
-
-      for (let i = 0; i < 80; i++)
-        queue.dequeue();
-
-      expect(queue.length).toBe(20);
-      expect(queue.peek()).toBe(80);
-    });
-  });
-
-  describe('peek', () => {
-    it('return the front element without removing it', () => {
-      const queue = new Queue([1, 2, 3]);
-
-      expect(queue.peek()).toBe(1);
-      expect(queue.length).toBe(3);
-    });
-
-    it('return undefined if the queue is empty', () => {
-      const queue = new Queue<number>();
-
-      expect(queue.peek()).toBeUndefined();
-    });
-  });
-
-  describe('clear', () => {
-    it('clear the queue', () => {
-      const queue = new Queue([1, 2, 3]);
-      queue.clear();
-
-      expect(queue.length).toBe(0);
-      expect(queue.isEmpty).toBe(true);
-    });
-
-    it('return this for chaining', () => {
-      const queue = new Queue([1, 2, 3]);
-
-      expect(queue.clear()).toBe(queue);
-    });
-  });
-
-  describe('toArray', () => {
-    it('return elements in FIFO order', () => {
-      const queue = new Queue([1, 2, 3]);
-
-      expect(queue.toArray()).toEqual([1, 2, 3]);
-    });
-
-    it('return correct array after dequeues', () => {
-      const queue = new Queue([1, 2, 3, 4, 5]);
-      queue.dequeue();
-      queue.dequeue();
-
-      expect(queue.toArray()).toEqual([3, 4, 5]);
-    });
-  });
-
-  describe('toString', () => {
-    it('return comma-separated string', () => {
-      const queue = new Queue([1, 2, 3]);
-
-      expect(queue.toString()).toBe('1,2,3');
-    });
-  });
-
-  describe('iteration', () => {
-    it('iterate over the queue in FIFO order', () => {
-      const queue = new Queue([1, 2, 3]);
-
-      expect([...queue]).toEqual([1, 2, 3]);
-    });
-
-    it('iterate correctly after dequeues', () => {
-      const queue = new Queue([1, 2, 3, 4]);
-      queue.dequeue();
-
-      expect([...queue]).toEqual([2, 3, 4]);
-    });
-
-    it('iterate over the queue asynchronously in FIFO order', async () => {
-      const queue = new Queue([1, 2, 3]);
-      const elements: number[] = [];
-
-      for await (const element of queue)
-        elements.push(element);
-
-      expect(elements).toEqual([1, 2, 3]);
-    });
-  });
-
-  describe('mixed operations', () => {
-    it('interleave enqueue and dequeue', () => {
-      const queue = new Queue<number>();
-
-      queue.enqueue(1);
-      queue.enqueue(2);
-      expect(queue.dequeue()).toBe(1);
-
-      queue.enqueue(3);
-      expect(queue.dequeue()).toBe(2);
-      expect(queue.dequeue()).toBe(3);
-      expect(queue.isEmpty).toBe(true);
-    });
-
-    it('reuse queue after clear', () => {
-      const queue = new Queue([1, 2, 3]);
-      queue.clear();
-      queue.enqueue(4);
-
-      expect(queue.length).toBe(1);
-      expect(queue.peek()).toBe(4);
-    });
-  });
-});

core/stdlib/src/structs/Queue/index.ts

@@ -1,140 +0,0 @@
-import { Deque } from '../Deque';
-import type { QueueLike } from './types';
-
-export type { QueueLike } from './types';
-
-export interface QueueOptions {
-  maxSize?: number;
-}
-
-/**
- * @name Queue
- * @category Data Structures
- * @description Represents a queue data structure (FIFO) backed by a Deque
- *
- * @since 0.0.8
- *
- * @template T The type of elements stored in the queue
- */
-export class Queue<T> implements QueueLike<T> {
-  /**
-   * The underlying deque
-   *
-   * @private
-   * @type {Deque<T>}
-   */
-  private readonly deque: Deque<T>;
-
-  /**
-   * Creates an instance of Queue
-   *
-   * @param {(T[] | T)} [initialValues] The initial values to add to the queue
-   * @param {QueueOptions} [options] The options for the queue
-   */
-  constructor(initialValues?: T[] | T, options?: QueueOptions) {
-    this.deque = new Deque(initialValues, options);
-  }
-
-  /**
-   * Gets the number of elements in the queue
-   * @returns {number} The number of elements in the queue
-   */
-  get length() {
-    return this.deque.length;
-  }
-
-  /**
-   * Checks if the queue is empty
-   * @returns {boolean} `true` if the queue is empty, `false` otherwise
-   */
-  get isEmpty() {
-    return this.deque.isEmpty;
-  }
-
-  /**
-   * Checks if the queue is full
-   * @returns {boolean} `true` if the queue is full, `false` otherwise
-   */
-  get isFull() {
-    return this.deque.isFull;
-  }
-
-  /**
-   * Adds an element to the back of the queue
-   * @param {T} element The element to enqueue
-   * @returns {this}
-   * @throws {RangeError} If the queue is full
-   */
-  enqueue(element: T) {
-    if (this.deque.isFull)
-      throw new RangeError('Queue is full');
-
-    this.deque.pushBack(element);
-
-    return this;
-  }
-
-  /**
-   * Removes and returns the front element of the queue
-   * @returns {T | undefined} The front element, or undefined if the queue is empty
-   */
-  dequeue() {
-    return this.deque.popFront();
-  }
-
-  /**
-   * Returns the front element without removing it
-   * @returns {T | undefined} The front element, or undefined if the queue is empty
-   */
-  peek() {
-    return this.deque.peekFront();
-  }
-
-  /**
-   * Clears the queue
-   *
-   * @returns {this}
-   */
-  clear() {
-    this.deque.clear();
-
-    return this;
-  }
-
-  /**
-   * Converts the queue to an array in FIFO order
-   *
-   * @returns {T[]}
-   */
-  toArray() {
-    return this.deque.toArray();
-  }
-
-  /**
-   * Returns a string representation of the queue
-   *
-   * @returns {string}
-   */
-  toString() {
-    return this.deque.toString();
-  }
-
-  /**
-   * Returns an iterator for the queue
-   *
-   * @returns {IterableIterator<T>}
-   */
-  [Symbol.iterator]() {
-    return this.deque[Symbol.iterator]();
-  }
-
-  /**
-   * Returns an async iterator for the queue
-   *
-   * @returns {AsyncIterableIterator<T>}
-   */
-  async *[Symbol.asyncIterator]() {
-    for (const element of this.deque)
-      yield element;
-  }
-}

core/stdlib/src/structs/Queue/types.ts

@@ -1,12 +0,0 @@
-export interface QueueLike<T> extends Iterable<T>, AsyncIterable<T> {
-  readonly length: number;
-  readonly isEmpty: boolean;
-  readonly isFull: boolean;
-
-  enqueue(element: T): this;
-  dequeue(): T | undefined;
-  peek(): T | undefined;
-  clear(): this;
-  toArray(): T[];
-  toString(): string;
-}

core/stdlib/src/structs/Stack/types.ts

@@ -1,12 +0,0 @@
-export interface StackLike<T> extends Iterable<T>, AsyncIterable<T> {
-  readonly length: number;
-  readonly isEmpty: boolean;
-  readonly isFull: boolean;
-
-  push(element: T): this;
-  pop(): T | undefined;
-  peek(): T | undefined;
-  clear(): this;
-  toArray(): T[];
-  toString(): string;
-}

core/stdlib/src/structs/index.ts

@@ -1,7 +0,0 @@
-export * from './BinaryHeap';
-export * from './CircularBuffer';
-export * from './Deque';
-export * from './LinkedList';
-export * from './PriorityQueue';
-export * from './Queue';
-export * from './Stack';

core/stdlib/src/sync/index.ts

@@ -1 +0,0 @@
-export * from './mutex';

core/stdlib/src/sync/mutex/index.test.ts

@@ -1,94 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { SyncMutex } from '.';
-
-describe('SyncMutex', () => {
-  let mutex: SyncMutex;
-
-  beforeEach(() => {
-    mutex = new SyncMutex();
-  });
-
-  it('unlocked by default', () => {
-    expect(mutex.isLocked).toBe(false);
-  });
-
-  it('lock the mutex', () => {
-    mutex.lock();
-  
-    expect(mutex.isLocked).toBe(true);
-  });
-
-  it('remain locked when locked multiple times', () => {
-    mutex.lock();
-    mutex.lock();
-  
-    expect(mutex.isLocked).toBe(true);
-  });
-
-  it('unlock a locked mutex', () => {
-    mutex.lock();
-    mutex.unlock();
-  
-    expect(mutex.isLocked).toBe(false);
-  });
-
-  it('remain unlocked when unlocked multiple times', () => {
-    mutex.unlock();
-    mutex.unlock();
-
-    expect(mutex.isLocked).toBe(false);
-  });
-
-  it('reflect the current lock state', () => {
-    expect(mutex.isLocked).toBe(false);
-    mutex.lock();
-    expect(mutex.isLocked).toBe(true);
-    mutex.unlock();
-    expect(mutex.isLocked).toBe(false);
-  });
-
-  it('execute a callback when unlocked', async () => {
-    const callback = vi.fn(() => 'done');
-    const result = await mutex.execute(callback);
-  
-    expect(result).toBe('done');
-    expect(callback).toHaveBeenCalled();
-  });
-
-  it('execute a promise callback when unlocked', async () => {
-    const callback = vi.fn(() => Promise.resolve('done'));
-    const result = await mutex.execute(callback);
-  
-    expect(result).toBe('done');
-    expect(callback).toHaveBeenCalled();
-  });
-
-  it('execute concurrent callbacks only one at a time', async () => {
-    const callback = vi.fn(() => Promise.resolve('done'));
-
-    const result = await Promise.all([
-      mutex.execute(callback),
-      mutex.execute(callback),
-      mutex.execute(callback),
-    ]);
-  
-    expect(result).toEqual(['done', undefined, undefined]);
-    expect(callback).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not execute a callback when locked', async () => {
-    const callback = vi.fn(() => 'done');
-    mutex.lock();
-    const result = await mutex.execute(callback);
-
-    expect(result).toBeUndefined();
-    expect(callback).not.toHaveBeenCalled();
-  });
-
-  it('unlocks after executing a callback', async () => {
-    const callback = vi.fn(() => 'done');
-    await mutex.execute(callback);
-  
-    expect(mutex.isLocked).toBe(false);
-  });
-});

core/stdlib/src/sync/mutex/index.ts

@@ -1,45 +0,0 @@
-/**
- * @name SyncMutex
- * @category Utils
- * @description A simple synchronous mutex to provide more readable locking and unlocking of code blocks
- * 
- * @example
- * const mutex = new SyncMutex();
- * 
- * mutex.lock();
- *
- * mutex.unlock();
- * 
- * const result = await mutex.execute(() => {
- *  // do something
- *  return Promise.resolve('done');  
- * });
- * 
- * @since 0.0.5
- */
-export class SyncMutex {
-  private state = false;
-
-  public get isLocked() {
-    return this.state;
-  }
-
-  public lock() {
-    this.state = true;
-  }
-
-  public unlock() {
-    this.state = false;
-  }
-
-  public async execute<T>(callback: () => T) {
-    if (this.isLocked)
-      return;
-
-    this.lock();
-    const result = await callback();
-    this.unlock();
-
-    return result;
-  }
-}

core/stdlib/tsdown.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from 'tsdown';
-import { sharedConfig } from '@robonen/tsdown';
-
-export default defineConfig({
-  ...sharedConfig,
-  entry: ['src/index.ts'],
-});

docs/.vitepress/config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitepress';
+
+export default defineConfig({
+  lang: 'ru-RU',
+  title: "Toolkit",
+  description: "A collection of typescript and javascript development tools",
+  rewrites: {
+    'packages/:pkg/README.md': 'packages/:pkg/index.md',
+  },
+  themeConfig: {
+    sidebar: [
+      {
+        text: 'Пакеты',
+        items: [
+          { text: '@robonen/tsconfig', link: '/packages/tsconfig/' },
+          { text: '@robonen/renovate', link: '/packages/renovate/' },
+          { text: '@robonen/stdlib', link: '/packages/stdlib/' },
+        ],
+      },
+    ],
+  },
+});

docs/index.md

@@ -0,0 +1,14 @@
+---
+# https://vitepress.dev/reference/default-theme-home-page
+layout: home
+
+hero:
+  name: Toolkit 
+  tagline: A collection of typescript and javascript development tools
+  actions:
+    - theme: brand
+      text: Get Started
+      link: /
+    - theme: alt
+      text: View on GitHub
+      link: /

infra/renovate/README.md

@@ -1,21 +0,0 @@
-# @robonen/renovate
-
-Shared [Renovate](https://docs.renovatebot.com/) configuration preset.
-
-## Usage
-
-Reference it in your `renovate.json`:
-
-```json
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["github>robonen/tools//infra/renovate/default.json"]
-}
-```
-
-## What's Included
-
-- Extends `config:base` and `group:allNonMajor`
-- Semantic commit type: `chore`
-- Range strategy: `bump`
-- Auto-approves & auto-merges minor, patch, pin, and digest updates (scheduled 1–3 AM)

package.json

@@ -15,26 +15,25 @@
     "type": "git",
     "url": "git+https://github.com/robonen/tools.git"
   },
-  "packageManager": "pnpm@10.29.3",
+  "packageManager": "pnpm@9.15.4",
   "engines": {
-    "node": ">=24.13.1"
+    "node": ">=22.13.0"
   },
   "type": "module",
   "devDependencies": {
-    "@types/node": "^24.10.13",
+    "@types/node": "^22.10.7",
-    "@vitest/coverage-v8": "catalog:",
+    "citty": "^0.1.6",
-    "@vitest/ui": "catalog:",
+    "jiti": "^2.4.2",
-    "citty": "^0.2.1",
+    "pathe": "^2.0.2",
-    "jiti": "^2.6.1",
-    "jsdom": "catalog:",
     "scule": "^1.3.0",
-    "vitest": "catalog:"
+    "vitepress": "^1.5.0"
   },
   "scripts": {
-    "build": "pnpm -r build",
+    "all:build": "pnpm -r build",
-    "lint": "pnpm -r lint",
+    "all:test": "pnpm -r test",
-    "test": "vitest run",
+    "create": "jiti ./cli.ts",
-    "test:ui": "vitest --ui",
+    "docs:dev": "vitepress dev .",
-    "create": "jiti ./bin/cli.ts"
+    "docs:build": "vitepress build .",
+    "docs:preview": "vitepress preview ."
   }
 }

packages/platform/README.md

@@ -0,0 +1 @@
+# @robonen/platform

packages/platform/build.config.ts

@@ -0,0 +1,16 @@
+import { defineBuildConfig } from 'unbuild';
+
+export default defineBuildConfig({
+  entries: [
+    'src/browsers',
+    'src/multi',
+  ],
+  clean: true,
+  declaration: true,
+  rollup: {
+    emitCJS: true,
+    esbuild: {
+      // minify: true,
+    },
+  },
+});

packages/platform/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robonen/platform",
-  "version": "0.0.4",
+  "version": "0.0.3",
   "license": "Apache-2.0",
   "description": "Platform dependent utilities for javascript development",
   "keywords": [
@@ -18,9 +18,9 @@
     "url": "git+https://github.com/robonen/tools.git",
     "directory": "packages/platform"
   },
-  "packageManager": "pnpm@10.29.3",
+  "packageManager": "pnpm@9.15.4",
   "engines": {
-    "node": ">=24.13.1"
+    "node": ">=22.13.0"
   },
   "type": "module",
   "files": [
@@ -28,27 +28,25 @@
   ],
   "exports": {
     "./browsers": {
-      "types": "./dist/browsers.d.ts",
+      "import": "./dist/browsers.mjs",
-      "import": "./dist/browsers.js",
+      "require": "./dist/browsers.cjs",
-      "require": "./dist/browsers.cjs"
+      "types": "./dist/browsers.d.ts"
     },
     "./multi": {
-      "types": "./dist/multi.d.ts",
+      "import": "./dist/multi.mjs",
-      "import": "./dist/multi.js",
+      "require": "./dist/multi.cjs",
-      "require": "./dist/multi.cjs"
+      "types": "./dist/multi.d.ts"
     }
   },
   "scripts": {
-    "lint": "oxlint -c oxlint.config.ts",
     "test": "vitest run",
     "dev": "vitest dev",
-    "build": "tsdown"
+    "build": "unbuild"
   },
   "devDependencies": {
-    "@robonen/oxlint": "workspace:*",
     "@robonen/tsconfig": "workspace:*",
-    "@robonen/tsdown": "workspace:*",
+    "jsdom": "catalog:",
-    "oxlint": "catalog:",
+    "unbuild": "catalog:",
-    "tsdown": "catalog:"
+    "vitest": "catalog:"
   }
 }

packages/platform/src/browsers/focusGuard/index.ts

@@ -18,7 +18,7 @@
  * 
  * @since 0.0.3
  */
-export function focusGuard(namespace = 'focus-guard') {
+export function focusGuard(namespace: string = 'focus-guard') {
   const guardAttr = `data-${namespace}`;
 
   const createGuard = () => {
@@ -39,7 +39,7 @@ export function focusGuard(namespace = 'focus-guard') {
   };
 }
 
-export function createGuardAttrs(namespace = 'focus-guard') {
+export function createGuardAttrs(namespace: string) {
   const element = document.createElement('span');
 
   element.setAttribute(namespace, '');

packages/platform/src/multi/debounce/index.ts

@@ -1,5 +1,3 @@
-// eslint-disable
-
 export interface DebounceOptions {
     /**
      * Call the function on the leading edge of the timeout, instead of waiting for the trailing edge

packages/platform/vitest.config.ts

@@ -5,4 +5,3 @@ export default defineConfig({
     environment: 'jsdom',
   },
 });
-

packages/renovate/README.md

@@ -0,0 +1 @@
+# @robonen/renovate

packages/renovate/package.json

@@ -16,9 +16,9 @@
     "url": "git+https://github.com/robonen/tools.git",
     "directory": "packages/renovate"
   },
-  "packageManager": "pnpm@10.29.3",
+  "packageManager": "pnpm@9.15.4",
   "engines": {
-    "node": ">=24.13.1"
+    "node": ">=22.13.0"
   },
   "files": [
     "default.json"
@@ -27,6 +27,6 @@
     "test": "renovate-config-validator ./default.json"
   },
   "devDependencies": {
-    "renovate": "^43.15.0"
+    "renovate": "^39.115.2"
   }
 }

packages/stdlib/README.md

@@ -0,0 +1 @@
+# @robonen/stdlib

packages/stdlib/build.config.ts

@@ -0,0 +1,9 @@
+import { defineBuildConfig } from 'unbuild';
+
+export default defineBuildConfig({
+  rollup: {
+    esbuild: {
+        // minify: true,
+    },
+  },
+});

packages/stdlib/jsr.json

@@ -1,6 +1,6 @@
 {
     "$schema": "https://jsr.io/schema/config-file.v1.json",
     "name": "@robonen/stdlib",
-    "version": "0.0.7",
+    "version": "0.0.4",
     "exports": "./src/index.ts"
 }

packages/stdlib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robonen/stdlib",
-  "version": "0.0.9",
+  "version": "0.0.4",
   "license": "Apache-2.0",
   "description": "A collection of tools, utilities, and helpers for TypeScript",
   "keywords": [
@@ -18,32 +18,34 @@
     "url": "git+https://github.com/robonen/tools.git",
     "directory": "packages/stdlib"
   },
-  "packageManager": "pnpm@10.29.3",
+  "packageManager": "pnpm@9.15.4",
   "engines": {
-    "node": ">=24.13.1"
+    "node": ">=22.13.0"
   },
   "type": "module",
   "files": [
     "dist"
   ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
-      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
-      "require": "./dist/index.cjs"
+      "types": "./dist/index.d.ts"
     }
   },
   "scripts": {
-    "lint": "oxlint -c oxlint.config.ts",
     "test": "vitest run",
     "dev": "vitest dev",
-    "build": "tsdown"
+    "build": "unbuild"
   },
   "devDependencies": {
-    "@robonen/oxlint": "workspace:*",
     "@robonen/tsconfig": "workspace:*",
-    "@robonen/tsdown": "workspace:*",
+    "@vitest/coverage-v8": "catalog:",
-    "oxlint": "catalog:",
+    "pathe": "catalog:",
-    "tsdown": "catalog:"
+    "unbuild": "catalog:",
+    "vitest": "catalog:"
   }
 }