diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 76d7ac5..b2233aa 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -31,5 +31,11 @@ jobs:
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
+      - name: Build
+        run: pnpm build
+
+      - name: Lint
+        run: pnpm lint
+
       - name: Test
-        run: pnpm build && pnpm test
\ No newline at end of file
+        run: pnpm test
\ No newline at end of file
diff --git a/configs/oxlint/README.md b/configs/oxlint/README.md
new file mode 100644
index 0000000..96817c7
--- /dev/null
+++ b/configs/oxlint/README.md
@@ -0,0 +1,54 @@
+# @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
diff --git a/configs/oxlint/oxlint.config.ts b/configs/oxlint/oxlint.config.ts
new file mode 100644
index 0000000..247c39b
--- /dev/null
+++ b/configs/oxlint/oxlint.config.ts
@@ -0,0 +1,4 @@
+import { defineConfig } from 'oxlint';
+import { compose, base, typescript, imports } from '@robonen/oxlint';
+
+export default defineConfig(compose(base, typescript, imports));
diff --git a/configs/oxlint/package.json b/configs/oxlint/package.json
new file mode 100644
index 0000000..aca8997
--- /dev/null
+++ b/configs/oxlint/package.json
@@ -0,0 +1,52 @@
+{
+  "name": "@robonen/oxlint",
+  "version": "0.0.1",
+  "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": ">=22.18.0"
+  },
+  "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:*",
+    "oxlint": "catalog:",
+    "tsdown": "catalog:"
+  },
+  "peerDependencies": {
+    "oxlint": ">=1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/configs/oxlint/src/compose.ts b/configs/oxlint/src/compose.ts
new file mode 100644
index 0000000..96993fc
--- /dev/null
+++ b/configs/oxlint/src/compose.ts
@@ -0,0 +1,103 @@
+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;
+}
diff --git a/configs/oxlint/src/index.ts b/configs/oxlint/src/index.ts
new file mode 100644
index 0000000..b026d25
--- /dev/null
+++ b/configs/oxlint/src/index.ts
@@ -0,0 +1,17 @@
+/* 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';
diff --git a/configs/oxlint/src/presets/base.ts b/configs/oxlint/src/presets/base.ts
new file mode 100644
index 0000000..22695b9
--- /dev/null
+++ b/configs/oxlint/src/presets/base.ts
@@ -0,0 +1,73 @@
+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',
+  },
+};
diff --git a/configs/oxlint/src/presets/imports.ts b/configs/oxlint/src/presets/imports.ts
new file mode 100644
index 0000000..f3a6276
--- /dev/null
+++ b/configs/oxlint/src/presets/imports.ts
@@ -0,0 +1,20 @@
+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'],
+  },
+};
diff --git a/configs/oxlint/src/presets/index.ts b/configs/oxlint/src/presets/index.ts
new file mode 100644
index 0000000..c17cbeb
--- /dev/null
+++ b/configs/oxlint/src/presets/index.ts
@@ -0,0 +1,6 @@
+export { base } from './base';
+export { typescript } from './typescript';
+export { vue } from './vue';
+export { vitest } from './vitest';
+export { imports } from './imports';
+export { node } from './node';
diff --git a/configs/oxlint/src/presets/node.ts b/configs/oxlint/src/presets/node.ts
new file mode 100644
index 0000000..59ffb3c
--- /dev/null
+++ b/configs/oxlint/src/presets/node.ts
@@ -0,0 +1,17 @@
+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',
+  },
+};
diff --git a/configs/oxlint/src/presets/typescript.ts b/configs/oxlint/src/presets/typescript.ts
new file mode 100644
index 0000000..dfe8107
--- /dev/null
+++ b/configs/oxlint/src/presets/typescript.ts
@@ -0,0 +1,39 @@
+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',
+      },
+    },
+  ],
+};
diff --git a/configs/oxlint/src/presets/vitest.ts b/configs/oxlint/src/presets/vitest.ts
new file mode 100644
index 0000000..df9a9fe
--- /dev/null
+++ b/configs/oxlint/src/presets/vitest.ts
@@ -0,0 +1,35 @@
+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',
+      },
+    },
+  ],
+};
diff --git a/configs/oxlint/src/presets/vue.ts b/configs/oxlint/src/presets/vue.ts
new file mode 100644
index 0000000..fb8cd73
--- /dev/null
+++ b/configs/oxlint/src/presets/vue.ts
@@ -0,0 +1,26 @@
+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',
+  },
+};
diff --git a/configs/oxlint/src/types.ts b/configs/oxlint/src/types.ts
new file mode 100644
index 0000000..150b065
--- /dev/null
+++ b/configs/oxlint/src/types.ts
@@ -0,0 +1,18 @@
+/**
+ * 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';
diff --git a/configs/oxlint/test/compose.test.ts b/configs/oxlint/test/compose.test.ts
new file mode 100644
index 0000000..1ff07e1
--- /dev/null
+++ b/configs/oxlint/test/compose.test.ts
@@ -0,0 +1,146 @@
+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();
+  });
+});
diff --git a/configs/oxlint/tsconfig.json b/configs/oxlint/tsconfig.json
new file mode 100644
index 0000000..077d6a1
--- /dev/null
+++ b/configs/oxlint/tsconfig.json
@@ -0,0 +1,6 @@
+{
+  "extends": "@robonen/tsconfig/tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "."
+  }
+}
diff --git a/configs/oxlint/tsdown.config.ts b/configs/oxlint/tsdown.config.ts
new file mode 100644
index 0000000..f5f5059
--- /dev/null
+++ b/configs/oxlint/tsdown.config.ts
@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: true,
+  clean: true,
+  hash: false,
+});
diff --git a/configs/oxlint/vitest.config.ts b/configs/oxlint/vitest.config.ts
new file mode 100644
index 0000000..4ac6027
--- /dev/null
+++ b/configs/oxlint/vitest.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+  },
+});
diff --git a/configs/tsconfig/README.md b/configs/tsconfig/README.md
index 9e1908b..10f9f81 100644
--- a/configs/tsconfig/README.md
+++ b/configs/tsconfig/README.md
@@ -1,45 +1,27 @@
 # @robonen/tsconfig
 
-Базовый конфигурационный файл для TypeScript
+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
 
-```json
-{
-  "module": "Preserve",           // использовать ту же версию модуля, что и сборщик
-  "noEmit": true,                 // не генерировать файлы
-  "moduleResolution": "Bundler",  // разрешение модулей на основе сборщика
-  "target": "ESNext",             // целевая версия JavaScript
-  
-  
-  "skipLibCheck": true,                   // не проверять типы, заданные во всех файлах описания типов (*.d.ts)
-  "esModuleInterop": true,                // создать хелперы __importStar и __importDefault для обеспечения совместимости с экосистемой Babel и включить allowSyntheticDefaultImports для совместимости с системой типов
-  "allowSyntheticDefaultImports": true,   // разрешить импортировать модули не имеющие внутри себя "import default"
-  "allowJs": true,                        // разрешить импортировать файлы JavaScript
-  "resolveJsonModule": true,              // разрешить импортировать файлы JSON
-  "moduleDetection": "force",             // заставляет TypeScript рассматривать все файлы как модули. Это помогает избежать ошибок cannot redeclare block-scoped variable»
-  "isolatedModules": true,                // орабатывать каждый файл, как отдельный изолированный модуль
-  "removeComments": false,                 // удалять комментарии из исходного кода
-  "verbatimModuleSyntax": true,           // сохранять синтаксис модулей в исходном коде (важно при импорте типов)
-  "useDefineForClassFields": true,        // использование классов стандарта TC39, а не TypeScript  
-  "strict": true,                         // включить все строгие проверки (noImplicitAny, noImplicitThis, alwaysStrict, strictNullChecks, strictFunctionTypes, strictPropertyInitialization)
-  "noUncheckedIndexedAccess": true,       // запрещает доступ к массиву или объекту без предварительной проверки того, определен ли он  
-  "declaration": true,                    // генерировать файлы описания типов (*.d.ts)
-  
-  "composite": true,                      // указывает TypeScript создавать файлы .tsbuildinfo. Это сообщает TypeScript, что ваш проект является частью монорепозитория, а также помогает кэшировать сборки для более быстрой работы
-  "sourceMap": true,                      // генерировать карту исходного кода
-  "declarationMap": true                  // генерировать карту исходного кода для файлов описания типов (*.d.ts)
-}  
-```
+- **Target / Module**: ESNext with Bundler resolution
+- **Strict mode**: `strict`, `noUncheckedIndexedAccess`
+- **Module safety**: `verbatimModuleSyntax`, `isolatedModules`
+- **Declarations**: `declaration` enabled
+- **Interop**: `esModuleInterop`, `allowJs`, `resolveJsonModule`
diff --git a/core/platform/README.md b/core/platform/README.md
index 629b30e..3983bd2 100644
--- a/core/platform/README.md
+++ b/core/platform/README.md
@@ -1 +1,23 @@
-# @robonen/platform
\ No newline at end of file
+# @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';
+```
\ No newline at end of file
diff --git a/core/platform/oxlint.config.ts b/core/platform/oxlint.config.ts
new file mode 100644
index 0000000..2a8522e
--- /dev/null
+++ b/core/platform/oxlint.config.ts
@@ -0,0 +1,15 @@
+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',
+				},
+			},
+		],
+	}),
+);
diff --git a/core/platform/package.json b/core/platform/package.json
index 5a2179c..ba37fee 100644
--- a/core/platform/package.json
+++ b/core/platform/package.json
@@ -39,12 +39,15 @@
     }
   },
   "scripts": {
+    "lint": "oxlint -c oxlint.config.ts",
     "test": "vitest run",
     "dev": "vitest dev",
     "build": "tsdown"
   },
   "devDependencies": {
+    "@robonen/oxlint": "workspace:*",
     "@robonen/tsconfig": "workspace:*",
+    "oxlint": "catalog:",
     "tsdown": "catalog:"
   }
 }
diff --git a/core/platform/src/browsers/focusGuard/index.ts b/core/platform/src/browsers/focusGuard/index.ts
index f4d7ec0..4ad1cf8 100644
--- a/core/platform/src/browsers/focusGuard/index.ts
+++ b/core/platform/src/browsers/focusGuard/index.ts
@@ -18,7 +18,7 @@
  * 
  * @since 0.0.3
  */
-export function focusGuard(namespace: string = 'focus-guard') {
+export function focusGuard(namespace = 'focus-guard') {
   const guardAttr = `data-${namespace}`;
 
   const createGuard = () => {
@@ -39,7 +39,7 @@ export function focusGuard(namespace: string = 'focus-guard') {
   };
 }
 
-export function createGuardAttrs(namespace: string) {
+export function createGuardAttrs(namespace = 'focus-guard') {
   const element = document.createElement('span');
 
   element.setAttribute(namespace, '');
diff --git a/core/platform/src/multi/debounce/index.ts b/core/platform/src/multi/debounce/index.ts
index bb803be..d61307e 100644
--- a/core/platform/src/multi/debounce/index.ts
+++ b/core/platform/src/multi/debounce/index.ts
@@ -1,3 +1,5 @@
+// eslint-disable
+
 export interface DebounceOptions {
     /**
      * Call the function on the leading edge of the timeout, instead of waiting for the trailing edge
diff --git a/core/stdlib/README.md b/core/stdlib/README.md
index 728ebbe..609ce8f 100644
--- a/core/stdlib/README.md
+++ b/core/stdlib/README.md
@@ -1 +1,32 @@
-# @robonen/stdlib
\ No newline at end of file
+# @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';
+```
\ No newline at end of file
diff --git a/core/stdlib/oxlint.config.ts b/core/stdlib/oxlint.config.ts
new file mode 100644
index 0000000..247c39b
--- /dev/null
+++ b/core/stdlib/oxlint.config.ts
@@ -0,0 +1,4 @@
+import { defineConfig } from 'oxlint';
+import { compose, base, typescript, imports } from '@robonen/oxlint';
+
+export default defineConfig(compose(base, typescript, imports));
diff --git a/core/stdlib/package.json b/core/stdlib/package.json
index 5bede55..770369d 100644
--- a/core/stdlib/package.json
+++ b/core/stdlib/package.json
@@ -34,12 +34,15 @@
     }
   },
   "scripts": {
+    "lint": "oxlint -c oxlint.config.ts",
     "test": "vitest run",
     "dev": "vitest dev",
     "build": "tsdown"
   },
   "devDependencies": {
+    "@robonen/oxlint": "workspace:*",
     "@robonen/tsconfig": "workspace:*",
+    "oxlint": "catalog:",
     "tsdown": "catalog:"
   }
 }
diff --git a/core/stdlib/src/async/pool/index.ts b/core/stdlib/src/async/pool/index.ts
index 4a6125c..0f6010f 100644
--- a/core/stdlib/src/async/pool/index.ts
+++ b/core/stdlib/src/async/pool/index.ts
@@ -1,3 +1,3 @@
-export type AsyncPoolOptions = {
+export interface AsyncPoolOptions {
   concurrency?: number;
 }
\ No newline at end of file
diff --git a/core/stdlib/src/async/retry/index.ts b/core/stdlib/src/async/retry/index.ts
index f9aadf8..7b74126 100644
--- a/core/stdlib/src/async/retry/index.ts
+++ b/core/stdlib/src/async/retry/index.ts
@@ -1,3 +1,4 @@
+// eslint-disable
 export interface RetryOptions {
   times?: number;
   delay?: number;
diff --git a/core/stdlib/src/bits/vector/index.ts b/core/stdlib/src/bits/vector/index.ts
index aa1c745..dbccbff 100644
--- a/core/stdlib/src/bits/vector/index.ts
+++ b/core/stdlib/src/bits/vector/index.ts
@@ -1,4 +1,4 @@
-export interface BitVector {
+export interface BitVectorLike {
   getBit(index: number): boolean;
   setBit(index: number): void;
   clearBit(index: number): void;
@@ -12,7 +12,7 @@ export interface BitVector {
  * 
  * @since 0.0.3
  */
-export class BitVector extends Uint8Array implements BitVector {
+export class BitVector extends Uint8Array implements BitVectorLike {
   constructor(size: number) {
     super(Math.ceil(size / 8));
   }
diff --git a/core/stdlib/src/collections/get/index.ts b/core/stdlib/src/collections/get/index.ts
index 888c058..e5bc56c 100644
--- a/core/stdlib/src/collections/get/index.ts
+++ b/core/stdlib/src/collections/get/index.ts
@@ -1,4 +1,4 @@
-import { type Collection, type Path } from '../../types';
+import type { Collection, Path } from '../../types';
 
 export type ExtractFromObject<O extends Record<PropertyKey, unknown>, K> =
   K extends keyof O
@@ -9,7 +9,7 @@ export type ExtractFromObject<O extends Record<PropertyKey, unknown>, K> =
 
 export type ExtractFromArray<A extends readonly any[], K> =
   any[] extends A
-    ? A extends readonly (infer T)[]
+    ? A extends ReadonlyArray<infer T>
       ? T | undefined
       : undefined
     : K extends keyof A
diff --git a/core/stdlib/src/math/basic/clamp/index.test.ts b/core/stdlib/src/math/basic/clamp/index.test.ts
index e637d0a..342485b 100644
--- a/core/stdlib/src/math/basic/clamp/index.test.ts
+++ b/core/stdlib/src/math/basic/clamp/index.test.ts
@@ -46,13 +46,13 @@ describe('clamp', () => {
 
   it('handle NaN and Infinity', () => {
     // value is NaN
-    expect(clamp(NaN, 0, 100)).toBe(NaN);
+    expect(clamp(Number.NaN, 0, 100)).toBe(Number.NaN);
 
     // min is NaN
-    expect(clamp(50, NaN, 100)).toBe(NaN);
+    expect(clamp(50, Number.NaN, 100)).toBe(Number.NaN);
 
     // max is NaN
-    expect(clamp(50, 0, NaN)).toBe(NaN);
+    expect(clamp(50, 0, Number.NaN)).toBe(Number.NaN);
 
     // value is Infinity
     expect(clamp(Infinity, 0, 100)).toBe(100);
diff --git a/core/stdlib/src/objects/omit/index.ts b/core/stdlib/src/objects/omit/index.ts
index 840147c..9f99b51 100644
--- a/core/stdlib/src/objects/omit/index.ts
+++ b/core/stdlib/src/objects/omit/index.ts
@@ -1,4 +1,5 @@
-import { isArray, type Arrayable } from '../../types';
+import { isArray } from '../../types';
+import type { Arrayable } from '../../types';
 
 /**
  * @name omit
diff --git a/core/stdlib/src/objects/pick/index.ts b/core/stdlib/src/objects/pick/index.ts
index 9a0b167..2589d9c 100644
--- a/core/stdlib/src/objects/pick/index.ts
+++ b/core/stdlib/src/objects/pick/index.ts
@@ -1,4 +1,5 @@
-import { isArray, type Arrayable } from '../../types';
+import { isArray } from '../../types';
+import type { Arrayable } from '../../types';
 
 /**
  * @name pick
diff --git a/core/stdlib/src/structs/stack/index.ts b/core/stdlib/src/structs/stack/index.ts
index 20c30f5..4780a80 100644
--- a/core/stdlib/src/structs/stack/index.ts
+++ b/core/stdlib/src/structs/stack/index.ts
@@ -1,9 +1,9 @@
 import { last } from '../../arrays';
 import { isArray } from '../../types';
 
-export type StackOptions = {
+export interface StackOptions {
     maxSize?: number;
-};
+}
 
 /**
  * @name Stack
diff --git a/core/stdlib/src/sync/mutex/index.ts b/core/stdlib/src/sync/mutex/index.ts
index 991bc19..b2ddaa2 100644
--- a/core/stdlib/src/sync/mutex/index.ts
+++ b/core/stdlib/src/sync/mutex/index.ts
@@ -1,5 +1,3 @@
-import type { MaybePromise } from "../../types";
-
 /**
  * @name SyncMutex
  * @category Utils
diff --git a/core/stdlib/src/text/template/index.ts b/core/stdlib/src/text/template/index.ts
index 926e501..a23f447 100644
--- a/core/stdlib/src/text/template/index.ts
+++ b/core/stdlib/src/text/template/index.ts
@@ -1,5 +1,6 @@
 import { get } from '../../collections';
-import { isFunction, type Path, type PathToType, type Stringable, type Trim, type UnionToIntersection } from '../../types';
+import { isFunction } from '../../types';
+import type { Collection, Path, PathToType, Stringable, Trim, UnionToIntersection } from '../../types';
 
 /**
  * Type of a value that will be used to replace a placeholder in a template.
@@ -55,7 +56,7 @@ export type GenerateTypes<T extends string, Target = string> = UnionToIntersecti
 
 export function templateObject<
   T extends string,
-  A extends GenerateTypes<ExtractPlaceholders<T>, TemplateValue>
+  A extends GenerateTypes<ExtractPlaceholders<T>, TemplateValue> & Collection
 >(template: T, args: A, fallback?: TemplateFallback) {
     return template.replace(TEMPLATE_PLACEHOLDER, (_, key) => {    
         const value = get(args, key)?.toString();
diff --git a/core/stdlib/src/text/trigram-distance/index.ts b/core/stdlib/src/text/trigram-distance/index.ts
index b1458dc..ee24fbd 100644
--- a/core/stdlib/src/text/trigram-distance/index.ts
+++ b/core/stdlib/src/text/trigram-distance/index.ts
@@ -11,7 +11,7 @@ export type Trigrams = Map<string, number>;
  * @since 0.0.1
  */
 export function trigramProfile(text: string): Trigrams {
-    text = '\n\n' + text + '\n\n';
+    text = `\n\n${text}\n\n`;
 
     const trigrams = new Map<string, number>();
 
diff --git a/core/stdlib/src/types/js/casts.test.ts b/core/stdlib/src/types/js/casts.test.ts
index 568a9c2..c79abfd 100644
--- a/core/stdlib/src/types/js/casts.test.ts
+++ b/core/stdlib/src/types/js/casts.test.ts
@@ -19,7 +19,7 @@ describe('casts', () => {
       expect(toString(null)).toBe('[object Null]');
       expect(toString(/abc/)).toBe('[object RegExp]');
       expect(toString(new Date())).toBe('[object Date]');
-      expect(toString(new Error())).toBe('[object Error]');
+      expect(toString(new Error('test'))).toBe('[object Error]');
       expect(toString(new Promise(() => {}))).toBe('[object Promise]');
       expect(toString(new Map())).toBe('[object Map]');
       expect(toString(new Set())).toBe('[object Set]');
diff --git a/core/stdlib/src/types/js/complex.test.ts b/core/stdlib/src/types/js/complex.test.ts
index ceff211..133f5f1 100644
--- a/core/stdlib/src/types/js/complex.test.ts
+++ b/core/stdlib/src/types/js/complex.test.ts
@@ -77,7 +77,7 @@ describe('complex', () => {
   
   describe('isError', () => {
     it('true if the value is an error', () => {
-      expect(isError(new Error())).toBe(true);
+      expect(isError(new Error('test'))).toBe(true);
     });
   
     it('false if the value is not an error', () => {
diff --git a/core/stdlib/src/types/js/complex.ts b/core/stdlib/src/types/js/complex.ts
index 2915e0e..77f2f48 100644
--- a/core/stdlib/src/types/js/complex.ts
+++ b/core/stdlib/src/types/js/complex.ts
@@ -1,4 +1,4 @@
-import { toString } from '.';
+import { toString } from './casts';
 
 /**
  * @name isFunction
diff --git a/core/stdlib/src/types/js/primitives.ts b/core/stdlib/src/types/js/primitives.ts
index d91d1da..0573a11 100644
--- a/core/stdlib/src/types/js/primitives.ts
+++ b/core/stdlib/src/types/js/primitives.ts
@@ -1,4 +1,4 @@
-import { toString } from '.';
+import { toString } from './casts';
 
 /**
  * @name isObject
diff --git a/core/stdlib/src/types/ts/collections.test-d.ts b/core/stdlib/src/types/ts/collections.test-d.ts
index 822fe58..30ee871 100644
--- a/core/stdlib/src/types/ts/collections.test-d.ts
+++ b/core/stdlib/src/types/ts/collections.test-d.ts
@@ -35,35 +35,35 @@ describe('collections', () => {
   describe('PathToType', () => {
     it('convert simple object path', () => {
       type actual = PathToType<['user', 'name']>;
-      type expected = { user: { name: unknown } };
+      interface expected { user: { name: unknown } }
 
       expectTypeOf<actual>().toEqualTypeOf<expected>();
     });
 
     it('convert simple array path', () => {
       type actual = PathToType<['user', '0']>;
-      type expected = { user: unknown[] };
+      interface expected { user: unknown[] }
 
       expectTypeOf<actual>().toEqualTypeOf<expected>();
     });
 
     it('convert complex object path', () => {
       type actual = PathToType<['user', 'addresses', '0', 'street']>;
-      type expected = { user: { addresses: { street: unknown }[] } };
+      interface expected { user: { addresses: Array<{ street: unknown }> } }
 
       expectTypeOf<actual>().toEqualTypeOf<expected>();
     });
 
     it('convert double dot path', () => {
       type actual = PathToType<['user', '', 'name']>;
-      type expected = { user: { '': { name: unknown } } };
+      interface expected { user: { '': { name: unknown } } }
 
       expectTypeOf<actual>().toEqualTypeOf<expected>();
     });
 
     it('convert to custom target', () => {
       type actual = PathToType<['user', 'name'], string>;
-      type expected = { user: { name: string } };
+      interface expected { user: { name: string } }
 
       expectTypeOf<actual>().toEqualTypeOf<expected>();
     });
diff --git a/core/stdlib/src/types/ts/collections.ts b/core/stdlib/src/types/ts/collections.ts
index 57b4c2f..b05f271 100644
--- a/core/stdlib/src/types/ts/collections.ts
+++ b/core/stdlib/src/types/ts/collections.ts
@@ -20,7 +20,7 @@ export type PathToType<T extends string[], Target = unknown> =
   T extends [infer Head, ...infer Rest]
     ? Head extends `${number}`
       ? Rest extends string[]
-        ? PathToType<Rest, Target>[]
+        ? Array<PathToType<Rest, Target>>
         : never
       : Rest extends string[]
         ? { [K in Head & string]: PathToType<Rest, Target> }
diff --git a/core/stdlib/src/types/ts/string.test-d.ts b/core/stdlib/src/types/ts/string.test-d.ts
index 883933a..7ac0189 100644
--- a/core/stdlib/src/types/ts/string.test-d.ts
+++ b/core/stdlib/src/types/ts/string.test-d.ts
@@ -7,7 +7,7 @@ describe('string', () => {
         expectTypeOf(Number(1)).toExtend<Stringable>();
         expectTypeOf(String(1)).toExtend<Stringable>();
         expectTypeOf(Symbol()).toExtend<Stringable>();
-        expectTypeOf(new Array(1)).toExtend<Stringable>();
+        expectTypeOf([1]).toExtend<Stringable>();
         expectTypeOf(new Object()).toExtend<Stringable>();
         expectTypeOf(new Date()).toExtend<Stringable>();
       });
diff --git a/infra/renovate/README.md b/infra/renovate/README.md
index e6cbe57..9739056 100644
--- a/infra/renovate/README.md
+++ b/infra/renovate/README.md
@@ -1 +1,21 @@
-# @robonen/renovate
\ No newline at end of file
+# @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)
\ No newline at end of file
diff --git a/package.json b/package.json
index 0a93154..44082f9 100644
--- a/package.json
+++ b/package.json
@@ -32,6 +32,7 @@
   },
   "scripts": {
     "build": "pnpm -r build",
+    "lint": "pnpm -r lint",
     "test": "vitest run",
     "test:ui": "vitest --ui",
     "create": "jiti ./bin/cli.ts"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index aaaf600..25743c9 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -18,6 +18,9 @@ catalogs:
     jsdom:
       specifier: ^28.0.0
       version: 28.0.0
+    oxlint:
+      specifier: ^1.2.0
+      version: 1.47.0
     tsdown:
       specifier: ^0.12.5
       version: 0.12.9
@@ -57,22 +60,49 @@ importers:
         specifier: 'catalog:'
         version: 4.0.18(@opentelemetry/api@1.9.0)(@types/node@22.19.11)(@vitest/ui@4.0.18)(jiti@2.6.1)(jsdom@28.0.0)(terser@5.44.0)(yaml@2.8.2)
 
+  configs/oxlint:
+    devDependencies:
+      '@robonen/oxlint':
+        specifier: workspace:*
+        version: 'link:'
+      '@robonen/tsconfig':
+        specifier: workspace:*
+        version: link:../tsconfig
+      oxlint:
+        specifier: 'catalog:'
+        version: 1.47.0
+      tsdown:
+        specifier: 'catalog:'
+        version: 0.12.9(typescript@5.8.3)
+
   configs/tsconfig: {}
 
   core/platform:
     devDependencies:
+      '@robonen/oxlint':
+        specifier: workspace:*
+        version: link:../../configs/oxlint
       '@robonen/tsconfig':
         specifier: workspace:*
         version: link:../../configs/tsconfig
+      oxlint:
+        specifier: 'catalog:'
+        version: 1.47.0
       tsdown:
         specifier: 'catalog:'
         version: 0.12.9(typescript@5.8.3)
 
   core/stdlib:
     devDependencies:
+      '@robonen/oxlint':
+        specifier: workspace:*
+        version: link:../../configs/oxlint
       '@robonen/tsconfig':
         specifier: workspace:*
         version: link:../../configs/tsconfig
+      oxlint:
+        specifier: 'catalog:'
+        version: 1.47.0
       tsdown:
         specifier: 'catalog:'
         version: 0.12.9(typescript@5.8.3)
@@ -95,12 +125,18 @@ importers:
         specifier: 'catalog:'
         version: 3.5.28(typescript@5.8.3)
     devDependencies:
+      '@robonen/oxlint':
+        specifier: workspace:*
+        version: link:../../configs/oxlint
       '@robonen/tsconfig':
         specifier: workspace:*
         version: link:../../configs/tsconfig
       '@vue/test-utils':
         specifier: 'catalog:'
         version: 2.4.6
+      oxlint:
+        specifier: 'catalog:'
+        version: 1.47.0
       tsdown:
         specifier: 'catalog:'
         version: 0.12.9(typescript@5.8.3)
@@ -793,6 +829,128 @@ packages:
   '@oxc-project/types@0.113.0':
     resolution: {integrity: sha512-Tp3XmgxwNQ9pEN9vxgJBAqdRamHibi76iowQ38O2I4PMpcvNRQNVsU2n1x1nv9yh0XoTrGFzf7cZSGxmixxrhA==}
 
+  '@oxlint/binding-android-arm-eabi@1.47.0':
+    resolution: {integrity: sha512-UHqo3te9K/fh29brCuQdHjN+kfpIi9cnTPABuD5S9wb9ykXYRGTOOMVuSV/CK43sOhU4wwb2nT1RVjcbrrQjFw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [android]
+
+  '@oxlint/binding-android-arm64@1.47.0':
+    resolution: {integrity: sha512-xh02lsTF1TAkR+SZrRMYHR/xCx8Wg2MAHxJNdHVpAKELh9/yE9h4LJeqAOBbIb3YYn8o/D97U9VmkvkfJfrHfw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [android]
+
+  '@oxlint/binding-darwin-arm64@1.47.0':
+    resolution: {integrity: sha512-OSOfNJqabOYbkyQDGT5pdoL+05qgyrmlQrvtCO58M4iKGEQ/xf3XkkKj7ws+hO+k8Y4VF4zGlBsJlwqy7qBcHA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@oxlint/binding-darwin-x64@1.47.0':
+    resolution: {integrity: sha512-hP2bOI4IWNS+F6pVXWtRshSTuJ1qCRZgDgVUg6EBUqsRy+ExkEPJkx+YmIuxgdCduYK1LKptLNFuQLJP8voPbQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@oxlint/binding-freebsd-x64@1.47.0':
+    resolution: {integrity: sha512-F55jIEH5xmGu7S661Uho8vGiLFk0bY3A/g4J8CTKiLJnYu/PSMZ2WxFoy5Hji6qvFuujrrM9Q8XXbMO0fKOYPg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@oxlint/binding-linux-arm-gnueabihf@1.47.0':
+    resolution: {integrity: sha512-wxmOn/wns/WKPXUC1fo5mu9pMZPVOu8hsynaVDrgmmXMdHKS7on6bA5cPauFFN9tJXNdsjW26AK9lpfu3IfHBQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@oxlint/binding-linux-arm-musleabihf@1.47.0':
+    resolution: {integrity: sha512-KJTmVIA/GqRlM2K+ZROH30VMdydEU7bDTY35fNg3tOPzQRIs2deLZlY/9JWwdWo1F/9mIYmpbdCmPqtKhWNOPg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@oxlint/binding-linux-arm64-gnu@1.47.0':
+    resolution: {integrity: sha512-PF7ELcFg1GVlS0X0ZB6aWiXobjLrAKer3T8YEkwIoO8RwWiAMkL3n3gbleg895BuZkHVlJ2kPRUwfrhHrVkD1A==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxlint/binding-linux-arm64-musl@1.47.0':
+    resolution: {integrity: sha512-4BezLRO5cu0asf0Jp1gkrnn2OHiXrPPPEfBTxq1k5/yJ2zdGGTmZxHD2KF2voR23wb8Elyu3iQawXo7wvIZq0Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxlint/binding-linux-ppc64-gnu@1.47.0':
+    resolution: {integrity: sha512-aI5ds9jq2CPDOvjeapiIj48T/vlWp+f4prkxs+FVzrmVN9BWIj0eqeJ/hV8WgXg79HVMIz9PU6deI2ki09bR1w==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxlint/binding-linux-riscv64-gnu@1.47.0':
+    resolution: {integrity: sha512-mO7ycp9Elvgt5EdGkQHCwJA6878xvo9tk+vlMfT1qg++UjvOMB8INsOCQIOH2IKErF/8/P21LULkdIrocMw9xA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxlint/binding-linux-riscv64-musl@1.47.0':
+    resolution: {integrity: sha512-24D0wsYT/7hDFn3Ow32m3/+QT/1ZwrUhShx4/wRDAmz11GQHOZ1k+/HBuK/MflebdnalmXWITcPEy4BWTi7TCA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxlint/binding-linux-s390x-gnu@1.47.0':
+    resolution: {integrity: sha512-8tPzPne882mtML/uy3mApvdCyuVOpthJ7xUv3b67gVfz63hOOM/bwO0cysSkPyYYFDFRn6/FnUb7Jhmsesntvg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxlint/binding-linux-x64-gnu@1.47.0':
+    resolution: {integrity: sha512-q58pIyGIzeffEBhEgbRxLFHmHfV9m7g1RnkLiahQuEvyjKNiJcvdHOwKH2BdgZxdzc99Cs6hF5xTa86X40WzPw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxlint/binding-linux-x64-musl@1.47.0':
+    resolution: {integrity: sha512-e7DiLZtETZUCwTa4EEHg9G+7g3pY+afCWXvSeMG7m0TQ29UHHxMARPaEQUE4mfKgSqIWnJaUk2iZzRPMRdga5g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxlint/binding-openharmony-arm64@1.47.0':
+    resolution: {integrity: sha512-3AFPfQ0WKMleT/bKd7zsks3xoawtZA6E/wKf0DjwysH7wUiMMJkNKXOzYq1R/00G98JFgSU1AkrlOQrSdNNhlg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@oxlint/binding-win32-arm64-msvc@1.47.0':
+    resolution: {integrity: sha512-cLMVVM6TBxp+N7FldQJ2GQnkcLYEPGgiuEaXdvhgvSgODBk9ov3jed+khIXSAWtnFOW0wOnG3RjwqPh0rCuheA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@oxlint/binding-win32-ia32-msvc@1.47.0':
+    resolution: {integrity: sha512-VpFOSzvTnld77/Edje3ZdHgZWnlTb5nVWXyTgjD3/DKF/6t5bRRbwn3z77zOdnGy44xAMvbyAwDNOSeOdVUmRA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@oxlint/binding-win32-x64-msvc@1.47.0':
+    resolution: {integrity: sha512-+q8IWptxXx2HMTM6JluR67284t0h8X/oHJgqpxH1siowxPMqZeIpAcWCUq+tY+Rv2iQK8TUugjZnSBQAVV5CmA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [win32]
+
   '@pkgjs/parseargs@0.11.0':
     resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
     engines: {node: '>=14'}
@@ -3131,6 +3289,16 @@ packages:
     resolution: {integrity: sha512-pLzCU8IgyKXPSO11eeharQkQ4GzOKNWhXq79pQarIRZEMt1/ssyr+MIuWBv1mNoenJLg04gvPx+fi4gcKZ4bag==}
     engines: {node: '>= 18.0.0'}
 
+  oxlint@1.47.0:
+    resolution: {integrity: sha512-v7xkK1iv1qdvTxJGclM97QzN8hHs5816AneFAQ0NGji1BMUquhiDAhXpMwp8+ls16uRVJtzVHxP9pAAXblDeGA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      oxlint-tsgolint: '>=0.11.2'
+    peerDependenciesMeta:
+      oxlint-tsgolint:
+        optional: true
+
   p-all@5.0.1:
     resolution: {integrity: sha512-LMT7WX9ZSaq3J1zjloApkIVmtz0ZdMFSIqbuiEa3txGYPLjUPOvgOPOx3nFjo+f37ZYL+1aY666I2SG7GVwLOA==}
     engines: {node: '>=16'}
@@ -5421,6 +5589,63 @@ snapshots:
 
   '@oxc-project/types@0.113.0': {}
 
+  '@oxlint/binding-android-arm-eabi@1.47.0':
+    optional: true
+
+  '@oxlint/binding-android-arm64@1.47.0':
+    optional: true
+
+  '@oxlint/binding-darwin-arm64@1.47.0':
+    optional: true
+
+  '@oxlint/binding-darwin-x64@1.47.0':
+    optional: true
+
+  '@oxlint/binding-freebsd-x64@1.47.0':
+    optional: true
+
+  '@oxlint/binding-linux-arm-gnueabihf@1.47.0':
+    optional: true
+
+  '@oxlint/binding-linux-arm-musleabihf@1.47.0':
+    optional: true
+
+  '@oxlint/binding-linux-arm64-gnu@1.47.0':
+    optional: true
+
+  '@oxlint/binding-linux-arm64-musl@1.47.0':
+    optional: true
+
+  '@oxlint/binding-linux-ppc64-gnu@1.47.0':
+    optional: true
+
+  '@oxlint/binding-linux-riscv64-gnu@1.47.0':
+    optional: true
+
+  '@oxlint/binding-linux-riscv64-musl@1.47.0':
+    optional: true
+
+  '@oxlint/binding-linux-s390x-gnu@1.47.0':
+    optional: true
+
+  '@oxlint/binding-linux-x64-gnu@1.47.0':
+    optional: true
+
+  '@oxlint/binding-linux-x64-musl@1.47.0':
+    optional: true
+
+  '@oxlint/binding-openharmony-arm64@1.47.0':
+    optional: true
+
+  '@oxlint/binding-win32-arm64-msvc@1.47.0':
+    optional: true
+
+  '@oxlint/binding-win32-ia32-msvc@1.47.0':
+    optional: true
+
+  '@oxlint/binding-win32-x64-msvc@1.47.0':
+    optional: true
+
   '@pkgjs/parseargs@0.11.0':
     optional: true
 
@@ -8105,6 +8330,28 @@ snapshots:
   openpgp@6.3.0:
     optional: true
 
+  oxlint@1.47.0:
+    optionalDependencies:
+      '@oxlint/binding-android-arm-eabi': 1.47.0
+      '@oxlint/binding-android-arm64': 1.47.0
+      '@oxlint/binding-darwin-arm64': 1.47.0
+      '@oxlint/binding-darwin-x64': 1.47.0
+      '@oxlint/binding-freebsd-x64': 1.47.0
+      '@oxlint/binding-linux-arm-gnueabihf': 1.47.0
+      '@oxlint/binding-linux-arm-musleabihf': 1.47.0
+      '@oxlint/binding-linux-arm64-gnu': 1.47.0
+      '@oxlint/binding-linux-arm64-musl': 1.47.0
+      '@oxlint/binding-linux-ppc64-gnu': 1.47.0
+      '@oxlint/binding-linux-riscv64-gnu': 1.47.0
+      '@oxlint/binding-linux-riscv64-musl': 1.47.0
+      '@oxlint/binding-linux-s390x-gnu': 1.47.0
+      '@oxlint/binding-linux-x64-gnu': 1.47.0
+      '@oxlint/binding-linux-x64-musl': 1.47.0
+      '@oxlint/binding-openharmony-arm64': 1.47.0
+      '@oxlint/binding-win32-arm64-msvc': 1.47.0
+      '@oxlint/binding-win32-ia32-msvc': 1.47.0
+      '@oxlint/binding-win32-x64-msvc': 1.47.0
+
   p-all@5.0.1:
     dependencies:
       p-map: 6.0.0
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 1c3398a..f4491fd 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -9,6 +9,7 @@ catalog:
   '@vitest/coverage-v8': ^4.0.18
   '@vue/test-utils': ^2.4.6
   jsdom: ^28.0.0
+  oxlint: ^1.2.0
   tsdown: ^0.12.5
   vitest: ^4.0.18
   '@vitest/ui': ^4.0.18
diff --git a/vitest.config.ts b/vitest.config.ts
index 05448c6..e4c02f0 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -3,6 +3,7 @@ import { defineConfig } from 'vitest/config';
 export default defineConfig({
   test: {
     projects: [
+      'configs/oxlint/vitest.config.ts',
       'core/stdlib/vitest.config.ts',
       'core/platform/vitest.config.ts',
       'web/vue/vitest.config.ts',
diff --git a/web/vue/README.md b/web/vue/README.md
index 41bbac6..1878647 100644
--- a/web/vue/README.md
+++ b/web/vue/README.md
@@ -1 +1,28 @@
-# @robonen/vue
\ No newline at end of file
+# @robonen/vue
+
+Collection of composables and utilities for Vue 3.
+
+## Install
+
+```bash
+pnpm install @robonen/vue
+```
+
+## Composables
+
+| Category       | Composables                                                        |
+| -------------- | ------------------------------------------------------------------ |
+| **browser**    | `useEventListener`, `useFocusGuard`, `useSupported`                |
+| **component**  | `unrefElement`, `useRenderCount`, `useRenderInfo`                  |
+| **lifecycle**  | `tryOnBeforeMount`, `tryOnMounted`, `tryOnScopeDispose`, `useMounted` |
+| **math**       | `useClamp`                                                         |
+| **reactivity** | `broadcastedRef`, `useCached`, `useLastChanged`, `useSyncRefs`     |
+| **state**      | `useAppSharedState`, `useAsyncState`, `useContextFactory`, `useCounter`, `useInjectionStore`, `useToggle` |
+| **storage**    | `useLocalStorage`, `useSessionStorage`, `useStorage`, `useStorageAsync` |
+| **utilities**  | `useOffsetPagination`                                              |
+
+## Usage
+
+```ts
+import { useToggle, useEventListener } from '@robonen/vue';
+```
\ No newline at end of file
diff --git a/web/vue/oxlint.config.ts b/web/vue/oxlint.config.ts
new file mode 100644
index 0000000..f9dcedd
--- /dev/null
+++ b/web/vue/oxlint.config.ts
@@ -0,0 +1,4 @@
+import { defineConfig } from 'oxlint';
+import { compose, base, typescript, vue, vitest, imports } from '@robonen/oxlint';
+
+export default defineConfig(compose(base, typescript, vue, vitest, imports));
diff --git a/web/vue/package.json b/web/vue/package.json
index d4bd51a..8c6b258 100644
--- a/web/vue/package.json
+++ b/web/vue/package.json
@@ -32,13 +32,16 @@
     }
   },
   "scripts": {
+    "lint": "oxlint -c oxlint.config.ts",
     "test": "vitest run",
     "dev": "vitest dev",
     "build": "tsdown"
   },
   "devDependencies": {
+    "@robonen/oxlint": "workspace:*",
     "@robonen/tsconfig": "workspace:*",
     "@vue/test-utils": "catalog:",
+    "oxlint": "catalog:",
     "tsdown": "catalog:"
   },
   "dependencies": {
diff --git a/web/vue/src/composables/browser/useEventListener/index.ts b/web/vue/src/composables/browser/useEventListener/index.ts
index cf68751..86c0065 100644
--- a/web/vue/src/composables/browser/useEventListener/index.ts
+++ b/web/vue/src/composables/browser/useEventListener/index.ts
@@ -1,4 +1,5 @@
-import { isArray, isString, noop, type Arrayable, type VoidFunction } from '@robonen/stdlib';
+import { isArray, isString, noop } from '@robonen/stdlib';
+import type { Arrayable, VoidFunction } from '@robonen/stdlib';
 import type { MaybeRefOrGetter } from 'vue';
 import { defaultWindow } from '@/types';
 
@@ -9,9 +10,7 @@ interface InferEventTarget<Events> {
   removeEventListener: (event: Events, listener?: any, options?: any) => any;
 }
 
-export interface GeneralEventListener<E = Event> {
-  (evt: E): void;
-}
+export type GeneralEventListener<E = Event> = (evt: E) => void;
 
 export type WindowEventName = keyof WindowEventMap;
 export type DocumentEventName = keyof DocumentEventMap;
@@ -84,7 +83,7 @@ export function useEventListener<Names extends string, EventType = Event>(
   event: Arrayable<Names>,
   listener: Arrayable<GeneralEventListener<EventType>>,
   options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>
-)
+): VoidFunction;
 
 /**
  * @name useEventListener
@@ -104,13 +103,13 @@ export function useEventListener(...args: any[]) {
   let target: MaybeRefOrGetter<EventTarget> | undefined;
   let events: Arrayable<string>;
   let listeners: Arrayable<Function>;
-  let options: MaybeRefOrGetter<boolean | AddEventListenerOptions> | undefined;
+  let _options: MaybeRefOrGetter<boolean | AddEventListenerOptions> | undefined;
 
   if (isString(args[0]) || isArray(args[0])) {
-    [events, listeners, options] = args;
+    [events, listeners, _options] = args;
     target = defaultWindow;
   } else {
-    [target, events, listeners, options] = args;
+    [target, events, listeners, _options] = args;
   }
 
   if (!target)
@@ -124,13 +123,16 @@ export function useEventListener(...args: any[]) {
 
   const cleanups: Function[] = [];
   
-  const cleanup = () => {
+  const _cleanup = () => {
     cleanups.forEach(fn => fn());
     cleanups.length = 0;
   }
 
-  const register = (el: any, event: string, listener: any, options: any) => {
+  const _register = (el: any, event: string, listener: any, options: any) => {
     el.addEventListener(event, listener, options);
     return () => el.removeEventListener(event, listener, options);
   }
+
+  void _cleanup;
+  void _register;
 }
\ No newline at end of file
diff --git a/web/vue/src/composables/browser/useFocusGuard/index.test.ts b/web/vue/src/composables/browser/useFocusGuard/index.test.ts
index f646716..be5e308 100644
--- a/web/vue/src/composables/browser/useFocusGuard/index.test.ts
+++ b/web/vue/src/composables/browser/useFocusGuard/index.test.ts
@@ -17,7 +17,7 @@ const setupFocusGuard = (namespace?: string) => {
 const getFocusGuards = (namespace: string) =>
   document.querySelectorAll(`[data-${namespace}]`);
 
-describe('useFocusGuard', () => {
+describe(useFocusGuard, () => {
   let component: ReturnType<typeof setupFocusGuard>;
   const namespace = 'test-guard';
 
@@ -33,7 +33,7 @@ describe('useFocusGuard', () => {
     component = setupFocusGuard(namespace);
 
     const guards = getFocusGuards(namespace);
-    expect(guards.length).toBe(2);
+    expect(guards).toHaveLength(2);
 
     guards.forEach((guard) => {
       expect(guard.getAttribute('tabindex')).toBe('0');
@@ -46,7 +46,7 @@ describe('useFocusGuard', () => {
 
     component.unmount();
 
-    expect(getFocusGuards(namespace).length).toBe(0);
+    expect(getFocusGuards(namespace)).toHaveLength(0);
   });
 
   it('correctly manage multiple instances with the same namespace', () => {
@@ -54,16 +54,16 @@ describe('useFocusGuard', () => {
     const wrapper2 = setupFocusGuard(namespace);
 
     // Guards should not be duplicated
-    expect(getFocusGuards(namespace).length).toBe(2);
+    expect(getFocusGuards(namespace)).toHaveLength(2);
 
     wrapper1.unmount();
 
     // Second instance still keeps the guards
-    expect(getFocusGuards(namespace).length).toBe(2);
+    expect(getFocusGuards(namespace)).toHaveLength(2);
 
     wrapper2.unmount();
 
     // No guards left after all instances are unmounted
-    expect(getFocusGuards(namespace).length).toBe(0);
+    expect(getFocusGuards(namespace)).toHaveLength(0);
   });
 });
diff --git a/web/vue/src/composables/browser/useSupported/index.test.ts b/web/vue/src/composables/browser/useSupported/index.test.ts
index 889a414..7a0efd2 100644
--- a/web/vue/src/composables/browser/useSupported/index.test.ts
+++ b/web/vue/src/composables/browser/useSupported/index.test.ts
@@ -11,14 +11,14 @@ const ComponentStub = defineComponent({
     },
   },
   setup(props) {
-      const isSupported = useSupported(() => props.location in window);
+      const isSupported = useSupported(() => props.location in globalThis);
       
       return { isSupported };
   },
   template: `<div>{{ isSupported }}</div>`,
 });
 
-describe('useSupported', () => {
+describe(useSupported, () => {
   it('return whether the feature is supported', async () => {
       const component = mount(ComponentStub);
 
diff --git a/web/vue/src/composables/browser/useSupported/index.ts b/web/vue/src/composables/browser/useSupported/index.ts
index fc669ea..9609cb1 100644
--- a/web/vue/src/composables/browser/useSupported/index.ts
+++ b/web/vue/src/composables/browser/useSupported/index.ts
@@ -22,6 +22,7 @@ export function useSupported(feature: () => unknown) {
 
     return computed(() => {
       // add reactive dependency on isMounted
+      // eslint-disable-next-line no-unused-expressions
       isMounted.value;
 
       return Boolean(feature());
diff --git a/web/vue/src/composables/component/unrefElement/index.test.ts b/web/vue/src/composables/component/unrefElement/index.test.ts
index 5e247e0..0cc41bf 100644
--- a/web/vue/src/composables/component/unrefElement/index.test.ts
+++ b/web/vue/src/composables/component/unrefElement/index.test.ts
@@ -3,7 +3,7 @@ import { computed, defineComponent, nextTick, ref, shallowRef } from 'vue';
 import { mount } from '@vue/test-utils'
 import { unrefElement } from '.';
 
-describe('unrefElement', () => {
+describe(unrefElement, () => {
   it('returns a plain element when passed a raw element', () => {
     const htmlEl = document.createElement('div');
     const svgEl = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
@@ -47,14 +47,14 @@ describe('unrefElement', () => {
     const result = unrefElement(childInstance);
 
     expect(result).toBe(childInstance.$el);
-    expect((result as HTMLElement).classList.contains('child-el')).toBe(true);
+    expect((result as HTMLElement).classList.contains('child-el')).toBeTruthy();
   });
 
   it('handles null and undefined values', () => {
     expect(unrefElement(undefined)).toBe(undefined);
     expect(unrefElement(null)).toBe(null);
-    expect(unrefElement(ref(null))).toBe(null);
-    expect(unrefElement(ref(undefined))).toBe(undefined);
+    expect(unrefElement(ref<null>(null))).toBe(null);
+    expect(unrefElement(ref<undefined>(undefined))).toBe(undefined);
     expect(unrefElement(() => null)).toBe(null);
     expect(unrefElement(() => undefined)).toBe(undefined);
   });
diff --git a/web/vue/src/composables/component/useRenderCount/index.test.ts b/web/vue/src/composables/component/useRenderCount/index.test.ts
index 8fe517f..45088ef 100644
--- a/web/vue/src/composables/component/useRenderCount/index.test.ts
+++ b/web/vue/src/composables/component/useRenderCount/index.test.ts
@@ -14,7 +14,7 @@ const ComponentStub = defineComponent({
     template: `<div>{{ visibleCount }}</div>`,
 });
 
-describe('useRenderCount', () => {
+describe(useRenderCount, () => {
     it('return the number of times the component has been rendered', async () => {
         const component = mount(ComponentStub);
         
diff --git a/web/vue/src/composables/component/useRenderCount/index.ts b/web/vue/src/composables/component/useRenderCount/index.ts
index 19e8a29..3d4bf15 100644
--- a/web/vue/src/composables/component/useRenderCount/index.ts
+++ b/web/vue/src/composables/component/useRenderCount/index.ts
@@ -1,4 +1,5 @@
-import { onMounted, onUpdated, readonly, type ComponentInternalInstance } from 'vue';
+import { onMounted, onUpdated, readonly } from 'vue';
+import type { ComponentInternalInstance } from 'vue';
 import { useCounter } from '@/composables/state/useCounter';
 import { getLifeCycleTarger } from '@/utils';
 
diff --git a/web/vue/src/composables/component/useRenderInfo/index.test.ts b/web/vue/src/composables/component/useRenderInfo/index.test.ts
index 1a13191..87f3486 100644
--- a/web/vue/src/composables/component/useRenderInfo/index.test.ts
+++ b/web/vue/src/composables/component/useRenderInfo/index.test.ts
@@ -26,7 +26,7 @@ const UnnamedComponentStub = defineComponent({
   template: `<div>{{ visibleCount }}</div>`,
 });
 
-describe('useRenderInfo', () => {
+describe(useRenderInfo, () => {
   it('return uid if component name is not available', async () => {
     const wrapper = mount(UnnamedComponentStub);
 
@@ -42,8 +42,8 @@ describe('useRenderInfo', () => {
     expect(wrapper.vm.info.duration.value).toBeGreaterThan(0);
     expect(wrapper.vm.info.lastRendered).toBeGreaterThan(0);
 
-    let lastRendered = wrapper.vm.info.lastRendered;
-    let duration = wrapper.vm.info.duration.value;
+    const lastRendered = wrapper.vm.info.lastRendered;
+    const duration = wrapper.vm.info.duration.value;
 
     // Will not trigger a render
     wrapper.vm.hiddenCount++;
@@ -76,8 +76,8 @@ describe('useRenderInfo', () => {
     expect(info.duration.value).toBe(0);
     expect(info.lastRendered).toBeGreaterThan(0);
 
-    let lastRendered = info.lastRendered;
-    let duration = info.duration.value;
+    const lastRendered = info.lastRendered;
+    const duration = info.duration.value;
 
     // Will not trigger a render
     wrapper.vm.hiddenCount++;
diff --git a/web/vue/src/composables/component/useRenderInfo/index.ts b/web/vue/src/composables/component/useRenderInfo/index.ts
index 482dc04..6253f5f 100644
--- a/web/vue/src/composables/component/useRenderInfo/index.ts
+++ b/web/vue/src/composables/component/useRenderInfo/index.ts
@@ -1,5 +1,6 @@
 import { timestamp } from '@robonen/stdlib';
-import { onBeforeMount, onBeforeUpdate, onMounted, onUpdated, readonly, ref, type ComponentInternalInstance } from 'vue';
+import { onBeforeMount, onBeforeUpdate, onMounted, onUpdated, readonly, ref } from 'vue';
+import type { ComponentInternalInstance } from 'vue';
 import { useRenderCount } from '../useRenderCount';
 import { getLifeCycleTarger } from '@/utils';
 
@@ -24,7 +25,7 @@ export function useRenderInfo(instance?: ComponentInternalInstance) {
     const duration = ref(0);
     let renderStartTime = 0;
 
-    const startMark = () => renderStartTime = performance.now();
+    const startMark = () => { renderStartTime = performance.now(); };
     const endMark = () => {
         duration.value = Math.max(performance.now() - renderStartTime, 0);
         renderStartTime = 0;
diff --git a/web/vue/src/composables/lifecycle/tryOnBeforeMount/index.ts b/web/vue/src/composables/lifecycle/tryOnBeforeMount/index.ts
index 337923b..f6d2ee1 100644
--- a/web/vue/src/composables/lifecycle/tryOnBeforeMount/index.ts
+++ b/web/vue/src/composables/lifecycle/tryOnBeforeMount/index.ts
@@ -1,4 +1,5 @@
-import { onBeforeMount, nextTick, type ComponentInternalInstance } from 'vue';
+import { onBeforeMount, nextTick } from 'vue';
+import type { ComponentInternalInstance } from 'vue';
 import { getLifeCycleTarger } from '@/utils';
 import type { VoidFunction } from '@robonen/stdlib';
 
diff --git a/web/vue/src/composables/lifecycle/tryOnMounted/index.test.ts b/web/vue/src/composables/lifecycle/tryOnMounted/index.test.ts
index dbbfedb..4000a8b 100644
--- a/web/vue/src/composables/lifecycle/tryOnMounted/index.test.ts
+++ b/web/vue/src/composables/lifecycle/tryOnMounted/index.test.ts
@@ -1,5 +1,6 @@
 import { describe, it, vi, expect } from 'vitest';
-import { defineComponent, nextTick, type PropType } from 'vue';
+import { defineComponent, nextTick } from 'vue';
+import type { PropType } from 'vue';
 import { tryOnMounted } from '.';
 import { mount } from '@vue/test-utils';
 import type { VoidFunction } from '@robonen/stdlib';
@@ -11,12 +12,12 @@ const ComponentStub = defineComponent({
     },
   },
   setup(props) {
-    props.callback && tryOnMounted(props.callback);
+    if (props.callback) { tryOnMounted(props.callback); }
   },
   template: `<div></div>`,
 });
 
-describe('tryOnMounted', () => {
+describe(tryOnMounted, () => {
   it('run the callback when mounted', () => {
     const callback = vi.fn();
     
diff --git a/web/vue/src/composables/lifecycle/tryOnMounted/index.ts b/web/vue/src/composables/lifecycle/tryOnMounted/index.ts
index 8bc43ef..583fca4 100644
--- a/web/vue/src/composables/lifecycle/tryOnMounted/index.ts
+++ b/web/vue/src/composables/lifecycle/tryOnMounted/index.ts
@@ -1,4 +1,5 @@
-import { onMounted, nextTick, type ComponentInternalInstance } from 'vue';
+import { onMounted, nextTick } from 'vue';
+import type { ComponentInternalInstance } from 'vue';
 import { getLifeCycleTarger } from '@/utils';
 import type { VoidFunction } from '@robonen/stdlib';
 
diff --git a/web/vue/src/composables/lifecycle/tryOnScopeDispose/index.test.ts b/web/vue/src/composables/lifecycle/tryOnScopeDispose/index.test.ts
index d386876..81c3884 100644
--- a/web/vue/src/composables/lifecycle/tryOnScopeDispose/index.test.ts
+++ b/web/vue/src/composables/lifecycle/tryOnScopeDispose/index.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
-import { defineComponent, effectScope, type PropType } from 'vue';
+import { defineComponent, effectScope } from 'vue';
+import type { PropType } from 'vue';
 import { tryOnScopeDispose } from '.';
 import { mount } from '@vue/test-utils';
 import type { VoidFunction } from '@robonen/stdlib';
@@ -17,12 +18,12 @@ const ComponentStub = defineComponent({
   template: '<div></div>',
 });
 
-describe('tryOnScopeDispose', () => {
+describe(tryOnScopeDispose, () => {
   it('returns false when the scope is not active', () => {
     const callback = vi.fn();
     const detectedScope = tryOnScopeDispose(callback);
 
-    expect(detectedScope).toBe(false);
+    expect(detectedScope).toBeFalsy();
     expect(callback).not.toHaveBeenCalled();
   });
   
@@ -35,7 +36,7 @@ describe('tryOnScopeDispose', () => {
       detectedScope = tryOnScopeDispose(callback);
     });
 
-    expect(detectedScope).toBe(true);
+    expect(detectedScope).toBeTruthy();
     expect(callback).not.toHaveBeenCalled();
 
     scope.stop();
diff --git a/web/vue/src/composables/lifecycle/useMounted/index.test.ts b/web/vue/src/composables/lifecycle/useMounted/index.test.ts
index da2adb0..e23263f 100644
--- a/web/vue/src/composables/lifecycle/useMounted/index.test.ts
+++ b/web/vue/src/composables/lifecycle/useMounted/index.test.ts
@@ -12,7 +12,7 @@ const ComponentStub = defineComponent({
     template: `<div>{{ isMounted }}</div>`,
 });
 
-describe('useMounted', () => {
+describe(useMounted, () => {
     it('return the mounted state of the component', async () => {
         const component = mount(ComponentStub);
         
diff --git a/web/vue/src/composables/lifecycle/useMounted/index.ts b/web/vue/src/composables/lifecycle/useMounted/index.ts
index a1e34e2..397b1f0 100644
--- a/web/vue/src/composables/lifecycle/useMounted/index.ts
+++ b/web/vue/src/composables/lifecycle/useMounted/index.ts
@@ -1,4 +1,5 @@
-import { onMounted, readonly, ref, type ComponentInternalInstance } from 'vue';
+import { onMounted, readonly, ref } from 'vue';
+import type { ComponentInternalInstance } from 'vue';
 import { getLifeCycleTarger } from '@/utils';
 
 /**
@@ -21,7 +22,7 @@ export function useMounted(instance?: ComponentInternalInstance) {
   const isMounted = ref(false);
   const targetInstance = getLifeCycleTarger(instance);
 
-  onMounted(() => isMounted.value = true, targetInstance);
+  onMounted(() => { isMounted.value = true; }, targetInstance);
 
   return readonly(isMounted);
 }
diff --git a/web/vue/src/composables/math/useClamp/index.test.ts b/web/vue/src/composables/math/useClamp/index.test.ts
index e7daca8..ec3bf6f 100644
--- a/web/vue/src/composables/math/useClamp/index.test.ts
+++ b/web/vue/src/composables/math/useClamp/index.test.ts
@@ -2,7 +2,7 @@ import { ref, readonly, computed } from 'vue';
 import { describe, it, expect } from 'vitest';
 import { useClamp } from '.';
 
-describe('useClamp', () => {
+describe(useClamp, () => {
   it('non-reactive values should be clamped', () => {
     const clampedValue = useClamp(10, 0, 5);
 
diff --git a/web/vue/src/composables/math/useClamp/index.ts b/web/vue/src/composables/math/useClamp/index.ts
index 3be6025..91577e1 100644
--- a/web/vue/src/composables/math/useClamp/index.ts
+++ b/web/vue/src/composables/math/useClamp/index.ts
@@ -1,5 +1,6 @@
 import { clamp, isFunction } from '@robonen/stdlib';
-import { computed, isReadonly, ref, toValue, type ComputedRef, type MaybeRef, type MaybeRefOrGetter, type WritableComputedRef } from 'vue';
+import { computed, isReadonly, ref, toValue } from 'vue';
+import type { ComputedRef, MaybeRef, MaybeRefOrGetter, WritableComputedRef } from 'vue';
 
 /**
  * @name useClamp
diff --git a/web/vue/src/composables/reactivity/useCached/index.test.ts b/web/vue/src/composables/reactivity/useCached/index.test.ts
index fccc1dc..570b633 100644
--- a/web/vue/src/composables/reactivity/useCached/index.test.ts
+++ b/web/vue/src/composables/reactivity/useCached/index.test.ts
@@ -4,7 +4,7 @@ import { useCached } from '.';
 
 const arrayEquals = (a: number[], b: number[]) => a.length === b.length && a.every((v, i) => v === b[i]);
 
-describe('useCached', () => {
+describe(useCached, () => {
   it('default comparator', async () => {
     const externalValue = ref(0);
     const cachedValue = useCached(externalValue);
diff --git a/web/vue/src/composables/reactivity/useCached/index.ts b/web/vue/src/composables/reactivity/useCached/index.ts
index 9deb294..a12aa2e 100644
--- a/web/vue/src/composables/reactivity/useCached/index.ts
+++ b/web/vue/src/composables/reactivity/useCached/index.ts
@@ -1,4 +1,5 @@
-import { ref, watch, toValue, type MaybeRefOrGetter, type Ref, type WatchOptions } from 'vue';
+import { ref, watch, toValue } from 'vue';
+import type { MaybeRefOrGetter, Ref, WatchOptions } from 'vue';
 
 export type Comparator<Value> = (a: Value, b: Value) => boolean;
 
diff --git a/web/vue/src/composables/reactivity/useLastChanged/index.test.ts b/web/vue/src/composables/reactivity/useLastChanged/index.test.ts
index 7e1863b..5c980d0 100644
--- a/web/vue/src/composables/reactivity/useLastChanged/index.test.ts
+++ b/web/vue/src/composables/reactivity/useLastChanged/index.test.ts
@@ -3,7 +3,7 @@ import { describe, it, expect } from 'vitest';
 import { useLastChanged } from '.';
 import { timestamp } from '@robonen/stdlib';
 
-describe('useLastChanged', () => {
+describe(useLastChanged, () => {
   it('initialize with null if no initialValue is provided', () => {
     const source = ref(0);
     const lastChanged = useLastChanged(source);
diff --git a/web/vue/src/composables/reactivity/useLastChanged/index.ts b/web/vue/src/composables/reactivity/useLastChanged/index.ts
index 4f5752e..06c69f8 100644
--- a/web/vue/src/composables/reactivity/useLastChanged/index.ts
+++ b/web/vue/src/composables/reactivity/useLastChanged/index.ts
@@ -1,5 +1,6 @@
 import { timestamp } from '@robonen/stdlib';
-import { ref, watch, type WatchSource, type WatchOptions, type Ref } from 'vue';
+import { ref, watch } from 'vue';
+import type { WatchSource, WatchOptions, Ref } from 'vue';
 
 export interface UseLastChangedOptions<
   Immediate extends boolean,
@@ -32,7 +33,7 @@ export function useLastChanged(source: WatchSource, options: UseLastChangedOptio
 export function useLastChanged(source: WatchSource, options: UseLastChangedOptions<boolean, any> = {}): Ref<number | null> | Ref<number> {
   const lastChanged = ref<number | null>(options.initialValue ?? null);
 
-  watch(source, () => lastChanged.value = timestamp(), options);
+  watch(source, () => { lastChanged.value = timestamp(); }, options);
 
   return lastChanged;
 }
diff --git a/web/vue/src/composables/reactivity/useSyncRefs/index.test.ts b/web/vue/src/composables/reactivity/useSyncRefs/index.test.ts
index e04e42c..7e573f4 100644
--- a/web/vue/src/composables/reactivity/useSyncRefs/index.test.ts
+++ b/web/vue/src/composables/reactivity/useSyncRefs/index.test.ts
@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest';
 import { ref } from 'vue';
 import { useSyncRefs } from '.';
 
-describe('useSyncRefs', () => {
+describe(useSyncRefs, () => {
   it('sync the value of a source ref with multiple target refs', () => {
     const source = ref(0);
     const target1 = ref(0);
diff --git a/web/vue/src/composables/reactivity/useSyncRefs/index.ts b/web/vue/src/composables/reactivity/useSyncRefs/index.ts
index 612bd7b..be5e9cf 100644
--- a/web/vue/src/composables/reactivity/useSyncRefs/index.ts
+++ b/web/vue/src/composables/reactivity/useSyncRefs/index.ts
@@ -1,4 +1,5 @@
-import { watch, type Ref, type WatchOptions, type WatchSource } from 'vue';
+import { watch } from 'vue';
+import type { Ref, WatchOptions, WatchSource } from 'vue';
 import { isArray } from '@robonen/stdlib';
 
 /**
@@ -40,7 +41,7 @@ export function useSyncRefs<T = unknown>(
 
     return watch(
         source,
-        (value) => targets.forEach((target) => target.value = value),
+        (value) => targets.forEach((target) => { target.value = value; }),
         { flush, deep, immediate },
     );
 }
diff --git a/web/vue/src/composables/state/useAppSharedState/index.test.ts b/web/vue/src/composables/state/useAppSharedState/index.test.ts
index 6d290ae..4d3f197 100644
--- a/web/vue/src/composables/state/useAppSharedState/index.test.ts
+++ b/web/vue/src/composables/state/useAppSharedState/index.test.ts
@@ -2,7 +2,7 @@ import { describe, it, vi, expect } from 'vitest';
 import { ref, reactive } from 'vue';
 import { useAppSharedState } from '.';
 
-describe('useAppSharedState', () => {
+describe(useAppSharedState, () => {
   it('initialize state only once', () => {
     const stateFactory = (initValue?: number) => {
       const count = ref(initValue ?? 0);
diff --git a/web/vue/src/composables/state/useAsyncState/index.test.ts b/web/vue/src/composables/state/useAsyncState/index.test.ts
index b5f41e7..5fcd9f2 100644
--- a/web/vue/src/composables/state/useAsyncState/index.test.ts
+++ b/web/vue/src/composables/state/useAsyncState/index.test.ts
@@ -2,7 +2,7 @@ import { isShallow, nextTick, ref } from 'vue';
 import { it, expect, describe, vi, beforeEach, afterEach } from 'vitest';
 import { useAsyncState } from '.';
 
-describe('useAsyncState', () => {
+describe(useAsyncState, () => {
   beforeEach(() => {
     vi.useFakeTimers();
   });
@@ -18,15 +18,15 @@ describe('useAsyncState', () => {
     );
 
     expect(state.value).toBe('initial');
-    expect(isReady.value).toBe(false);
-    expect(isLoading.value).toBe(true);
+    expect(isReady.value).toBeFalsy();
+    expect(isLoading.value).toBeTruthy();
     expect(error.value).toBe(null);
 
     await nextTick();
 
     expect(state.value).toBe('data');
-    expect(isReady.value).toBe(true);
-    expect(isLoading.value).toBe(false);
+    expect(isReady.value).toBeTruthy();
+    expect(isLoading.value).toBeFalsy();
     expect(error.value).toBe(null);
   });
 
@@ -37,15 +37,15 @@ describe('useAsyncState', () => {
     );
 
     expect(state.value).toBe('initial');
-    expect(isReady.value).toBe(false);
-    expect(isLoading.value).toBe(true);
+    expect(isReady.value).toBeFalsy();
+    expect(isLoading.value).toBeTruthy();
     expect(error.value).toBe(null);
 
     await nextTick();
 
     expect(state.value).toBe('data');
-    expect(isReady.value).toBe(true);
-    expect(isLoading.value).toBe(false);
+    expect(isReady.value).toBeTruthy();
+    expect(isLoading.value).toBeFalsy();
     expect(error.value).toBe(null);
   });
 
@@ -56,15 +56,15 @@ describe('useAsyncState', () => {
     );
 
     expect(state.value).toBe('initial');
-    expect(isReady.value).toBe(false);
-    expect(isLoading.value).toBe(true);
+    expect(isReady.value).toBeFalsy();
+    expect(isLoading.value).toBeTruthy();
     expect(error.value).toBe(null);
 
     await nextTick();
 
     expect(state.value).toBe('initial');
-    expect(isReady.value).toBe(false);
-    expect(isLoading.value).toBe(false);
+    expect(isReady.value).toBeFalsy();
+    expect(isLoading.value).toBeFalsy();
     expect(error.value).toEqual(new Error('test-error'));
   });
 
@@ -131,14 +131,14 @@ describe('useAsyncState', () => {
     );
 
     const promise = execute();
-    expect(isLoading.value).toBe(true);
+    expect(isLoading.value).toBeTruthy();
 
     await vi.advanceTimersByTimeAsync(50);
-    expect(isLoading.value).toBe(true);
+    expect(isLoading.value).toBeTruthy();
 
     await vi.advanceTimersByTimeAsync(50);
     await promise;
-    expect(isLoading.value).toBe(false);
+    expect(isLoading.value).toBeFalsy();
   });
 
   it('is awaitable', async () => {
@@ -160,15 +160,15 @@ describe('useAsyncState', () => {
     executeImmediately();
 
     expect(state.value).toBe('initial');
-    expect(isLoading.value).toBe(true);
-    expect(isReady.value).toBe(false);
+    expect(isLoading.value).toBeTruthy();
+    expect(isReady.value).toBeFalsy();
     expect(error.value).toBe(null);
 
     await nextTick();
 
     expect(state.value).toBe('data');
-    expect(isReady.value).toBe(true);
-    expect(isLoading.value).toBe(false);
+    expect(isReady.value).toBeTruthy();
+    expect(isLoading.value).toBeFalsy();
     expect(error.value).toBe(null);
   });
 
@@ -193,7 +193,7 @@ describe('useAsyncState', () => {
     );
   
     expect(state.value.a).toBe(1);
-    expect(isShallow(state)).toBe(true);
+    expect(isShallow(state)).toBeTruthy();
   });
 
   it('uses ref when shallow is false', async () => {
@@ -204,6 +204,6 @@ describe('useAsyncState', () => {
     );
 
     expect(state.value.a).toBe(1);
-    expect(isShallow(state)).toBe(false);
+    expect(isShallow(state)).toBeFalsy();
   });
 });
diff --git a/web/vue/src/composables/state/useAsyncState/index.ts b/web/vue/src/composables/state/useAsyncState/index.ts
index 1410b7f..bd380a6 100644
--- a/web/vue/src/composables/state/useAsyncState/index.ts
+++ b/web/vue/src/composables/state/useAsyncState/index.ts
@@ -1,4 +1,5 @@
-import { ref, shallowRef, watch, type Ref, type ShallowRef, type UnwrapRef } from 'vue';
+import { ref, shallowRef, watch } from 'vue';
+import type { Ref, ShallowRef, UnwrapRef } from 'vue';
 import { isFunction, sleep } from '@robonen/stdlib';
 
 export interface UseAsyncStateOptions<Shallow extends boolean, Data = any> {
@@ -103,8 +104,12 @@ export function useAsyncState<Data, Params extends any[] = [], Shallow extends b
       watch(
         isLoading,
         (loading) => {
-          if (loading === false)
-            error.value ? reject(error.value) : resolve(shell);
+          if (loading === false) {
+            if (error.value)
+              reject(error.value);
+            else 
+              resolve(shell);
+          }
         },
         { 
           immediate: true,
@@ -117,6 +122,7 @@ export function useAsyncState<Data, Params extends any[] = [], Shallow extends b
 
   return {
     ...shell,
+    // eslint-disable-next-line unicorn/no-thenable
     then(onFulfilled, onRejected) {
       return waitResolve().then(onFulfilled, onRejected);
     },
diff --git a/web/vue/src/composables/state/useContextFactory/index.test.ts b/web/vue/src/composables/state/useContextFactory/index.test.ts
index 8a62719..a9ab250 100644
--- a/web/vue/src/composables/state/useContextFactory/index.test.ts
+++ b/web/vue/src/composables/state/useContextFactory/index.test.ts
@@ -35,7 +35,7 @@ function testFactory<Data>(
 
 // TODO: maybe replace template with passing mock functions to setup
 
-describe('useContextFactory', () => {
+describe(useContextFactory, () => {
   it('provide and inject context correctly', () => {
     const { Parent } = testFactory('test', useContextFactory('TestContext'));
 
diff --git a/web/vue/src/composables/state/useContextFactory/index.ts b/web/vue/src/composables/state/useContextFactory/index.ts
index 5334a9b..e379561 100644
--- a/web/vue/src/composables/state/useContextFactory/index.ts
+++ b/web/vue/src/composables/state/useContextFactory/index.ts
@@ -1,4 +1,5 @@
-import { inject as vueInject, provide as vueProvide, type InjectionKey, type App } from 'vue';
+import { inject as vueInject, provide as vueProvide } from 'vue';
+import type { InjectionKey, App } from 'vue';
 import { VueToolsError } from '@/utils';
 
 /**
diff --git a/web/vue/src/composables/state/useCounter/index.test.ts b/web/vue/src/composables/state/useCounter/index.test.ts
index 54a0c72..c4c2371 100644
--- a/web/vue/src/composables/state/useCounter/index.test.ts
+++ b/web/vue/src/composables/state/useCounter/index.test.ts
@@ -2,7 +2,7 @@ import { it, expect, describe } from 'vitest';
 import { ref } from 'vue';
 import { useCounter } from '.';
 
-describe('useCounter', () => {
+describe(useCounter, () => {
   it('initialize count with the provided initial value', () => {
     const { count } = useCounter(5);
     expect(count.value).toBe(5);
diff --git a/web/vue/src/composables/state/useCounter/index.ts b/web/vue/src/composables/state/useCounter/index.ts
index 860e81d..00066d9 100644
--- a/web/vue/src/composables/state/useCounter/index.ts
+++ b/web/vue/src/composables/state/useCounter/index.ts
@@ -1,4 +1,5 @@
-import { ref, toValue, type MaybeRefOrGetter, type Ref } from 'vue';
+import { ref, toValue } from 'vue';
+import type { MaybeRefOrGetter, Ref } from 'vue';
 import { clamp } from '@robonen/stdlib';
 
 export interface UseCounterOptions {
@@ -46,14 +47,17 @@ export function useCounter(
         max = Number.MAX_SAFE_INTEGER,
     } = options;
 
-    const increment = (delta = 1) =>
+    const increment = (delta = 1) => {
         count.value = clamp(count.value + delta, min, max);
+    };
 
-    const decrement = (delta = 1) =>
+    const decrement = (delta = 1) => {
         count.value = clamp(count.value - delta, min, max);
+    };
 
-    const set = (value: number) =>
+    const set = (value: number) => {
         count.value = clamp(value, min, max);
+    };
 
     const get = () => count.value;
 
diff --git a/web/vue/src/composables/state/useInjectionStore/index.ts b/web/vue/src/composables/state/useInjectionStore/index.ts
index 851cbce..9882d9b 100644
--- a/web/vue/src/composables/state/useInjectionStore/index.ts
+++ b/web/vue/src/composables/state/useInjectionStore/index.ts
@@ -1,5 +1,5 @@
 import { useContextFactory } from '../useContextFactory';
-import type { App, InjectionKey } from 'vue';
+import type { App } from 'vue';
 
 export interface useInjectionStoreOptions<Return> {
   injectionName?: string;
diff --git a/web/vue/src/composables/state/useToggle/index.test.ts b/web/vue/src/composables/state/useToggle/index.test.ts
index deece4d..bd0df23 100644
--- a/web/vue/src/composables/state/useToggle/index.test.ts
+++ b/web/vue/src/composables/state/useToggle/index.test.ts
@@ -2,56 +2,56 @@ import { it, expect, describe } from 'vitest';
 import { ref } from 'vue';
 import { useToggle } from '.';
 
-describe('useToggle', () => {
+describe(useToggle, () => {
   it('initialize with false by default', () => {
     const { value } = useToggle();
-    expect(value.value).toBe(false);
+    expect(value.value).toBeFalsy();
   });
 
   it('initialize with the provided initial value', () => {
     const { value } = useToggle(true);
-    expect(value.value).toBe(true);
+    expect(value.value).toBeTruthy();
   });
 
   it('initialize with the provided initial value from a ref', () => {
     const { value } = useToggle(ref(true));
-    expect(value.value).toBe(true);
+    expect(value.value).toBeTruthy();
   });
 
   it('toggle from false to true', () => {
     const { value, toggle } = useToggle(false);
     toggle();
-    expect(value.value).toBe(true);
+    expect(value.value).toBeTruthy();
   });
 
   it('toggle from true to false', () => {
     const { value, toggle } = useToggle(true);
     toggle();
-    expect(value.value).toBe(false);
+    expect(value.value).toBeFalsy();
   });
 
   it('toggle multiple times', () => {
     const { value, toggle } = useToggle(false);
     toggle();
-    expect(value.value).toBe(true);
+    expect(value.value).toBeTruthy();
     toggle();
-    expect(value.value).toBe(false);
+    expect(value.value).toBeFalsy();
     toggle();
-    expect(value.value).toBe(true);
+    expect(value.value).toBeTruthy();
   });
 
   it('toggle returns the new value', () => {
     const { toggle } = useToggle(false);
-    expect(toggle()).toBe(true);
-    expect(toggle()).toBe(false);
+    expect(toggle()).toBeTruthy();
+    expect(toggle()).toBeFalsy();
   });
 
   it('set a specific value via toggle', () => {
     const { value, toggle } = useToggle(false);
     toggle(true);
-    expect(value.value).toBe(true);
+    expect(value.value).toBeTruthy();
     toggle(true);
-    expect(value.value).toBe(true);
+    expect(value.value).toBeTruthy();
   });
 
   it('use custom truthy and falsy values', () => {
diff --git a/web/vue/src/composables/state/useToggle/index.ts b/web/vue/src/composables/state/useToggle/index.ts
index c5e7794..89c8982 100644
--- a/web/vue/src/composables/state/useToggle/index.ts
+++ b/web/vue/src/composables/state/useToggle/index.ts
@@ -1,4 +1,5 @@
-import { ref, toValue, type MaybeRefOrGetter, type MaybeRef, type Ref } from 'vue';
+import { ref, toValue } from 'vue';
+import type { MaybeRefOrGetter, MaybeRef, Ref } from 'vue';
 
 export interface UseToggleOptions<Truthy, Falsy> {
     truthyValue?: MaybeRefOrGetter<Truthy>,
diff --git a/web/vue/src/composables/storage/useLocalStorage/index.test.ts b/web/vue/src/composables/storage/useLocalStorage/index.test.ts
index 2a3bb65..60ce4d0 100644
--- a/web/vue/src/composables/storage/useLocalStorage/index.test.ts
+++ b/web/vue/src/composables/storage/useLocalStorage/index.test.ts
@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach } from 'vitest';
 import { nextTick } from 'vue';
 import { useLocalStorage } from '.';
 
-describe('useLocalStorage', () => {
+describe(useLocalStorage, () => {
   beforeEach(() => {
     localStorage.clear();
   });
diff --git a/web/vue/src/composables/storage/useLocalStorage/index.ts b/web/vue/src/composables/storage/useLocalStorage/index.ts
index c610ee6..c7a5f52 100644
--- a/web/vue/src/composables/storage/useLocalStorage/index.ts
+++ b/web/vue/src/composables/storage/useLocalStorage/index.ts
@@ -1,7 +1,8 @@
 import type { MaybeRefOrGetter, Ref } from 'vue';
 import { defaultWindow } from '@/types';
 import { VueToolsError } from '@/utils/error';
-import { useStorage, type UseStorageOptions } from '../useStorage';
+import { useStorage } from '../useStorage';
+import type { UseStorageOptions } from '../useStorage';
 
 /**
  * @name useLocalStorage
diff --git a/web/vue/src/composables/storage/useSessionStorage/index.test.ts b/web/vue/src/composables/storage/useSessionStorage/index.test.ts
index af329cd..345c69b 100644
--- a/web/vue/src/composables/storage/useSessionStorage/index.test.ts
+++ b/web/vue/src/composables/storage/useSessionStorage/index.test.ts
@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach } from 'vitest';
 import { nextTick } from 'vue';
 import { useSessionStorage } from '.';
 
-describe('useSessionStorage', () => {
+describe(useSessionStorage, () => {
   beforeEach(() => {
     sessionStorage.clear();
   });
diff --git a/web/vue/src/composables/storage/useSessionStorage/index.ts b/web/vue/src/composables/storage/useSessionStorage/index.ts
index 85a1f2d..476285a 100644
--- a/web/vue/src/composables/storage/useSessionStorage/index.ts
+++ b/web/vue/src/composables/storage/useSessionStorage/index.ts
@@ -1,7 +1,8 @@
 import type { MaybeRefOrGetter, Ref } from 'vue';
 import { defaultWindow } from '@/types';
 import { VueToolsError } from '@/utils/error';
-import { useStorage, type UseStorageOptions } from '../useStorage';
+import { useStorage } from '../useStorage';
+import type { UseStorageOptions } from '../useStorage';
 
 /**
  * @name useSessionStorage
diff --git a/web/vue/src/composables/storage/useStorage/index.test.ts b/web/vue/src/composables/storage/useStorage/index.test.ts
index 78303be..2d68a93 100644
--- a/web/vue/src/composables/storage/useStorage/index.test.ts
+++ b/web/vue/src/composables/storage/useStorage/index.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect, vi } from 'vitest';
 import { nextTick } from 'vue';
-import { useStorage, StorageSerializers, type StorageLike } from '.';
+import { useStorage, StorageSerializers } from '.';
+import type { StorageLike } from '.';
 
 function createMockStorage(): StorageLike & { store: Map<string, string> } {
   const store = new Map<string, string>();
@@ -13,7 +14,7 @@ function createMockStorage(): StorageLike & { store: Map<string, string> } {
   };
 }
 
-describe('useStorage', () => {
+describe(useStorage, () => {
   // --- Basic types ---
 
   it('stores and reads a string', async () => {
@@ -45,7 +46,7 @@ describe('useStorage', () => {
     const storage = createMockStorage();
     const state = useStorage<boolean>('test-bool', true, storage);
 
-    expect(state.value).toBe(true);
+    expect(state.value).toBeTruthy();
 
     state.value = false;
     await nextTick();
diff --git a/web/vue/src/composables/storage/useStorage/index.ts b/web/vue/src/composables/storage/useStorage/index.ts
index 5d3d82b..0a2e3a0 100644
--- a/web/vue/src/composables/storage/useStorage/index.ts
+++ b/web/vue/src/composables/storage/useStorage/index.ts
@@ -1,4 +1,5 @@
-import { ref, shallowRef, watch, toValue, type Ref, type MaybeRefOrGetter } from 'vue';
+import { ref, shallowRef, watch, toValue } from 'vue';
+import type { Ref, MaybeRefOrGetter } from 'vue';
 import { isBoolean, isNumber, isString, isObject, isMap, isSet, isDate } from '@robonen/stdlib';
 import type { ConfigurableFlush } from '@/types';
 
@@ -145,7 +146,7 @@ export function useStorage<T>(
     flush = 'pre',
     writeDefaults = true,
     mergeDefaults = false,
-    onError = console.error,
+    onError = console.error, // eslint-disable-line no-console
   } = options;
 
   const defaults = toValue(initialValue);
@@ -156,8 +157,8 @@ export function useStorage<T>(
   function read(): T {
     const raw = storage.getItem(key);
 
-    if (raw == null) {
-      if (writeDefaults && defaults != null) {
+    if (raw === undefined || raw === null) {
+      if (writeDefaults && defaults !== undefined && defaults !== null) {
         try {
           storage.setItem(key, serializer.write(defaults));
         } catch (e) {
@@ -188,7 +189,7 @@ export function useStorage<T>(
     try {
       const oldValue = storage.getItem(key);
 
-      if (value == null) {
+      if (value === undefined || value === null) {
         storage.removeItem(key);
       } else {
         const serialized = serializer.write(value);
diff --git a/web/vue/src/composables/storage/useStorageAsync/index.test.ts b/web/vue/src/composables/storage/useStorageAsync/index.test.ts
index 4c00bcc..65401cd 100644
--- a/web/vue/src/composables/storage/useStorageAsync/index.test.ts
+++ b/web/vue/src/composables/storage/useStorageAsync/index.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect, vi } from 'vitest';
 import { nextTick } from 'vue';
-import { useStorageAsync, type StorageLikeAsync } from '.';
+import { useStorageAsync } from '.';
+import type { StorageLikeAsync } from '.';
 
 function createMockAsyncStorage(): StorageLikeAsync & { store: Map<string, string> } {
   const store = new Map<string, string>();
@@ -24,7 +25,7 @@ function createDelayedAsyncStorage(delay: number): StorageLikeAsync & { store: M
   };
 }
 
-describe('useStorageAsync', () => {
+describe(useStorageAsync, () => {
   // --- Basic read/write ---
 
   it('returns default value before storage is ready', () => {
@@ -32,7 +33,7 @@ describe('useStorageAsync', () => {
     const { state, isReady } = useStorageAsync('key', 'default', storage);
 
     expect(state.value).toBe('default');
-    expect(isReady.value).toBe(false);
+    expect(isReady.value).toBeFalsy();
   });
 
   it('reads existing value from async storage', async () => {
@@ -42,7 +43,7 @@ describe('useStorageAsync', () => {
     const { state, isReady } = await useStorageAsync('key', 'default', storage);
 
     expect(state.value).toBe('stored');
-    expect(isReady.value).toBe(true);
+    expect(isReady.value).toBeTruthy();
   });
 
   it('writes value to async storage on change', async () => {
@@ -81,7 +82,7 @@ describe('useStorageAsync', () => {
 
     const { state } = await useStorageAsync('flag', false, storage);
 
-    expect(state.value).toBe(true);
+    expect(state.value).toBeTruthy();
 
     state.value = false;
     await nextTick();
@@ -108,7 +109,7 @@ describe('useStorageAsync', () => {
     const { state, isReady } = await useStorageAsync('delayed', 'default', storage);
 
     expect(state.value).toBe('loaded');
-    expect(isReady.value).toBe(true);
+    expect(isReady.value).toBeTruthy();
   });
 
   // --- onReady callback ---
@@ -201,7 +202,7 @@ describe('useStorageAsync', () => {
     await nextTick();
     await new Promise((resolve) => setTimeout(resolve, 0));
 
-    expect(storage.store.has('nullable')).toBe(false);
+    expect(storage.store.has('nullable')).toBeFalsy();
   });
 
   // --- Error handling ---
@@ -321,7 +322,7 @@ describe('useStorageAsync', () => {
 
     await useStorageAsync('new-key', 'default-val', storage, { writeDefaults: false });
 
-    expect(storage.store.has('new-key')).toBe(false);
+    expect(storage.store.has('new-key')).toBeFalsy();
   });
 
   it('does not overwrite existing value with defaults', async () => {
diff --git a/web/vue/src/composables/storage/useStorageAsync/index.ts b/web/vue/src/composables/storage/useStorageAsync/index.ts
index 870b321..7ca4736 100644
--- a/web/vue/src/composables/storage/useStorageAsync/index.ts
+++ b/web/vue/src/composables/storage/useStorageAsync/index.ts
@@ -1,4 +1,5 @@
-import { ref, shallowRef, watch, toValue, type Ref, type ShallowRef, type MaybeRefOrGetter, type UnwrapRef } from 'vue';
+import { ref, shallowRef, watch, toValue } from 'vue';
+import type { Ref, ShallowRef, MaybeRefOrGetter, UnwrapRef } from 'vue';
 import type { ConfigurableFlush } from '@/types';
 import { tryOnScopeDispose } from '@/composables/lifecycle/tryOnScopeDispose';
 import { guessSerializer, shallowMerge } from '../useStorage';
@@ -100,7 +101,7 @@ export function useStorageAsync<T, Shallow extends boolean = true>(
     writeDefaults = true,
     mergeDefaults = false,
     onReady,
-    onError = console.error,
+    onError = console.error, // eslint-disable-line no-console
   } = options;
 
   const defaults = toValue(initialValue);
@@ -113,8 +114,8 @@ export function useStorageAsync<T, Shallow extends boolean = true>(
     try {
       const raw = await storage.getItem(key);
 
-      if (raw == null) {
-        if (writeDefaults && defaults != null) {
+      if (raw === undefined || raw === null) {
+        if (writeDefaults && defaults !== undefined && defaults !== null) {
           try {
             await storage.setItem(key, await serializer.write(defaults));
           } catch (e) {
@@ -142,7 +143,7 @@ export function useStorageAsync<T, Shallow extends boolean = true>(
 
   async function write(value: T) {
     try {
-      if (value == null) {
+      if (value === undefined || value === null) {
         await storage.removeItem(key);
       } else {
         const raw = await serializer.write(value);
@@ -179,6 +180,7 @@ export function useStorageAsync<T, Shallow extends boolean = true>(
 
   return {
     ...shell,
+    // eslint-disable-next-line unicorn/no-thenable
     then(onFulfilled, onRejected) {
       return readyPromise.then(onFulfilled, onRejected);
     },
diff --git a/web/vue/src/composables/utilities/useOffsetPagination/index.test.ts b/web/vue/src/composables/utilities/useOffsetPagination/index.test.ts
index 2617d8a..191e744 100644
--- a/web/vue/src/composables/utilities/useOffsetPagination/index.test.ts
+++ b/web/vue/src/composables/utilities/useOffsetPagination/index.test.ts
@@ -2,14 +2,14 @@ import { describe, it, expect, vi } from 'vitest';
 import { nextTick, ref } from 'vue';
 import { useOffsetPagination } from '.';
 
-describe('useOffsetPagination', () => {
+describe(useOffsetPagination, () => {
   it('initialize with default values without options', () => {
     const { currentPage, currentPageSize, totalPages, isFirstPage } = useOffsetPagination({});
     
     expect(currentPage.value).toBe(1);
     expect(currentPageSize.value).toBe(10);
     expect(totalPages.value).toBe(Infinity);
-    expect(isFirstPage.value).toBe(true);
+    expect(isFirstPage.value).toBeTruthy();
   });
 
   it('calculate total pages correctly', () => {
@@ -51,14 +51,14 @@ describe('useOffsetPagination', () => {
     const { currentPage, isFirstPage, isLastPage } = useOffsetPagination({ total: 20, pageSize: 10 });
     
     expect(currentPage.value).toBe(1);
-    expect(isFirstPage.value).toBe(true);
-    expect(isLastPage.value).toBe(false);
+    expect(isFirstPage.value).toBeTruthy();
+    expect(isLastPage.value).toBeFalsy();
 
     currentPage.value = 2;
 
     expect(currentPage.value).toBe(2);
-    expect(isFirstPage.value).toBe(false);
-    expect(isLastPage.value).toBe(true);
+    expect(isFirstPage.value).toBeFalsy();
+    expect(isLastPage.value).toBeTruthy();
   });
 
   it('call onPageChange callback', async () => {
diff --git a/web/vue/src/composables/utilities/useOffsetPagination/index.ts b/web/vue/src/composables/utilities/useOffsetPagination/index.ts
index 3fe7cde..21c9988 100644
--- a/web/vue/src/composables/utilities/useOffsetPagination/index.ts
+++ b/web/vue/src/composables/utilities/useOffsetPagination/index.ts
@@ -1,5 +1,6 @@
 import type { VoidFunction } from '@robonen/stdlib';
-import { computed, reactive, toValue, watch, type ComputedRef, type MaybeRef, type MaybeRefOrGetter, type UnwrapNestedRefs, type WritableComputedRef } from 'vue';
+import { computed, reactive, toValue, watch } from 'vue';
+import type { ComputedRef, MaybeRef, MaybeRefOrGetter, UnwrapNestedRefs, WritableComputedRef } from 'vue';
 import { useClamp } from '@/composables/math/useClamp';
 
 // TODO: sync returned refs with passed refs
@@ -89,7 +90,7 @@ export function useOffsetPagination(options: UseOffsetPaginationOptions): UseOff
 
   const next = () => currentPage.value++;
   const previous = () => currentPage.value--;
-  const select = (page: number) => currentPage.value = page;
+  const select = (page: number) => { currentPage.value = page; };
 
   const returnValue = {
     currentPage,
diff --git a/web/vue/src/types/window.ts b/web/vue/src/types/window.ts
index 91675bb..cae0d39 100644
--- a/web/vue/src/types/window.ts
+++ b/web/vue/src/types/window.ts
@@ -1,6 +1,6 @@
 import { isClient } from '@robonen/platform/multi';
 
-export const defaultWindow = /* #__PURE__ */ isClient ? window : undefined
+export const defaultWindow = /* #__PURE__ */ isClient ? globalThis as Window & typeof globalThis : undefined
 
 export interface ConfigurableWindow {
   /**
diff --git a/web/vue/src/utils/components.ts b/web/vue/src/utils/components.ts
index 5765af6..08ac4f2 100644
--- a/web/vue/src/utils/components.ts
+++ b/web/vue/src/utils/components.ts
@@ -1,4 +1,5 @@
-import { getCurrentInstance, type ComponentInternalInstance } from 'vue';
+import { getCurrentInstance } from 'vue';
+import type { ComponentInternalInstance } from 'vue';
 
 /**
  * @name getLifeCycleTarger
diff --git a/web/vue/vitest.config.ts b/web/vue/vitest.config.ts
index 0bef73c..6214510 100644
--- a/web/vue/vitest.config.ts
+++ b/web/vue/vitest.config.ts
@@ -1,5 +1,5 @@
 import { defineConfig } from 'vitest/config';
-import { resolve } from 'path';
+import { resolve } from 'node:path';
 
 export default defineConfig({
   resolve: {