serverless-ircd 0.1.0 → 0.3.0

package/packages/irc-server/tests/dispatch.test.ts

@@ -1,4 +1,5 @@
 import { Effect } from '@serverless-ircd/irc-core';
+import { CapturingLogger, LogLevel } from '@serverless-ircd/irc-core';
 import type { ChannelDelta, ConnId, RawLine } from '@serverless-ircd/irc-core';
 import { describe, expect, it } from 'vitest';
 import { dispatch } from '../src/dispatch';
@@ -510,3 +511,86 @@ describe('dispatch — Broadcast cap / capLines', () => {
     expect(sends.map((s) => s.to)).toEqual(['c1']);
   });
 });
+
+// ===========================================================================
+// dispatch observability
+// ===========================================================================
+describe('dispatch — observability', () => {
+  it('emits a `dispatch` debug record with traceId/connectionId and effect tags', async () => {
+    const calls: RecordedCall[] = [];
+    const runtime = fakeRuntime(calls);
+    const logger = new CapturingLogger();
+
+    await dispatch(
+      [Effect.send('c1', [L('PING :1')]), Effect.send('c1', [L('PONG :1')])],
+      runtime,
+      { logger, traceId: 't-1', connectionId: 'c1' },
+    );
+
+    const records = logger.records.filter((r) => r.msg === 'dispatch');
+    expect(records).toHaveLength(1);
+    const rec = records[0];
+    expect(rec?.level).toBe(LogLevel.Debug);
+    expect(rec?.traceId).toBe('t-1');
+    expect(rec?.connectionId).toBe('c1');
+    expect(rec?.fields?.effects).toEqual(['Send', 'Send']);
+    expect(rec?.fields?.histogram).toEqual({ Send: 2 });
+  });
+
+  it('is silent when no logger is supplied (backwards-compatible default)', async () => {
+    const calls: RecordedCall[] = [];
+    const runtime = fakeRuntime(calls);
+    // Default silent call signature still works.
+    await expect(dispatch([Effect.send('c1', [L('x')])], runtime)).resolves.toBeUndefined();
+  });
+
+  it('emits a dispatch.error warn record and rethrows when a handler rejects', async () => {
+    const runtime: IrcRuntime = {
+      ...fakeRuntime([]),
+      async send() {
+        throw new Error('boom');
+      },
+    };
+    const logger = new CapturingLogger();
+
+    await expect(
+      dispatch([Effect.send('c1', [L('x')])], runtime, {
+        logger,
+        traceId: 't-2',
+        connectionId: 'c1',
+      }),
+    ).rejects.toThrow('boom');
+
+    const errs = logger.records.filter((r) => r.msg === 'dispatch.error');
+    expect(errs).toHaveLength(1);
+    expect(errs[0]?.level).toBe(LogLevel.Warn);
+    expect(errs[0]?.traceId).toBe('t-2');
+    expect(errs[0]?.connectionId).toBe('c1');
+    expect(errs[0]?.fields?.effect).toBe('Send');
+    const err = errs[0]?.fields?.err as { name: string; message: string };
+    expect(err.name).toBe('Error');
+    expect(err.message).toBe('boom');
+  });
+
+  it('stringifies non-Error rejections in the dispatch.error record', async () => {
+    const runtime: IrcRuntime = {
+      ...fakeRuntime([]),
+      async send() {
+        throw 'string-error';
+      },
+    };
+    const logger = new CapturingLogger();
+
+    await expect(
+      dispatch([Effect.send('c1', [L('x')])], runtime, {
+        logger,
+        traceId: 't-3',
+        connectionId: 'c1',
+      }),
+    ).rejects.toBe('string-error');
+
+    const errs = logger.records.filter((r) => r.msg === 'dispatch.error');
+    expect(errs).toHaveLength(1);
+    expect(errs[0]?.fields?.err).toBe('string-error');
+  });
+});

package/packages/irc-server/tests/routing.test.ts

@@ -0,0 +1,204 @@
+import {
+  type ConnectionState,
+  type Effect as EffectType,
+  EmptyMotdProvider,
+  FakeClock,
+  type FloodControlConfig,
+  SequentialIdFactory,
+  type ServerConfig,
+  buildCtx,
+  createConnection,
+} from '@serverless-ircd/irc-core';
+import { describe, expect, it } from 'vitest';
+import { type RoutedReducers, buildRoutedReducers, resolveFloodControl } from '../src/routing';
+
+const baseServerConfig: ServerConfig = {
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  maxChannelsPerUser: 30,
+  maxTargetsPerCommand: 10,
+  maxListEntries: 50,
+  nickLen: 30,
+  channelLen: 50,
+  topicLen: 390,
+  quitMessage: 'Client Quit',
+};
+
+function makeConn(id = 'c1'): ConnectionState {
+  const conn = createConnection({ id, connectedSince: 0 });
+  conn.nick = 'alice';
+  conn.user = 'alice';
+  conn.host = 'example.com';
+  conn.realname = 'Alice';
+  conn.registration = 'registered';
+  return conn;
+}
+
+function ctxFor(conn: ConnectionState, clock = new FakeClock(1_000)) {
+  return buildCtx({
+    serverConfig: baseServerConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+const motd = (): { command: string; params: string[]; tags: Record<string, string> } => ({
+  command: 'MOTD',
+  params: [],
+  tags: {},
+});
+
+const ping = (): { command: string; params: string[]; tags: Record<string, string> } => ({
+  command: 'PING',
+  params: ['tok'],
+  tags: {},
+});
+
+/** Counts Disconnect effects across one reducer invocation. */
+function isDisconnect(out: { effects: EffectType[] }): boolean {
+  return out.effects.some((e) => e.tag === 'Disconnect');
+}
+
+describe('resolveFloodControl', () => {
+  it('returns null when flood control is explicitly disabled', () => {
+    expect(resolveFloodControl({ ...baseServerConfig, floodControl: null })).toBeNull();
+  });
+
+  it('applies the documented default bucket (with control-plane exemption) when the field is omitted', () => {
+    const fc = resolveFloodControl(baseServerConfig);
+    expect(fc).not.toBeNull();
+    expect(fc?.capacity).toBe(10);
+    expect(fc?.refillRatePerSecond).toBe(1);
+    expect(fc?.disconnectThreshold).toBe(0);
+    expect(typeof fc?.commandCost).toBe('function');
+  });
+
+  it('honours caller-supplied thresholds and attaches the default cost when none is supplied', () => {
+    const fc = resolveFloodControl({
+      ...baseServerConfig,
+      floodControl: { capacity: 7, refillRatePerSecond: 2, disconnectThreshold: 1 },
+    });
+    expect(fc?.capacity).toBe(7);
+    expect(fc?.refillRatePerSecond).toBe(2);
+    expect(fc?.disconnectThreshold).toBe(1);
+    expect(typeof fc?.commandCost).toBe('function');
+    // PING is in the exempt set under the default cost.
+    expect(fc?.commandCost?.('PING')).toBe(0);
+    expect(fc?.commandCost?.('PRIVMSG')).toBe(1);
+  });
+
+  it('preserves a caller-supplied commandCost verbatim', () => {
+    const custom: FloodControlConfig['commandCost'] = () => 5;
+    const fc = resolveFloodControl({
+      ...baseServerConfig,
+      floodControl: {
+        capacity: 7,
+        refillRatePerSecond: 2,
+        disconnectThreshold: 1,
+        commandCost: custom,
+      },
+    });
+    expect(fc?.commandCost).toBe(custom);
+  });
+});
+
+describe('buildRoutedReducers', () => {
+  it('exposes every routed command in the map', () => {
+    const reducers = buildRoutedReducers(baseServerConfig);
+    expect(Object.keys(reducers).sort()).toEqual(
+      [
+        'authenticate',
+        'away',
+        'cap',
+        'channelMode',
+        'invite',
+        'join',
+        'kick',
+        'motd',
+        'names',
+        'nick',
+        'noticeChannel',
+        'noticeUser',
+        'oper',
+        'part',
+        'pass',
+        'ping',
+        'pong',
+        'privmsgChannel',
+        'privmsgUser',
+        'quit',
+        'tagmsgChannel',
+        'tagmsgUser',
+        'topic',
+        'user',
+        'userMode',
+      ].sort(),
+    );
+  });
+
+  it('wraps reducers so a non-exempt burst past capacity trips Disconnect (default config)', () => {
+    const reducers = buildRoutedReducers(baseServerConfig);
+    const conn = makeConn();
+    const ctx = ctxFor(conn);
+
+    let disconnects = 0;
+    // MOTD is a charged command (cost 1); capacity 10 / threshold 0 ⇒ 10
+    // pass, the 11th onward disconnect.
+    for (let i = 0; i < 20; i++) {
+      const out = reducers.motd(conn, motd(), ctx);
+      if (isDisconnect(out)) disconnects += 1;
+    }
+    expect(disconnects).toBe(10);
+  });
+
+  it('exempts control-plane traffic (PING) so a pure PING burst never disconnects', () => {
+    const reducers = buildRoutedReducers(baseServerConfig);
+    const conn = makeConn();
+    const ctx = ctxFor(conn);
+
+    let disconnects = 0;
+    for (let i = 0; i < 50; i++) {
+      const out = reducers.ping(conn, ping(), ctx);
+      if (isDisconnect(out)) disconnects += 1;
+    }
+    expect(disconnects).toBe(0);
+  });
+
+  it('returns raw (unwrapped) reducers when flood control is disabled', () => {
+    const reducers = buildRoutedReducers({ ...baseServerConfig, floodControl: null });
+    const conn = makeConn();
+    const ctx = ctxFor(conn);
+
+    let disconnects = 0;
+    for (let i = 0; i < 20; i++) {
+      const out = reducers.motd(conn, motd(), ctx);
+      if (isDisconnect(out)) disconnects += 1;
+    }
+    // Disabled → the bucket is never consulted; every MOTD reaches the reducer.
+    expect(disconnects).toBe(0);
+    // And the connection never even acquired a bucket.
+    expect(conn.floodBucket).toBeUndefined();
+  });
+
+  it('uses the same Clock source the ctx carries (no ambient time)', () => {
+    const reducers = buildRoutedReducers(baseServerConfig);
+    const conn = makeConn();
+    const clock = new FakeClock(42_000);
+    const ctx = ctxFor(conn, clock);
+
+    reducers.motd(conn, motd(), ctx);
+    // The wrapper stamps the bucket's lastRefill with the injected clock.
+    expect(conn.floodBucket?.lastRefill).toBe(42_000);
+  });
+});
+
+describe('buildRoutedReducers — type shape', () => {
+  it('returns a readonly map typed as RoutedReducers', () => {
+    const reducers: RoutedReducers = buildRoutedReducers(baseServerConfig);
+    // Touching each field confirms the public type is usable as documented.
+    expect(reducers.ping).toBeTypeOf('function');
+    expect(reducers.privmsgChannel).toBeTypeOf('function');
+  });
+});

package/packages/irc-test-support/README.md

@@ -0,0 +1,32 @@
+# @serverless-ircd/irc-test-support
+
+Shared IRC scenario suite + harness seam used by every adapter's integration tests.
+
+## Purpose
+
+PLAN §8 calls for the same scenario suite to run against every runtime
+implementation (in-memory, Cloudflare Workers, AWS Lambda + DynamoDB).
+This package owns:
+
+- `IrcHarnessFactory` / `IrcHarness` / `ClientHarness` ports — the seam
+  each adapter implements.
+- `runIrcScenarios(factories)` — registers the 31 Phase 2 scenarios as a
+  `describe` block per factory.
+- `inMemoryHarnessFactory` — the reference factory used to keep the suite
+  honest; also useful as a template when implementing a new adapter.
+- `HARNESS_SERVER_CONFIG` / `HARNESS_MOTD_LINES` — the constants scenario
+  bodies assert against.
+
+## Adding a runtime
+
+1. Implement `IrcHarnessFactory` in your adapter package.
+2. From a vitest test file, call `runIrcScenarios([yourFactory])`.
+
+See `packages/cf-adapter/tests/cf-harness.ts` and
+`packages/aws-adapter/tests/aws-harness.ts` for examples.
+
+## Scripts
+
+- `pnpm --filter @serverless-ircd/irc-test-support test` — runs the smoke
+  test plus the in-memory scenario matrix.
+- `pnpm --filter @serverless-ircd/irc-test-support build` — emits `dist/`.

package/packages/irc-test-support/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@serverless-ircd/irc-test-support",
+  "version": "0.3.0",
+  "private": true,
+  "description": "Shared IRC scenario runner + harness seam used by every adapter's integration suite",
+  "license": "BSD-3-Clause",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "clean": "rimraf dist coverage .tsbuildinfo .turbo"
+  },
+  "files": ["dist", "src", "README.md"],
+  "dependencies": {
+    "@serverless-ircd/irc-core": "workspace:*",
+    "@serverless-ircd/irc-server": "workspace:*"
+  },
+  "devDependencies": {
+    "@serverless-ircd/in-memory-runtime": "workspace:*",
+    "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "^4.1.0",
+    "rimraf": "^6.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^4.1.0"
+  }
+}

package/packages/{cf-adapter/tests/integration → irc-test-support/src}/in-memory-harness.ts

@@ -52,12 +52,13 @@ export const HARNESS_SERVER_CONFIG = {
 } as const;
 
 /**
- * Default MOTD lines exposed to every spawned client. The welcome block
- * always emits the placeholder 375/372/376 numerics; an explicit `MOTD`
- * command after registration reads these lines via the {@link MotdProvider}
- * port. Tests assert against this content (scenario: MOTD).
+ * Default MOTD lines exposed to every spawned client. The registration
+ * welcome block renders these lines as `375`/`372`×N/`376` numerics, and
+ * an explicit `MOTD` command after registration reads them again via the
+ * {@link MotdProvider} port. Tests assert against this content
+ * (scenario: MOTD).
  */
-const HARNESS_MOTD_LINES = [
+export const HARNESS_MOTD_LINES = [
   'Welcome to the ServerlessIRCd integration-test harness.',
   'All scenarios run parametrized over the IrcRuntime factory matrix.',
 ];

package/packages/irc-test-support/src/index.ts

@@ -0,0 +1,24 @@
+/**
+ * @serverless-ircd/irc-test-support
+ *
+ * Shared IRC scenario suite + harness seam. Every adapter package
+ * (`cf-adapter`, `aws-adapter`, …) registers its own
+ * {@link IrcHarnessFactory} and re-runs the same scenarios under its
+ * native runtime, keeping the runtime contract (PLAN §8) honest: the
+ * same tests pass in-memory, against workerd, and against
+ * dynamodb-local.
+ */
+
+export type {
+  ClientHarness,
+  IrcHarness,
+  IrcHarnessFactory,
+  SpawnClientOptions,
+} from './harness.js';
+export {
+  HARNESS_MOTD_LINES,
+  HARNESS_SERVER_CONFIG,
+  InMemoryHarness,
+  inMemoryHarnessFactory,
+} from './in-memory-harness.js';
+export { runIrcScenarios } from './scenarios.js';

package/packages/{cf-adapter/tests/integration/harness.test.ts → irc-test-support/tests/in-memory-harness.test.ts}

@@ -8,7 +8,7 @@
  */
 
 import { describe, expect, it } from 'vitest';
-import { InMemoryHarness, inMemoryHarnessFactory } from './in-memory-harness.js';
+import { InMemoryHarness, inMemoryHarnessFactory } from '../src/index.js';
 
 describe('inMemoryHarnessFactory', () => {
   it('exposes a stable name for the describe.each matrix', () => {

package/packages/{cf-adapter/tests/integration/scenarios.test.ts → irc-test-support/tests/in-memory-scenarios.test.ts}

@@ -13,8 +13,7 @@
  * requires only registering a factory").
  */
 
-import { inMemoryHarnessFactory } from './in-memory-harness.js';
-import { runIrcScenarios } from './scenarios.js';
+import { inMemoryHarnessFactory, runIrcScenarios } from '../src/index.js';
 
 /** The runtime matrix. Adding a runtime = appending one entry here. */
 runIrcScenarios([inMemoryHarnessFactory]);

package/packages/irc-test-support/tests/smoke.test.ts

@@ -0,0 +1,11 @@
+/**
+ * Smoke test for the extracted `@serverless-ircd/irc-test-support` package.
+ *
+ * Confirms the in-memory factory still runs the full scenario suite after
+ * the move out of `cf-adapter/tests/integration`. Adapter packages import
+ * the same surface to register their own factories.
+ */
+
+import { inMemoryHarnessFactory, runIrcScenarios } from '../src/index.js';
+
+runIrcScenarios([inMemoryHarnessFactory]);

package/packages/irc-test-support/tsconfig.build.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "composite": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "tsBuildInfoFile": "./.tsbuildinfo",
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "tests", "**/*.test.ts"],
+  "references": [
+    { "path": "../irc-core/tsconfig.build.json" },
+    { "path": "../irc-server/tsconfig.build.json" }
+  ]
+}

package/packages/irc-test-support/tsconfig.test.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["dist"],
+  "references": [
+    { "path": "../irc-core/tsconfig.build.json" },
+    { "path": "../irc-server/tsconfig.build.json" },
+    { "path": "../in-memory-runtime/tsconfig.build.json" }
+  ]
+}

package/packages/irc-test-support/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      all: false,
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/index.ts'],
+      reporter: ['text', 'html', 'json-summary'],
+      thresholds: {
+        lines: 90,
+        functions: 90,
+        branches: 90,
+        statements: 90,
+      },
+    },
+  },
+});

package/pnpm-workspace.yaml

@@ -1,3 +1,4 @@
+linkedWorkspacePackages: true
 packages:
   - "packages/*"
   - "apps/*"

package/tools/ci-hardening/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@serverless-ircd/ci-hardening",
+  "version": "0.2.0",
+  "private": true,
+  "description": "CI hardening helpers: coverage-gate config validator + mutation-testing driver for irc-core",
+  "license": "BSD-3-Clause",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "start": "node --enable-source-maps ./dist/main.js",
+    "clean": "rimraf dist coverage .tsbuildinfo .turbo"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "^4.1.0",
+    "rimraf": "^6.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^4.1.0"
+  }
+}

package/tools/ci-hardening/src/index.ts

@@ -0,0 +1,6 @@
+export {
+  MUTATION_SCORE_THRESHOLD,
+  readCoverageThresholds,
+  readStrykerConfig,
+  readWorkflowJob,
+} from './validate.js';

package/tools/ci-hardening/src/validate.ts

@@ -0,0 +1,103 @@
+import { readFileSync } from 'node:fs';
+import { load } from 'js-yaml';
+
+/**
+ * Minimum mutation score (in percent) required for the Stryker
+ * spot-checks on `irc-core/protocol` and `irc-core/commands`.
+ *
+ * Exported so the test-suite and any future dashboards can
+ * import the canonical value instead of re-hard-coding it.
+ */
+export const MUTATION_SCORE_THRESHOLD = 80;
+
+export interface CoverageThresholds {
+  lines: number;
+  functions: number;
+  branches: number;
+  statements: number;
+}
+
+interface StrykerThresholds {
+  high?: number;
+  low?: number;
+  break?: number | null;
+}
+
+interface StrykerConfig {
+  mutate?: unknown;
+  thresholds?: StrykerThresholds;
+  coverageAnalysis?: string;
+  testRunner?: string;
+  [key: string]: unknown;
+}
+
+interface WorkflowJob {
+  steps: Array<{ name?: string; run?: string; [key: string]: unknown }>;
+  [key: string]: unknown;
+}
+
+interface ParsedWorkflow {
+  jobs?: Record<string, WorkflowJob>;
+}
+
+/**
+ * Extract the `coverage.thresholds` block from a vitest config file.
+ *
+ * Vitest configs are plain TypeScript modules; rather than pulling in
+ * the full TS toolchain to evaluate them, we parse the source as text
+ * and pull out the `thresholds: { ... }` object. This deliberately
+ * fails loud (returns NaN-bearing values) if the config shape drifts,
+ * so the test-suite notices immediately.
+ *
+ * @param configPath absolute path to a vitest.config.ts file.
+ */
+export function readCoverageThresholds(configPath: string): CoverageThresholds {
+  const src = readFileSync(configPath, 'utf8');
+  const match = src.match(/thresholds:\s*\{([^}]*)\}/);
+  if (match === null || match[1] === undefined) {
+    throw new Error(`No coverage.thresholds block found in ${configPath}`);
+  }
+  const block = match[1];
+  const grab = (key: string): number => {
+    const m = block.match(new RegExp(`${key}:\\s*(\\d+)`));
+    if (m === null || m[1] === undefined) {
+      throw new Error(`No ${key} threshold found in ${configPath}`);
+    }
+    return Number.parseInt(m[1], 10);
+  };
+  return {
+    lines: grab('lines'),
+    functions: grab('functions'),
+    branches: grab('branches'),
+    statements: grab('statements'),
+  };
+}
+
+/**
+ * Load and validate a Stryker JSON config file.
+ *
+ * @param configPath absolute path to a `stryker.*.conf.json` file.
+ */
+export function readStrykerConfig(configPath: string): StrykerConfig {
+  const raw = readFileSync(configPath, 'utf8');
+  const parsed = JSON.parse(raw) as StrykerConfig;
+  if (!Array.isArray(parsed.mutate)) {
+    throw new Error(`Stryker config at ${configPath} is missing mutate[]`);
+  }
+  return parsed;
+}
+
+/**
+ * Parse a GitHub Actions YAML file and return the named job.
+ *
+ * @param yamlText raw YAML source of a workflow file.
+ * @param jobName key under `jobs:`.
+ */
+export function readWorkflowJob(yamlText: string, jobName: string): WorkflowJob {
+  const parsed = load(yamlText) as ParsedWorkflow;
+  const job = parsed.jobs?.[jobName];
+  if (job === undefined) {
+    throw new Error(`Workflow has no job named "${jobName}"`);
+  }
+  return job;
+}

package/tools/ci-hardening/tests/__no_thresholds__.txt

@@ -0,0 +1,11 @@
+// Fixture: vitest config with no thresholds block at all.
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+    },
+  },
+});

package/tools/ci-hardening/tests/__partial_thresholds__.txt

@@ -0,0 +1,16 @@
+// Fixture: vitest config with only some threshold keys present.
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      thresholds: {
+        functions: 100,
+        branches: 100,
+        statements: 100,
+      },
+    },
+  },
+});