Use vitest as a test framework (#18)

package.json

@@ -10,7 +10,6 @@
         "test": "turbo run test --log-order grouped"
     },
     "devDependencies": {
-        "@ava/typescript": "^4.1.0",
         "@changesets/changelog-github": "^0.5.0",
         "@changesets/cli": "^2.27.1",
         "@kinobi-so/internals": "workspace:*",
@@ -20,18 +19,18 @@
         "@typescript-eslint/eslint-plugin": "^6.21.0",
         "@typescript-eslint/parser": "^6.0.0",
         "agadoo": "^3.0.0",
-        "ava": "^6.1.2",
-        "concurrently": "^8.2.2",
         "eslint": "^8.57.0",
         "eslint-config-turbo": "^1.12.4",
         "eslint-plugin-simple-import-sort": "^10.0.0",
         "eslint-plugin-sort-keys-fix": "^1.1.2",
         "eslint-plugin-typescript-sort-keys": "^3.2.0",
+        "happy-dom": "^14.7.1",
         "prettier": "^3.2.5",
         "rimraf": "5.0.5",
         "tsup": "^8.0.1",
         "turbo": "^1.13.0",
         "typescript": "^5.4.3",
+        "vitest": "^1.5.3",
         "zx": "^8.0.2"
     },
     "engines": {

packages/errors/package.json

@@ -42,7 +42,7 @@
         "build:src": "zx ../../node_modules/@kinobi-so/internals/scripts/build-src.mjs package",
         "build:cli": "zx ../../node_modules/@kinobi-so/internals/scripts/build-src.mjs cli",
         "build:types": "zx ../../node_modules/@kinobi-so/internals/scripts/build-types.mjs",
-        "dev": "zx ../../node_modules/@kinobi-so/internals/scripts/test-unit.mjs browser --watch",
+        "dev": "zx ../../node_modules/@kinobi-so/internals/scripts/test-unit.mjs node --watch",
         "lint": "zx ../../node_modules/@kinobi-so/internals/scripts/lint.mjs",
         "lint:fix": "zx ../../node_modules/@kinobi-so/internals/scripts/lint.mjs --fix",
         "prepublishOnly": "pnpm build",

packages/errors/src/types/global.d.ts

@@ -2,4 +2,5 @@ declare const __BROWSER__: boolean;
 declare const __DEV__: boolean;
 declare const __NODEJS__: boolean;
 declare const __REACTNATIVE__: boolean;
+declare const __TEST__: boolean;
 declare const __VERSION__: string;

packages/errors/test/error.test.ts

@@ -1,53 +1,53 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
 import {
     isKinobiError,
     KINOBI_ERROR__UNEXPECTED_NODE_KIND,
     KINOBI_ERROR__UNRECOGNIZED_NODE_KIND,
     KinobiError,
-} from '../src/index.js';
+} from '../src';
 
-test('it exposes the Kinobi error context', t => {
+test('it exposes the Kinobi error context', () => {
     const error = new KinobiError(KINOBI_ERROR__UNRECOGNIZED_NODE_KIND, { kind: 'missingNode' });
-    t.is(error.context.kind, 'missingNode');
+    expect(error.context.kind).toBe('missingNode');
 });
 
-test('it exposes the Kinobi error code', t => {
+test('it exposes the Kinobi error code', () => {
     const error = new KinobiError(KINOBI_ERROR__UNRECOGNIZED_NODE_KIND, { kind: 'missingNode' });
-    t.is(error.context.__code, KINOBI_ERROR__UNRECOGNIZED_NODE_KIND);
+    expect(error.context.__code).toBe(KINOBI_ERROR__UNRECOGNIZED_NODE_KIND);
 });
 
-test('it calls the message formatter with the code and context', t => {
+test('it calls the message formatter with the code and context', () => {
     const error = new KinobiError(KINOBI_ERROR__UNRECOGNIZED_NODE_KIND, { kind: 'missingNode' });
-    t.is(error.message, 'Unrecognized node kind [missingNode].');
+    expect(error.message).toBe('Unrecognized node kind [missingNode].');
 });
 
-test('it exposes no cause when none is provided', t => {
+test('it exposes no cause when none is provided', () => {
     const error = new KinobiError(KINOBI_ERROR__UNRECOGNIZED_NODE_KIND, { kind: 'missingNode' });
-    t.is(error.cause, undefined);
+    expect(error.cause).toBeUndefined();
 });
 
-test('it exposes the cause when provided', t => {
+test('it exposes the cause when provided', () => {
     const cause = {} as unknown;
     const error = new KinobiError(KINOBI_ERROR__UNRECOGNIZED_NODE_KIND, { cause, kind: 'missingNode' });
-    t.is(error.cause, cause);
+    expect(error.cause).toBe(cause);
 });
 
-test('it returns `true` for an instance of `KinobiError`', t => {
+test('it returns `true` for an instance of `KinobiError`', () => {
     const error = new KinobiError(KINOBI_ERROR__UNRECOGNIZED_NODE_KIND, { kind: 'missingNode' });
-    t.true(isKinobiError(error));
+    expect(isKinobiError(error)).toBe(true);
 });
 
-test('it returns `false` for an instance of `Error`', t => {
-    t.false(isKinobiError(new Error('bad thing')));
+test('it returns `false` for an instance of `Error`', () => {
+    expect(isKinobiError(new Error('bad thing'))).toBe(false);
 });
 
-test('it returns `true` when the error code matches', t => {
+test('it returns `true` when the error code matches', () => {
     const error = new KinobiError(KINOBI_ERROR__UNRECOGNIZED_NODE_KIND, { kind: 'missingNode' });
-    t.true(isKinobiError(error, KINOBI_ERROR__UNRECOGNIZED_NODE_KIND));
+    expect(isKinobiError(error, KINOBI_ERROR__UNRECOGNIZED_NODE_KIND)).toBe(true);
 });
 
-test('it returns `false` when the error code does not match', t => {
+test('it returns `false` when the error code does not match', () => {
     const error = new KinobiError(KINOBI_ERROR__UNRECOGNIZED_NODE_KIND, { kind: 'missingNode' });
-    t.false(isKinobiError(error, KINOBI_ERROR__UNEXPECTED_NODE_KIND));
+    expect(isKinobiError(error, KINOBI_ERROR__UNEXPECTED_NODE_KIND)).toBe(false);
 });

packages/errors/test/error.typetest.ts

@@ -1,8 +1,8 @@
 import { PublicKeyTypeNode } from '@kinobi-so/node-types';
 
-import * as KinobiErrorCodeModule from '../src/codes.js';
-import { KinobiErrorContext } from '../src/context.js';
-import { isKinobiError, KinobiError, KinobiErrorCode } from '../src/index.js';
+import { isKinobiError, KinobiError, KinobiErrorCode } from '../src';
+import * as KinobiErrorCodeModule from '../src/codes';
+import { KinobiErrorContext } from '../src/context';
 
 const { KINOBI_ERROR__UNRECOGNIZED_NODE_KIND, KINOBI_ERROR__UNEXPECTED_NODE_KIND } = KinobiErrorCodeModule;
 

packages/errors/test/types/global.d.ts

@@ -2,4 +2,5 @@ declare const __BROWSER__: boolean;
 declare const __DEV__: boolean;
 declare const __NODEJS__: boolean;
 declare const __REACTNATIVE__: boolean;
+declare const __TEST__: boolean;
 declare const __VERSION__: string;

packages/internals/ava.config.browser-cjs.mjs

@@ -1,11 +0,0 @@
-export default {
-    files: ['test/**/*.test.ts'],
-    nodeArguments: ['--conditions', 'browser'],
-    typescript: {
-        compile: false,
-        rewritePaths: { 'test/': 'dist/tests-browser-cjs/test/' },
-    },
-    watchMode: {
-        ignoreChanges: ['src/**', 'test/**'],
-    },
-};

packages/internals/ava.config.browser-esm.mjs

@@ -1,11 +0,0 @@
-export default {
-    files: ['test/**/*.test.ts'],
-    nodeArguments: ['--conditions', 'browser'],
-    typescript: {
-        compile: false,
-        rewritePaths: { 'test/': 'dist/tests-browser-esm/test/' },
-    },
-    watchMode: {
-        ignoreChanges: ['src/**', 'test/**'],
-    },
-};

packages/internals/ava.config.node-cjs.mjs

@@ -1,11 +0,0 @@
-export default {
-    files: ['test/**/*.test.ts'],
-    nodeArguments: ['--conditions', 'node'],
-    typescript: {
-        compile: false,
-        rewritePaths: { 'test/': 'dist/tests-node-cjs/test/' },
-    },
-    watchMode: {
-        ignoreChanges: ['src/**', 'test/**'],
-    },
-};

packages/internals/ava.config.node-esm.mjs

@@ -1,11 +0,0 @@
-export default {
-    files: ['test/**/*.test.ts'],
-    nodeArguments: ['--conditions', 'node'],
-    typescript: {
-        compile: false,
-        rewritePaths: { 'test/': 'dist/tests-node-esm/test/' },
-    },
-    watchMode: {
-        ignoreChanges: ['src/**', 'test/**'],
-    },
-};

packages/internals/ava.config.react-native-esm.mjs

@@ -1,11 +0,0 @@
-export default {
-    files: ['test/**/*.test.ts'],
-    nodeArguments: ['--conditions', 'react-native'],
-    typescript: {
-        compile: false,
-        rewritePaths: { 'test/': 'dist/tests-react-native-esm/test/' },
-    },
-    watchMode: {
-        ignoreChanges: ['src/**', 'test/**'],
-    },
-};

packages/internals/package.json

@@ -3,10 +3,11 @@
     "version": "0.0.0",
     "private": true,
     "files": [
-        "ave.config.*",
+        "scripts",
         "env-shim.ts",
-        "tsconfig.base.json",
-        "tsup.config.*"
+        "tsconfig.*",
+        "tsup.config.*",
+        "vitest.config.*"
     ],
     "devDependencies": {
         "browserslist-to-esbuild": "^2.1.1"

packages/internals/scripts/test-unit.mjs

@@ -5,19 +5,10 @@ $.stdio = 'inherit';
 const platform = argv._[0];
 const watch = argv.watch;
 
-// Prepare build and test arguments.
-const buildArgs = ['--config', `internals/tsup.config.tests.${platform}.ts`];
-// const esmTestArgs = ['--config', `../../node_modules/@kinobi-so/internals/ava.config.${platform}-esm.mjs`];
-const cjsTestArgs = ['--config', `../../node_modules/@kinobi-so/internals/ava.config.${platform}-cjs.mjs`];
+const testArgs = ['--config', `../../node_modules/@kinobi-so/internals/vitest.config.${platform}.mts`];
 
 if (watch) {
-    // Build and run the tests concurrently in watch mode.
-    await $`concurrently "tsup ${buildArgs} --watch" "ava ${cjsTestArgs} --watch" --hide 0 --prefix none --kill-others`;
+    await $`vitest ${testArgs}`;
 } else {
-    // Build and run the tests.
-    await $`tsup ${buildArgs}`;
-    // await $`ava ${esmTestArgs}`;
-    if (platform !== 'react-native') {
-        await $`ava ${cjsTestArgs}`;
-    }
+    await $`vitest run ${testArgs}`;
 }

packages/internals/getBuildConfig.ts → packages/internals/tsup.config.base.ts

@@ -1,4 +1,3 @@
-import { writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { env } from 'node:process';
 
@@ -21,6 +20,7 @@ export function getBuildConfig(options: BuildOptions): TsupConfig {
             __BROWSER__: `${platform === 'browser'}`,
             __NODEJS__: `${platform === 'node'}`,
             __REACTNATIVE__: `${platform === 'react-native'}`,
+            __TEST__: 'false',
             __VERSION__: `"${env.npm_package_version}"`,
         },
         entry: [`./src/index.ts`],
@@ -54,29 +54,3 @@ export function getBuildConfig(options: BuildOptions): TsupConfig {
         treeshake: true,
     };
 }
-
-export function getTestsBuildConfig(options: BuildOptions): TsupConfig[] {
-    const { format, platform } = options;
-    function outExtension() {
-        return { js: '.js' };
-    }
-    return [
-        {
-            ...getBuildConfig(options),
-            outDir: `./dist/tests-${platform}-${format}/src`,
-            outExtension,
-        },
-        {
-            ...getBuildConfig(options),
-            bundle: false,
-            entry: ['./test/**/*.ts'],
-            async onSuccess() {
-                if (format === 'esm') {
-                    await writeFile(`./dist/tests-${platform}-${format}/package.json`, '{ "type": "module" }');
-                }
-            },
-            outDir: `./dist/tests-${platform}-${format}/test`,
-            outExtension,
-        },
-    ];
-}

packages/internals/tsup.config.cli.ts

@@ -1,6 +1,6 @@
 import { defineConfig } from 'tsup';
 
-import { getBuildConfig } from './getBuildConfig';
+import { getBuildConfig } from './tsup.config.base';
 
 export default defineConfig([
     {

packages/internals/tsup.config.library.ts

@@ -1,6 +1,6 @@
 import { defineConfig } from 'tsup';
 
-import { getBuildConfig } from './getBuildConfig';
+import { getBuildConfig } from './tsup.config.base';
 
 export default defineConfig([
     getBuildConfig({ format: 'cjs', platform: 'node' }),

packages/internals/tsup.config.node.ts

@@ -1,6 +1,6 @@
 import { defineConfig } from 'tsup';
 
-import { getBuildConfig } from './getBuildConfig';
+import { getBuildConfig } from './tsup.config.base';
 
 export default defineConfig([
     getBuildConfig({ format: 'cjs', platform: 'node' }),

packages/internals/tsup.config.package.ts

@@ -1,6 +1,6 @@
 import { defineConfig } from 'tsup';
 
-import { getBuildConfig } from './getBuildConfig';
+import { getBuildConfig } from './tsup.config.base';
 
 export default defineConfig([
     getBuildConfig({ format: 'cjs', platform: 'node' }),

packages/internals/tsup.config.tests.browser.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'tsup';
-
-import { getTestsBuildConfig } from './getBuildConfig';
-
-export default defineConfig([
-    ...getTestsBuildConfig({ format: 'cjs', platform: 'browser' }),
-    ...getTestsBuildConfig({ format: 'esm', platform: 'browser' }),
-]);

packages/internals/tsup.config.tests.node.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'tsup';
-
-import { getTestsBuildConfig } from './getBuildConfig';
-
-export default defineConfig([
-    ...getTestsBuildConfig({ format: 'cjs', platform: 'node' }),
-    ...getTestsBuildConfig({ format: 'esm', platform: 'node' }),
-]);

packages/internals/tsup.config.tests.react-native.ts

@@ -1,5 +0,0 @@
-import { defineConfig } from 'tsup';
-
-import { getTestsBuildConfig } from './getBuildConfig';
-
-export default defineConfig(getTestsBuildConfig({ format: 'esm', platform: 'react-native' }));

packages/internals/vitest.config.base.mts

@@ -0,0 +1,22 @@
+import { env } from 'node:process';
+
+import { configDefaults, defineConfig } from 'vitest/config';
+
+export type Platform = 'browser' | 'node' | 'react-native';
+
+export function getVitestConfig(platform: Platform) {
+    return defineConfig({
+        define: {
+            __BROWSER__: `${platform === 'browser'}`,
+            __DEV__: 'true',
+            __NODEJS__: `${platform === 'node'}`,
+            __REACTNATIVE__: `${platform === 'react-native'}`,
+            __TEST__: 'true',
+            __VERSION__: `"${env.npm_package_version}"`,
+        },
+        test: {
+            environment: platform === 'browser' ? 'happy-dom' : 'node',
+            exclude: [...configDefaults.exclude, '**/e2e/**'],
+        },
+    });
+}

packages/internals/vitest.config.browser.mts

@@ -0,0 +1,3 @@
+import { getVitestConfig } from './vitest.config.base.mjs';
+
+export default getVitestConfig('browser');

packages/internals/vitest.config.node.mts

@@ -0,0 +1,3 @@
+import { getVitestConfig } from './vitest.config.base.mjs';
+
+export default getVitestConfig('node');

packages/internals/vitest.config.react-native.mts

@@ -0,0 +1,3 @@
+import { getVitestConfig } from './vitest.config.base.mjs';
+
+export default getVitestConfig('react-native');

packages/library/package.json

@@ -42,7 +42,7 @@
         "build": "rimraf dist && pnpm build:src && pnpm build:types",
         "build:src": "zx ../../node_modules/@kinobi-so/internals/scripts/build-src.mjs library",
         "build:types": "zx ../../node_modules/@kinobi-so/internals/scripts/build-types.mjs",
-        "dev": "zx ../../node_modules/@kinobi-so/internals/scripts/test-unit.mjs browser --watch",
+        "dev": "zx ../../node_modules/@kinobi-so/internals/scripts/test-unit.mjs node --watch",
         "lint": "zx ../../node_modules/@kinobi-so/internals/scripts/lint.mjs",
         "lint:fix": "zx ../../node_modules/@kinobi-so/internals/scripts/lint.mjs --fix",
         "prepublishOnly": "pnpm build",
@@ -54,7 +54,8 @@
         "test:types": "zx ../../node_modules/@kinobi-so/internals/scripts/test-types.mjs"
     },
     "dependencies": {
-        "@kinobi-so/nodes": "workspace:*"
+        "@kinobi-so/nodes": "workspace:*",
+        "@kinobi-so/visitors": "workspace:*"
     },
     "license": "MIT",
     "repository": {

packages/library/src/index.ts

@@ -1 +1,2 @@
 export * from '@kinobi-so/nodes';
+export * from '@kinobi-so/visitors';

packages/library/test/index.test.ts

@@ -1,7 +1,11 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { rootNode } from '../src/index.js';
+import { identityVisitor, rootNode } from '../src';
 
-test('it exports node helpers', t => {
-    t.is(typeof rootNode, 'function');
+test('it exports node helpers', () => {
+    expect(typeof rootNode).toBe('function');
+});
+
+test('it exports visitors', () => {
+    expect(typeof identityVisitor).toBe('function');
 });

packages/node-types/test/GetNodeFromKind.typetest.ts

@@ -1,4 +1,4 @@
-import type { GetNodeFromKind, PublicKeyTypeNode, StringTypeNode } from '../src/index.js';
+import type { GetNodeFromKind, PublicKeyTypeNode, StringTypeNode } from '../src';
 
 // [DESCRIBE] GetNodeFromKind.
 {

packages/nodes-from-anchor/package.json

@@ -38,7 +38,7 @@
         "build": "rimraf dist && pnpm build:src && pnpm build:types",
         "build:src": "zx ../../node_modules/@kinobi-so/internals/scripts/build-src.mjs package",
         "build:types": "zx ../../node_modules/@kinobi-so/internals/scripts/build-types.mjs",
-        "dev": "zx ../../node_modules/@kinobi-so/internals/scripts/test-unit.mjs browser --watch",
+        "dev": "zx ../../node_modules/@kinobi-so/internals/scripts/test-unit.mjs node --watch",
         "lint": "zx ../../node_modules/@kinobi-so/internals/scripts/lint.mjs",
         "lint:fix": "zx ../../node_modules/@kinobi-so/internals/scripts/lint.mjs --fix",
         "prepublishOnly": "pnpm build",

packages/nodes-from-anchor/test/discriminator.test.ts

@@ -1,9 +1,9 @@
 import { bytesValueNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { getAnchorAccountDiscriminator, getAnchorInstructionDiscriminator } from '../src/index.js';
+import { getAnchorAccountDiscriminator, getAnchorInstructionDiscriminator } from '../src';
 
-test('it can compute the discriminator of an Anchor account', t => {
+test('it can compute the discriminator of an Anchor account', () => {
     // Given an account named "StakeEntry" on the IDL.
     const idlName = 'StakeEntry';
 
@@ -11,10 +11,10 @@ test('it can compute the discriminator of an Anchor account', t => {
     const discriminator = getAnchorAccountDiscriminator(idlName);
 
     // Then we get the expected value.
-    t.deepEqual(discriminator, bytesValueNode('base16', 'bb7f09239b445628'));
+    expect(discriminator).toEqual(bytesValueNode('base16', 'bb7f09239b445628'));
 });
 
-test('it can compute the discriminator of an Anchor instruction', t => {
+test('it can compute the discriminator of an Anchor instruction', () => {
     // Given an instruction named "addConfigLines" on the IDL.
     const idlName = 'addConfigLines';
 
@@ -22,5 +22,5 @@ test('it can compute the discriminator of an Anchor instruction', t => {
     const discriminator = getAnchorInstructionDiscriminator(idlName);
 
     // Then we get the expected value.
-    t.deepEqual(discriminator, bytesValueNode('base16', 'df32e0e39708736a'));
+    expect(discriminator).toEqual(bytesValueNode('base16', 'df32e0e39708736a'));
 });

packages/nodes-from-anchor/test/rootNodeFromAnchor.test.ts

@@ -1,9 +1,9 @@
 import { programNode, rootNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { rootNodeFromAnchor } from '../src/index.js';
+import { rootNodeFromAnchor } from '../src';
 
-test('it creates root nodes from IDL version 0.0', t => {
+test('it creates root nodes from IDL version 0.0', () => {
     const node = rootNodeFromAnchor({
         instructions: [],
         metadata: { address: '1111' },
@@ -11,8 +11,7 @@ test('it creates root nodes from IDL version 0.0', t => {
         version: '1.2.3',
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         rootNode(
             programNode({
                 name: 'myProgram',

packages/nodes-from-anchor/test/v00/AccountNode.test.ts

@@ -7,11 +7,11 @@ import {
     structFieldTypeNode,
     structTypeNode,
 } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { accountNodeFromAnchorV00 } from '../../src/index.js';
+import { accountNodeFromAnchorV00 } from '../../src';
 
-test('it creates account nodes', t => {
+test('it creates account nodes', () => {
     const node = accountNodeFromAnchorV00({
         name: 'myAccount',
         type: {
@@ -20,8 +20,7 @@ test('it creates account nodes', t => {
         },
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         accountNode({
             data: structTypeNode([
                 structFieldTypeNode({
@@ -34,7 +33,7 @@ test('it creates account nodes', t => {
     );
 });
 
-test('it creates account nodes with anchor discriminators', t => {
+test('it creates account nodes with anchor discriminators', () => {
     const node = accountNodeFromAnchorV00(
         {
             name: 'myAccount',
@@ -43,8 +42,7 @@ test('it creates account nodes with anchor discriminators', t => {
         'anchor',
     );
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         accountNode({
             data: structTypeNode([
                 structFieldTypeNode({

packages/nodes-from-anchor/test/v00/DefinedTypeNode.test.ts

@@ -1,9 +1,9 @@
 import { definedTypeNode, numberTypeNode, structFieldTypeNode, structTypeNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { definedTypeNodeFromAnchorV00 } from '../../src/index.js';
+import { definedTypeNodeFromAnchorV00 } from '../../src';
 
-test('it creates defined type nodes', t => {
+test('it creates defined type nodes', () => {
     const node = definedTypeNodeFromAnchorV00({
         name: 'myType',
         type: {
@@ -12,8 +12,7 @@ test('it creates defined type nodes', t => {
         },
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         definedTypeNode({
             name: 'myType',
             type: structTypeNode([

packages/nodes-from-anchor/test/v00/ErrorNode.test.ts

@@ -1,17 +1,16 @@
 import { errorNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { errorNodeFromAnchorV00 } from '../../src/index.js';
+import { errorNodeFromAnchorV00 } from '../../src';
 
-test('it creates error nodes', t => {
+test('it creates error nodes', () => {
     const node = errorNodeFromAnchorV00({
         code: 42,
         msg: 'my error message',
         name: 'myError',
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         errorNode({
             code: 42,
             docs: ['myError: my error message'],

packages/nodes-from-anchor/test/v00/InstructionAccountNode.test.ts

@@ -1,9 +1,9 @@
 import { instructionAccountNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { instructionAccountNodeFromAnchorV00, instructionAccountNodesFromAnchorV00 } from '../../src/index.js';
+import { instructionAccountNodeFromAnchorV00, instructionAccountNodesFromAnchorV00 } from '../../src';
 
-test('it creates instruction account nodes', t => {
+test('it creates instruction account nodes', () => {
     const node = instructionAccountNodeFromAnchorV00({
         docs: ['my docs'],
         isMut: true,
@@ -12,8 +12,7 @@ test('it creates instruction account nodes', t => {
         name: 'myInstructionAccount',
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         instructionAccountNode({
             docs: ['my docs'],
             isOptional: true,
@@ -24,7 +23,7 @@ test('it creates instruction account nodes', t => {
     );
 });
 
-test('it flattens nested instruction accounts', t => {
+test('it flattens nested instruction accounts', () => {
     const nodes = instructionAccountNodesFromAnchorV00([
         { isMut: false, isSigner: false, name: 'accountA' },
         {
@@ -37,7 +36,7 @@ test('it flattens nested instruction accounts', t => {
         { isMut: true, isSigner: true, name: 'accountD' },
     ]);
 
-    t.deepEqual(nodes, [
+    expect(nodes).toEqual([
         instructionAccountNode({ isSigner: false, isWritable: false, name: 'accountA' }),
         instructionAccountNode({ isSigner: false, isWritable: true, name: 'accountB' }),
         instructionAccountNode({ isSigner: true, isWritable: false, name: 'accountC' }),

packages/nodes-from-anchor/test/v00/InstructionArgumentNode.test.ts

@@ -1,16 +1,15 @@
 import { instructionArgumentNode, numberTypeNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { instructionArgumentNodeFromAnchorV00 } from '../../src/index.js';
+import { instructionArgumentNodeFromAnchorV00 } from '../../src';
 
-test('it creates instruction argument nodes', t => {
+test('it creates instruction argument nodes', () => {
     const node = instructionArgumentNodeFromAnchorV00({
         name: 'myInstructionArgument',
         type: 'u8',
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         instructionArgumentNode({
             name: 'myInstructionArgument',
             type: numberTypeNode('u8'),

packages/nodes-from-anchor/test/v00/InstructionNode.test.ts

@@ -7,19 +7,18 @@ import {
     instructionNode,
     numberTypeNode,
 } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { instructionNodeFromAnchorV00 } from '../../src/index.js';
+import { instructionNodeFromAnchorV00 } from '../../src';
 
-test('it creates instruction nodes', t => {
+test('it creates instruction nodes', () => {
     const node = instructionNodeFromAnchorV00({
         accounts: [{ isMut: true, isSigner: false, name: 'mint' }],
         args: [{ name: 'amount', type: 'u8' }],
         name: 'mintTokens',
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         instructionNode({
             accounts: [instructionAccountNode({ isSigner: false, isWritable: true, name: 'mint' })],
             arguments: [instructionArgumentNode({ name: 'amount', type: numberTypeNode('u8') })],
@@ -28,7 +27,7 @@ test('it creates instruction nodes', t => {
     );
 });
 
-test('it creates instruction nodes with anchor discriminators', t => {
+test('it creates instruction nodes with anchor discriminators', () => {
     const node = instructionNodeFromAnchorV00(
         {
             accounts: [],
@@ -38,8 +37,7 @@ test('it creates instruction nodes with anchor discriminators', t => {
         'anchor',
     );
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         instructionNode({
             arguments: [
                 instructionArgumentNode({

packages/nodes-from-anchor/test/v00/PdaNode.test.ts

@@ -6,11 +6,11 @@ import {
     pdaNode,
     variablePdaSeedNode,
 } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { pdaNodeFromAnchorV00 } from '../../src/index.js';
+import { pdaNodeFromAnchorV00 } from '../../src';
 
-test('it creates PDA nodes', t => {
+test('it creates PDA nodes', () => {
     const node = pdaNodeFromAnchorV00({
         name: 'myPda',
         seeds: [
@@ -20,8 +20,7 @@ test('it creates PDA nodes', t => {
         ],
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         pdaNode({
             name: 'myPda',
             seeds: [

packages/nodes-from-anchor/test/v00/ProgramNode.test.ts

@@ -9,11 +9,11 @@ import {
     programNode,
     structTypeNode,
 } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { programNodeFromAnchorV00 } from '../../src/index.js';
+import { programNodeFromAnchorV00 } from '../../src';
 
-test('it creates program nodes', t => {
+test('it creates program nodes', () => {
     const node = programNodeFromAnchorV00({
         accounts: [{ name: 'myAccount', seeds: [{ kind: 'programId' }], type: { fields: [], kind: 'struct' } }],
         errors: [{ code: 42, msg: 'my error message', name: 'myError' }],
@@ -24,8 +24,7 @@ test('it creates program nodes', t => {
         version: '1.2.3',
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         programNode({
             accounts: [accountNode({ name: 'myAccount', pda: pdaLinkNode('myAccount') })],
             definedTypes: [definedTypeNode({ name: 'myType', type: structTypeNode([]) })],

packages/nodes-from-anchor/test/v00/RootNode.test.ts

@@ -1,9 +1,9 @@
 import { programNode, rootNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { rootNodeFromAnchorV00 } from '../../src/index.js';
+import { rootNodeFromAnchorV00 } from '../../src';
 
-test('it creates root nodes', t => {
+test('it creates root nodes', () => {
     const node = rootNodeFromAnchorV00({
         instructions: [],
         metadata: { address: '1111' },
@@ -11,8 +11,7 @@ test('it creates root nodes', t => {
         version: '1.2.3',
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         rootNode(
             programNode({
                 name: 'myProgram',

packages/nodes-from-anchor/test/v00/typeNodes/ArrayTypeNode.test.ts

@@ -1,20 +1,17 @@
 import { arrayTypeNode, fixedCountNode, numberTypeNode, prefixedCountNode, remainderCountNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates array type nodes', t => {
-    t.deepEqual(typeNodeFromAnchorV00({ array: ['u8', 2] }), arrayTypeNode(numberTypeNode('u8'), fixedCountNode(2)));
-    t.deepEqual(
-        typeNodeFromAnchorV00({ vec: 'u8' }),
+test('it creates array type nodes', () => {
+    expect(typeNodeFromAnchorV00({ array: ['u8', 2] })).toEqual(arrayTypeNode(numberTypeNode('u8'), fixedCountNode(2)));
+    expect(typeNodeFromAnchorV00({ vec: 'u8' })).toEqual(
         arrayTypeNode(numberTypeNode('u8'), prefixedCountNode(numberTypeNode('u32'))),
     );
-    t.deepEqual(
-        typeNodeFromAnchorV00({ size: 'u16', vec: 'u8' }),
+    expect(typeNodeFromAnchorV00({ size: 'u16', vec: 'u8' })).toEqual(
         arrayTypeNode(numberTypeNode('u8'), prefixedCountNode(numberTypeNode('u16'))),
     );
-    t.deepEqual(
-        typeNodeFromAnchorV00({ size: 'remainder', vec: 'u8' }),
+    expect(typeNodeFromAnchorV00({ size: 'remainder', vec: 'u8' })).toEqual(
         arrayTypeNode(numberTypeNode('u8'), remainderCountNode()),
     );
 });

packages/nodes-from-anchor/test/v00/typeNodes/BooleanTypeNode.test.ts

@@ -1,8 +1,8 @@
 import { booleanTypeNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates boolean type nodes', t => {
-    t.deepEqual(typeNodeFromAnchorV00('bool'), booleanTypeNode());
+test('it creates boolean type nodes', () => {
+    expect(typeNodeFromAnchorV00('bool')).toEqual(booleanTypeNode());
 });

packages/nodes-from-anchor/test/v00/typeNodes/BytesTypeNode.test.ts

@@ -1,8 +1,8 @@
 import { bytesTypeNode, numberTypeNode, sizePrefixTypeNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates bytes type nodes', t => {
-    t.deepEqual(typeNodeFromAnchorV00('bytes'), sizePrefixTypeNode(bytesTypeNode(), numberTypeNode('u32')));
+test('it creates bytes type nodes', () => {
+    expect(typeNodeFromAnchorV00('bytes')).toEqual(sizePrefixTypeNode(bytesTypeNode(), numberTypeNode('u32')));
 });

packages/nodes-from-anchor/test/v00/typeNodes/EnumTypeNode.test.ts

@@ -9,11 +9,11 @@ import {
     structTypeNode,
     tupleTypeNode,
 } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates enum type nodes', t => {
+test('it creates enum type nodes', () => {
     const node = typeNodeFromAnchorV00({
         kind: 'enum',
         variants: [
@@ -23,8 +23,7 @@ test('it creates enum type nodes', t => {
         ],
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         enumTypeNode([
             enumEmptyVariantTypeNode('variantA'),
             enumTupleVariantTypeNode('variantB', tupleTypeNode([numberTypeNode('u16'), booleanTypeNode()])),
@@ -36,7 +35,7 @@ test('it creates enum type nodes', t => {
     );
 });
 
-test('it creates enum type nodes with custom sizes', t => {
+test('it creates enum type nodes with custom sizes', () => {
     const node = typeNodeFromAnchorV00({ kind: 'enum', size: 'u16', variants: [] });
-    t.deepEqual(node, enumTypeNode([], { size: numberTypeNode('u16') }));
+    expect(node).toEqual(enumTypeNode([], { size: numberTypeNode('u16') }));
 });

packages/nodes-from-anchor/test/v00/typeNodes/MapTypeNode.test.ts

@@ -6,25 +6,21 @@ import {
     prefixedCountNode,
     remainderCountNode,
 } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates map type nodes', t => {
-    t.deepEqual(
-        typeNodeFromAnchorV00({ hashMap: ['u8', 'bool'] }),
+test('it creates map type nodes', () => {
+    expect(typeNodeFromAnchorV00({ hashMap: ['u8', 'bool'] })).toEqual(
         mapTypeNode(numberTypeNode('u8'), booleanTypeNode(), prefixedCountNode(numberTypeNode('u32'))),
     );
-    t.deepEqual(
-        typeNodeFromAnchorV00({ hashMap: ['u8', 'bool'], size: 2 }),
+    expect(typeNodeFromAnchorV00({ hashMap: ['u8', 'bool'], size: 2 })).toEqual(
         mapTypeNode(numberTypeNode('u8'), booleanTypeNode(), fixedCountNode(2)),
     );
-    t.deepEqual(
-        typeNodeFromAnchorV00({ hashMap: ['u8', 'bool'], size: 'u16' }),
+    expect(typeNodeFromAnchorV00({ hashMap: ['u8', 'bool'], size: 'u16' })).toEqual(
         mapTypeNode(numberTypeNode('u8'), booleanTypeNode(), prefixedCountNode(numberTypeNode('u16'))),
     );
-    t.deepEqual(
-        typeNodeFromAnchorV00({ hashMap: ['u8', 'bool'], size: 'remainder' }),
+    expect(typeNodeFromAnchorV00({ hashMap: ['u8', 'bool'], size: 'remainder' })).toEqual(
         mapTypeNode(numberTypeNode('u8'), booleanTypeNode(), remainderCountNode()),
     );
 });

packages/nodes-from-anchor/test/v00/typeNodes/NumberTypeNode.test.ts

@@ -1,20 +1,20 @@
 import { numberTypeNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates number type nodes', t => {
-    t.deepEqual(typeNodeFromAnchorV00('f32'), numberTypeNode('f32'));
-    t.deepEqual(typeNodeFromAnchorV00('f64'), numberTypeNode('f64'));
-    t.deepEqual(typeNodeFromAnchorV00('i8'), numberTypeNode('i8'));
-    t.deepEqual(typeNodeFromAnchorV00('i16'), numberTypeNode('i16'));
-    t.deepEqual(typeNodeFromAnchorV00('i32'), numberTypeNode('i32'));
-    t.deepEqual(typeNodeFromAnchorV00('i64'), numberTypeNode('i64'));
-    t.deepEqual(typeNodeFromAnchorV00('i128'), numberTypeNode('i128'));
-    t.deepEqual(typeNodeFromAnchorV00('shortU16'), numberTypeNode('shortU16'));
-    t.deepEqual(typeNodeFromAnchorV00('u8'), numberTypeNode('u8'));
-    t.deepEqual(typeNodeFromAnchorV00('u16'), numberTypeNode('u16'));
-    t.deepEqual(typeNodeFromAnchorV00('u32'), numberTypeNode('u32'));
-    t.deepEqual(typeNodeFromAnchorV00('u64'), numberTypeNode('u64'));
-    t.deepEqual(typeNodeFromAnchorV00('u128'), numberTypeNode('u128'));
+test('it creates number type nodes', () => {
+    expect(typeNodeFromAnchorV00('f32')).toEqual(numberTypeNode('f32'));
+    expect(typeNodeFromAnchorV00('f64')).toEqual(numberTypeNode('f64'));
+    expect(typeNodeFromAnchorV00('i8')).toEqual(numberTypeNode('i8'));
+    expect(typeNodeFromAnchorV00('i16')).toEqual(numberTypeNode('i16'));
+    expect(typeNodeFromAnchorV00('i32')).toEqual(numberTypeNode('i32'));
+    expect(typeNodeFromAnchorV00('i64')).toEqual(numberTypeNode('i64'));
+    expect(typeNodeFromAnchorV00('i128')).toEqual(numberTypeNode('i128'));
+    expect(typeNodeFromAnchorV00('shortU16')).toEqual(numberTypeNode('shortU16'));
+    expect(typeNodeFromAnchorV00('u8')).toEqual(numberTypeNode('u8'));
+    expect(typeNodeFromAnchorV00('u16')).toEqual(numberTypeNode('u16'));
+    expect(typeNodeFromAnchorV00('u32')).toEqual(numberTypeNode('u32'));
+    expect(typeNodeFromAnchorV00('u64')).toEqual(numberTypeNode('u64'));
+    expect(typeNodeFromAnchorV00('u128')).toEqual(numberTypeNode('u128'));
 });

packages/nodes-from-anchor/test/v00/typeNodes/OptionTypeNode.test.ts

@@ -1,26 +1,23 @@
 import { numberTypeNode, optionTypeNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates option type nodes', t => {
-    t.deepEqual(typeNodeFromAnchorV00({ option: 'u8' }), optionTypeNode(numberTypeNode('u8')));
+test('it creates option type nodes', () => {
+    expect(typeNodeFromAnchorV00({ option: 'u8' })).toEqual(optionTypeNode(numberTypeNode('u8')));
 });
 
-test('it creates option type nodes with custom prefixes', t => {
-    t.deepEqual(
-        typeNodeFromAnchorV00({ option: 'u8', prefix: 'u64' }),
+test('it creates option type nodes with custom prefixes', () => {
+    expect(typeNodeFromAnchorV00({ option: 'u8', prefix: 'u64' })).toEqual(
         optionTypeNode(numberTypeNode('u8'), { prefix: numberTypeNode('u64') }),
     );
 });
 
-test('it creates option type nodes with fixed size', t => {
-    t.deepEqual(
-        typeNodeFromAnchorV00({ coption: 'u8' }),
+test('it creates option type nodes with fixed size', () => {
+    expect(typeNodeFromAnchorV00({ coption: 'u8' })).toEqual(
         optionTypeNode(numberTypeNode('u8'), { fixed: true, prefix: numberTypeNode('u32') }),
     );
-    t.deepEqual(
-        typeNodeFromAnchorV00({ coption: 'u8', prefix: 'u16' }),
+    expect(typeNodeFromAnchorV00({ coption: 'u8', prefix: 'u16' })).toEqual(
         optionTypeNode(numberTypeNode('u8'), { fixed: true, prefix: numberTypeNode('u16') }),
     );
 });

packages/nodes-from-anchor/test/v00/typeNodes/PublicKeyTypeNode.test.ts

@@ -1,8 +1,8 @@
 import { publicKeyTypeNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates public key type nodes', t => {
-    t.deepEqual(typeNodeFromAnchorV00('publicKey'), publicKeyTypeNode());
+test('it creates public key type nodes', () => {
+    expect(typeNodeFromAnchorV00('publicKey')).toEqual(publicKeyTypeNode());
 });

packages/nodes-from-anchor/test/v00/typeNodes/SetTypeNode.test.ts

@@ -1,23 +1,19 @@
 import { fixedCountNode, numberTypeNode, prefixedCountNode, remainderCountNode, setTypeNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates set type nodes', t => {
-    t.deepEqual(
-        typeNodeFromAnchorV00({ hashSet: 'u8' }),
+test('it creates set type nodes', () => {
+    expect(typeNodeFromAnchorV00({ hashSet: 'u8' })).toEqual(
         setTypeNode(numberTypeNode('u8'), prefixedCountNode(numberTypeNode('u32'))),
     );
-    t.deepEqual(
-        typeNodeFromAnchorV00({ hashSet: 'u8', size: 2 }),
+    expect(typeNodeFromAnchorV00({ hashSet: 'u8', size: 2 })).toEqual(
         setTypeNode(numberTypeNode('u8'), fixedCountNode(2)),
     );
-    t.deepEqual(
-        typeNodeFromAnchorV00({ hashSet: 'u8', size: 'u16' }),
+    expect(typeNodeFromAnchorV00({ hashSet: 'u8', size: 'u16' })).toEqual(
         setTypeNode(numberTypeNode('u8'), prefixedCountNode(numberTypeNode('u16'))),
     );
-    t.deepEqual(
-        typeNodeFromAnchorV00({ hashSet: 'u8', size: 'remainder' }),
+    expect(typeNodeFromAnchorV00({ hashSet: 'u8', size: 'remainder' })).toEqual(
         setTypeNode(numberTypeNode('u8'), remainderCountNode()),
     );
 });

packages/nodes-from-anchor/test/v00/typeNodes/StringTypeNode.test.ts

@@ -1,8 +1,8 @@
 import { numberTypeNode, sizePrefixTypeNode, stringTypeNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates string type nodes', t => {
-    t.deepEqual(typeNodeFromAnchorV00('string'), sizePrefixTypeNode(stringTypeNode('utf8'), numberTypeNode('u32')));
+test('it creates string type nodes', () => {
+    expect(typeNodeFromAnchorV00('string')).toEqual(sizePrefixTypeNode(stringTypeNode('utf8'), numberTypeNode('u32')));
 });

packages/nodes-from-anchor/test/v00/typeNodes/StructTypeNode.test.ts

@@ -5,11 +5,11 @@ import {
     structFieldTypeNode,
     structTypeNode,
 } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates struct type nodes', t => {
+test('it creates struct type nodes', () => {
     const node = typeNodeFromAnchorV00({
         fields: [
             { name: 'name', type: 'string' },
@@ -18,8 +18,7 @@ test('it creates struct type nodes', t => {
         kind: 'struct',
     });
 
-    t.deepEqual(
-        node,
+    expect(node).toEqual(
         structTypeNode([
             structFieldTypeNode({
                 name: 'name',

packages/nodes-from-anchor/test/v00/typeNodes/TupleTypeNode.test.ts

@@ -1,12 +1,12 @@
 import { numberTypeNode, publicKeyTypeNode, tupleTypeNode } from '@kinobi-so/nodes';
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { typeNodeFromAnchorV00 } from '../../../src/index.js';
+import { typeNodeFromAnchorV00 } from '../../../src';
 
-test('it creates tuple type nodes', t => {
+test('it creates tuple type nodes', () => {
     const node = typeNodeFromAnchorV00({
         tuple: ['u8', 'publicKey'],
     });
 
-    t.deepEqual(node, tupleTypeNode([numberTypeNode('u8'), publicKeyTypeNode()]));
+    expect(node).toEqual(tupleTypeNode([numberTypeNode('u8'), publicKeyTypeNode()]));
 });

packages/nodes/package.json

@@ -38,7 +38,7 @@
         "build": "rimraf dist && pnpm build:src && pnpm build:types",
         "build:src": "zx ../../node_modules/@kinobi-so/internals/scripts/build-src.mjs package",
         "build:types": "zx ../../node_modules/@kinobi-so/internals/scripts/build-types.mjs",
-        "dev": "zx ../../node_modules/@kinobi-so/internals/scripts/test-unit.mjs browser --watch",
+        "dev": "zx ../../node_modules/@kinobi-so/internals/scripts/test-unit.mjs node --watch",
         "lint": "zx ../../node_modules/@kinobi-so/internals/scripts/lint.mjs",
         "lint:fix": "zx ../../node_modules/@kinobi-so/internals/scripts/lint.mjs --fix",
         "prepublishOnly": "pnpm build",

packages/nodes/src/types/global.d.ts

@@ -2,4 +2,5 @@ declare const __BROWSER__: boolean;
 declare const __DEV__: boolean;
 declare const __NODEJS__: boolean;
 declare const __REACTNATIVE__: boolean;
+declare const __TEST__: boolean;
 declare const __VERSION__: string;

packages/nodes/test/AccountNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { accountNode } from '../src/index.js';
+import { accountNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = accountNode({ name: 'foo' });
-    t.is(node.kind, 'accountNode');
+    expect(node.kind).toBe('accountNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = accountNode({ name: 'foo' });
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/DefinedTypeNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { definedTypeNode, structTypeNode } from '../src/index.js';
+import { definedTypeNode, structTypeNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = definedTypeNode({ name: 'foo', type: structTypeNode([]) });
-    t.is(node.kind, 'definedTypeNode');
+    expect(node.kind).toBe('definedTypeNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = definedTypeNode({ name: 'foo', type: structTypeNode([]) });
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/ErrorNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { errorNode } from '../src/index.js';
+import { errorNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = errorNode({ name: 'foo', code: 42, message: 'error message' });
-    t.is(node.kind, 'errorNode');
+    expect(node.kind).toBe('errorNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = errorNode({ name: 'foo', code: 42, message: 'error message' });
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/InstructionAccountNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { instructionAccountNode } from '../src/index.js';
+import { instructionAccountNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = instructionAccountNode({ name: 'foo', isSigner: false, isWritable: false });
-    t.is(node.kind, 'instructionAccountNode');
+    expect(node.kind).toBe('instructionAccountNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = instructionAccountNode({ name: 'foo', isSigner: false, isWritable: false });
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/InstructionArgumentNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { instructionArgumentNode, structTypeNode } from '../src/index.js';
+import { instructionArgumentNode, structTypeNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = instructionArgumentNode({ name: 'foo', type: structTypeNode([]) });
-    t.is(node.kind, 'instructionArgumentNode');
+    expect(node.kind).toBe('instructionArgumentNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = instructionArgumentNode({ name: 'foo', type: structTypeNode([]) });
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/InstructionByteDeltaNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { instructionByteDeltaNode, numberValueNode } from '../src/index.js';
+import { instructionByteDeltaNode, numberValueNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = instructionByteDeltaNode(numberValueNode(42));
-    t.is(node.kind, 'instructionByteDeltaNode');
+    expect(node.kind).toBe('instructionByteDeltaNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = instructionByteDeltaNode(numberValueNode(42));
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/InstructionNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { instructionNode } from '../src/index.js';
+import { instructionNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = instructionNode({ name: 'foo' });
-    t.is(node.kind, 'instructionNode');
+    expect(node.kind).toBe('instructionNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = instructionNode({ name: 'foo' });
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/InstructionRemainingAccountsNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { argumentValueNode, instructionRemainingAccountsNode } from '../src/index.js';
+import { argumentValueNode, instructionRemainingAccountsNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = instructionRemainingAccountsNode(argumentValueNode('foo'));
-    t.is(node.kind, 'instructionRemainingAccountsNode');
+    expect(node.kind).toBe('instructionRemainingAccountsNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = instructionRemainingAccountsNode(argumentValueNode('foo'));
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/Node.test.ts

@@ -1,4 +1,4 @@
-import test from 'ava';
+import { describe, expect, test } from 'vitest';
 
 import {
     assertIsNode,
@@ -9,95 +9,101 @@ import {
     publicKeyTypeNode,
     removeNullAndAssertIsNodeFilter,
     tupleTypeNode,
-} from '../src/index.js';
+} from '../src';
 
-test('it checks if a given node is of the given kind', t => {
-    t.true(isNode(tupleTypeNode([]), 'tupleTypeNode'));
-    t.false(isNode(publicKeyTypeNode(), 'tupleTypeNode'));
-    t.false(isNode(null, 'tupleTypeNode'));
-});
-
-test('it checks if a given node is part of the given kinds', t => {
-    t.true(isNode(tupleTypeNode([]), ['tupleTypeNode', 'publicKeyTypeNode']));
-    t.true(isNode(publicKeyTypeNode(), ['tupleTypeNode', 'publicKeyTypeNode']));
-    t.false(isNode(numberTypeNode('u8'), ['tupleTypeNode', 'publicKeyTypeNode']));
-    t.false(isNode(null, ['tupleTypeNode', 'publicKeyTypeNode']));
-});
-
-test('it asserts that a given node is of the given kind', t => {
-    t.notThrows(() => assertIsNode(tupleTypeNode([]), 'tupleTypeNode'));
-    t.throws(() => assertIsNode(publicKeyTypeNode(), 'tupleTypeNode'), {
-        message: 'Expected node of kind [tupleTypeNode], got [publicKeyTypeNode].',
+describe('isNode', () => {
+    test('it checks if a given node is of the given kind', () => {
+        expect(isNode(tupleTypeNode([]), 'tupleTypeNode')).toBe(true);
+        expect(isNode(publicKeyTypeNode(), 'tupleTypeNode')).toBe(false);
+        expect(isNode(null, 'tupleTypeNode')).toBe(false);
     });
-    t.throws(() => assertIsNode(null, 'tupleTypeNode'), {
-        message: 'Expected node of kind [tupleTypeNode], got [null].',
-    });
-});
 
-test('it asserts that a given node is part of the given kinds', t => {
-    t.notThrows(() => assertIsNode(tupleTypeNode([]), ['tupleTypeNode', 'publicKeyTypeNode']));
-    t.notThrows(() => assertIsNode(publicKeyTypeNode(), ['tupleTypeNode', 'publicKeyTypeNode']));
-    t.throws(() => assertIsNode(numberTypeNode('u8'), ['tupleTypeNode', 'publicKeyTypeNode']), {
-        message: 'Expected node of kind [tupleTypeNode,publicKeyTypeNode], got [numberTypeNode].',
-    });
-    t.throws(() => assertIsNode(null, ['tupleTypeNode', 'publicKeyTypeNode']), {
-        message: 'Expected node of kind [tupleTypeNode,publicKeyTypeNode], got [null].',
+    test('it checks if a given node is part of the given kinds', () => {
+        expect(isNode(tupleTypeNode([]), ['tupleTypeNode', 'publicKeyTypeNode'])).toBe(true);
+        expect(isNode(publicKeyTypeNode(), ['tupleTypeNode', 'publicKeyTypeNode'])).toBe(true);
+        expect(isNode(numberTypeNode('u8'), ['tupleTypeNode', 'publicKeyTypeNode'])).toBe(false);
+        expect(isNode(null, ['tupleTypeNode', 'publicKeyTypeNode'])).toBe(false);
     });
 });
 
-test('it returns a callback that checks the node is of the given kind', t => {
-    const filter = isNodeFilter('tupleTypeNode');
-    t.true(filter(tupleTypeNode([])));
-    t.false(filter(publicKeyTypeNode()));
-    t.false(filter(null));
-});
+describe('assertIsNode', () => {
+    test('it asserts that a given node is of the given kind', () => {
+        expect(() => assertIsNode(tupleTypeNode([]), 'tupleTypeNode')).not.toThrow();
+        expect(() => assertIsNode(publicKeyTypeNode(), 'tupleTypeNode')).toThrowError(
+            'Expected node of kind [tupleTypeNode], got [publicKeyTypeNode].',
+        );
+        expect(() => assertIsNode(null, 'tupleTypeNode')).toThrowError(
+            'Expected node of kind [tupleTypeNode], got [null].',
+        );
+    });
 
-test('it returns a callback that checks the node is part of the given kinds', t => {
-    const filter = isNodeFilter(['tupleTypeNode', 'publicKeyTypeNode']);
-    t.true(filter(tupleTypeNode([])));
-    t.true(filter(publicKeyTypeNode()));
-    t.false(filter(numberTypeNode('u8')));
-    t.false(filter(null));
+    test('it asserts that a given node is part of the given kinds', () => {
+        expect(() => assertIsNode(tupleTypeNode([]), ['tupleTypeNode', 'publicKeyTypeNode'])).not.toThrow();
+        expect(() => assertIsNode(publicKeyTypeNode(), ['tupleTypeNode', 'publicKeyTypeNode'])).not.toThrow();
+        expect(() => assertIsNode(numberTypeNode('u8'), ['tupleTypeNode', 'publicKeyTypeNode'])).toThrowError(
+            'Expected node of kind [tupleTypeNode,publicKeyTypeNode], got [numberTypeNode].',
+        );
+        expect(() => assertIsNode(null, ['tupleTypeNode', 'publicKeyTypeNode'])).toThrowError(
+            'Expected node of kind [tupleTypeNode,publicKeyTypeNode], got [null].',
+        );
+    });
 });
 
-test('it returns a callback that asserts the node is of the given kind', t => {
-    const filter = assertIsNodeFilter('tupleTypeNode');
-    t.notThrows(() => filter(tupleTypeNode([])));
-    t.throws(() => filter(publicKeyTypeNode()), {
-        message: 'Expected node of kind [tupleTypeNode], got [publicKeyTypeNode].',
+describe('isNodeFilter', () => {
+    test('it returns a callback that checks the node is of the given kind', () => {
+        const filter = isNodeFilter('tupleTypeNode');
+        expect(filter(tupleTypeNode([]))).toBe(true);
+        expect(filter(publicKeyTypeNode())).toBe(false);
+        expect(filter(null)).toBe(false);
     });
-    t.throws(() => filter(null), {
-        message: 'Expected node of kind [tupleTypeNode], got [null].',
+
+    test('it returns a callback that checks the node is part of the given kinds', () => {
+        const filter = isNodeFilter(['tupleTypeNode', 'publicKeyTypeNode']);
+        expect(filter(tupleTypeNode([]))).toBe(true);
+        expect(filter(publicKeyTypeNode())).toBe(true);
+        expect(filter(numberTypeNode('u8'))).toBe(false);
+        expect(filter(null)).toBe(false);
     });
 });
 
-test('it returns a callback that asserts the node is part of the given kinds', t => {
-    const filter = assertIsNodeFilter(['tupleTypeNode', 'publicKeyTypeNode']);
-    t.notThrows(() => filter(tupleTypeNode([])));
-    t.notThrows(() => filter(publicKeyTypeNode()));
-    t.throws(() => filter(numberTypeNode('u8')), {
-        message: 'Expected node of kind [tupleTypeNode,publicKeyTypeNode], got [numberTypeNode].',
+describe('assertIsNodeFilter', () => {
+    test('it returns a callback that asserts the node is of the given kind', () => {
+        const filter = assertIsNodeFilter('tupleTypeNode');
+        expect(() => filter(tupleTypeNode([]))).not.toThrow();
+        expect(() => filter(publicKeyTypeNode())).toThrowError(
+            'Expected node of kind [tupleTypeNode], got [publicKeyTypeNode].',
+        );
+        expect(() => filter(null)).toThrowError('Expected node of kind [tupleTypeNode], got [null].');
     });
-    t.throws(() => filter(null), {
-        message: 'Expected node of kind [tupleTypeNode,publicKeyTypeNode], got [null].',
+
+    test('it returns a callback that asserts the node is part of the given kinds', () => {
+        const filter = assertIsNodeFilter(['tupleTypeNode', 'publicKeyTypeNode']);
+        expect(() => filter(tupleTypeNode([]))).not.toThrow();
+        expect(() => filter(publicKeyTypeNode())).not.toThrow();
+        expect(() => filter(numberTypeNode('u8'))).toThrowError(
+            'Expected node of kind [tupleTypeNode,publicKeyTypeNode], got [numberTypeNode].',
+        );
+        expect(() => filter(null)).toThrowError('Expected node of kind [tupleTypeNode,publicKeyTypeNode], got [null].');
     });
 });
 
-test('it returns a callback that filters out null values and asserts the node is of the given kind', t => {
-    const filter = removeNullAndAssertIsNodeFilter('tupleTypeNode');
-    t.deepEqual([tupleTypeNode([]), null].filter(filter), [tupleTypeNode([])]);
-    t.throws(() => [tupleTypeNode([]), publicKeyTypeNode(), null].filter(filter), {
-        message: 'Expected node of kind [tupleTypeNode], got [publicKeyTypeNode].',
+describe('removeNullAndAssertIsNodeFilter', () => {
+    test('it returns a callback that filters out null values and asserts the node is of the given kind', () => {
+        const filter = removeNullAndAssertIsNodeFilter('tupleTypeNode');
+        expect([tupleTypeNode([]), null].filter(filter)).toEqual([tupleTypeNode([])]);
+        expect(() => [tupleTypeNode([]), publicKeyTypeNode(), null].filter(filter)).toThrowError(
+            'Expected node of kind [tupleTypeNode], got [publicKeyTypeNode].',
+        );
     });
-});
 
-test('it returns a callback that filters out null values and asserts the node is part of the given kinds', t => {
-    const filter = removeNullAndAssertIsNodeFilter(['tupleTypeNode', 'publicKeyTypeNode']);
-    t.deepEqual([tupleTypeNode([]), publicKeyTypeNode(), null].filter(filter), [
-        tupleTypeNode([]),
-        publicKeyTypeNode(),
-    ]);
-    t.throws(() => [tupleTypeNode([]), numberTypeNode('u8'), null].filter(filter), {
-        message: 'Expected node of kind [tupleTypeNode,publicKeyTypeNode], got [numberTypeNode].',
+    test('it returns a callback that filters out null values and asserts the node is part of the given kinds', () => {
+        const filter = removeNullAndAssertIsNodeFilter(['tupleTypeNode', 'publicKeyTypeNode']);
+        expect([tupleTypeNode([]), publicKeyTypeNode(), null].filter(filter)).toEqual([
+            tupleTypeNode([]),
+            publicKeyTypeNode(),
+        ]);
+        expect(() => [tupleTypeNode([]), numberTypeNode('u8'), null].filter(filter)).toThrowError(
+            'Expected node of kind [tupleTypeNode,publicKeyTypeNode], got [numberTypeNode].',
+        );
     });
 });

packages/nodes/test/Node.typetest.ts

@@ -7,7 +7,7 @@ import {
     isNodeFilter,
     REGISTERED_NODE_KINDS,
     removeNullAndAssertIsNodeFilter,
-} from '../src/index.js';
+} from '../src';
 
 // [DESCRIBE] Registered node kinds.
 {

packages/nodes/test/PdaNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { pdaNode } from '../src/index.js';
+import { pdaNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = pdaNode({ name: 'foo', seeds: [] });
-    t.is(node.kind, 'pdaNode');
+    expect(node.kind).toBe('pdaNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = pdaNode({ name: 'foo', seeds: [] });
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/ProgramNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { programNode } from '../src/index.js';
+import { programNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = programNode({ name: 'foo', publicKey: '1111' });
-    t.is(node.kind, 'programNode');
+    expect(node.kind).toBe('programNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = programNode({ name: 'foo', publicKey: '1111' });
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/RootNode.test.ts

@@ -1,24 +1,25 @@
 import type { KinobiVersion } from '@kinobi-so/node-types';
-import test from 'ava';
+import { expect, expectTypeOf, test } from 'vitest';
 
-import { programNode, rootNode } from '../src/index.js';
+import { programNode, rootNode } from '../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const root = rootNode(programNode({ name: 'foo', publicKey: '1111' }));
-    t.is(root.kind, 'rootNode');
+    expect(root.kind).toBe('rootNode');
 });
 
-test('it returns the right Kinobi standard', t => {
+test('it returns the right Kinobi standard', () => {
     const root = rootNode(programNode({ name: 'foo', publicKey: '1111' }));
-    t.is(root.standard, 'kinobi');
+    expect(root.standard).toBe('kinobi');
 });
 
-test('it returns the right Kinobi version', t => {
+test('it returns the right Kinobi version', () => {
     const root = rootNode(programNode({ name: 'foo', publicKey: '1111' }));
-    t.is(root.version, __VERSION__ as KinobiVersion);
+    expect(root.version).toBe(__VERSION__);
+    expectTypeOf(root.version).toMatchTypeOf<KinobiVersion>();
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const root = rootNode(programNode({ name: 'foo', publicKey: '1111' }));
-    t.true(Object.isFrozen(root));
+    expect(Object.isFrozen(root)).toBe(true);
 });

packages/nodes/test/contextualValueNodes/AccountBumpValueNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { accountBumpValueNode } from '../../src/index.js';
+import { accountBumpValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = accountBumpValueNode('associatedToken');
-    t.is(node.kind, 'accountBumpValueNode');
+    expect(node.kind).toBe('accountBumpValueNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = accountBumpValueNode('associatedToken');
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/contextualValueNodes/AccountValueNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { accountValueNode } from '../../src/index.js';
+import { accountValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = accountValueNode('mint');
-    t.is(node.kind, 'accountValueNode');
+    expect(node.kind).toBe('accountValueNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = accountValueNode('mint');
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/contextualValueNodes/ArgumentValueNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { argumentValueNode } from '../../src/index.js';
+import { argumentValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = argumentValueNode('space');
-    t.is(node.kind, 'argumentValueNode');
+    expect(node.kind).toBe('argumentValueNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = argumentValueNode('space');
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/contextualValueNodes/ConditionalValueNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { accountValueNode, argumentValueNode, conditionalValueNode } from '../../src/index.js';
+import { accountValueNode, argumentValueNode, conditionalValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = conditionalValueNode({ condition: accountValueNode('token'), ifTrue: argumentValueNode('space') });
-    t.is(node.kind, 'conditionalValueNode');
+    expect(node.kind).toBe('conditionalValueNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = conditionalValueNode({ condition: accountValueNode('token'), ifTrue: argumentValueNode('space') });
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/contextualValueNodes/ContextualValueNode.typetest.ts

@@ -1,6 +1,6 @@
 import type { RegisteredContextualValueNode } from '@kinobi-so/node-types';
 
-import { REGISTERED_CONTEXTUAL_VALUE_NODE_KINDS } from '../../src/index.js';
+import { REGISTERED_CONTEXTUAL_VALUE_NODE_KINDS } from '../../src';
 
 // [DESCRIBE] Registered contextual value node kinds.
 {

packages/nodes/test/contextualValueNodes/IdentityValueNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { identityValueNode } from '../../src/index.js';
+import { identityValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = identityValueNode();
-    t.is(node.kind, 'identityValueNode');
+    expect(node.kind).toBe('identityValueNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = identityValueNode();
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/contextualValueNodes/PayerValueNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { payerValueNode } from '../../src/index.js';
+import { payerValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = payerValueNode();
-    t.is(node.kind, 'payerValueNode');
+    expect(node.kind).toBe('payerValueNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = payerValueNode();
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/contextualValueNodes/PdaSeedValueNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { accountValueNode, pdaSeedValueNode } from '../../src/index.js';
+import { accountValueNode, pdaSeedValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = pdaSeedValueNode('token', accountValueNode('token'));
-    t.is(node.kind, 'pdaSeedValueNode');
+    expect(node.kind).toBe('pdaSeedValueNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = pdaSeedValueNode('token', accountValueNode('token'));
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/contextualValueNodes/PdaValueNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { pdaValueNode } from '../../src/index.js';
+import { pdaValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = pdaValueNode('associatedToken', []);
-    t.is(node.kind, 'pdaValueNode');
+    expect(node.kind).toBe('pdaValueNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = pdaValueNode('associatedToken', []);
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/contextualValueNodes/ProgramIdValueNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { programIdValueNode } from '../../src/index.js';
+import { programIdValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = programIdValueNode();
-    t.is(node.kind, 'programIdValueNode');
+    expect(node.kind).toBe('programIdValueNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = programIdValueNode();
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/contextualValueNodes/ResolverValueNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { resolverValueNode } from '../../src/index.js';
+import { resolverValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = resolverValueNode('foo');
-    t.is(node.kind, 'resolverValueNode');
+    expect(node.kind).toBe('resolverValueNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = resolverValueNode('foo');
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/countNodes/CountNode.typetest.ts

@@ -1,6 +1,6 @@
 import type { RegisteredCountNode } from '@kinobi-so/node-types';
 
-import { REGISTERED_COUNT_NODE_KINDS } from '../../src/index.js';
+import { REGISTERED_COUNT_NODE_KINDS } from '../../src';
 
 // [DESCRIBE] Registered count node kinds.
 {

packages/nodes/test/countNodes/FixedCountNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { fixedCountNode } from '../../src/index.js';
+import { fixedCountNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = fixedCountNode(42);
-    t.is(node.kind, 'fixedCountNode');
+    expect(node.kind).toBe('fixedCountNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = fixedCountNode(42);
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/countNodes/PrefixedCountNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { numberTypeNode, prefixedCountNode } from '../../src/index.js';
+import { numberTypeNode, prefixedCountNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = prefixedCountNode(numberTypeNode('u32'));
-    t.is(node.kind, 'prefixedCountNode');
+    expect(node.kind).toBe('prefixedCountNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = prefixedCountNode(numberTypeNode('u32'));
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/countNodes/RemainderCountNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { remainderCountNode } from '../../src/index.js';
+import { remainderCountNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = remainderCountNode();
-    t.is(node.kind, 'remainderCountNode');
+    expect(node.kind).toBe('remainderCountNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = remainderCountNode();
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/discriminatorNodes/ConstantDiscriminatorNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { constantDiscriminatorNode, constantValueNodeFromBytes } from '../../src/index.js';
+import { constantDiscriminatorNode, constantValueNodeFromBytes } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = constantDiscriminatorNode(constantValueNodeFromBytes('base16', 'aabbccdd'));
-    t.is(node.kind, 'constantDiscriminatorNode');
+    expect(node.kind).toBe('constantDiscriminatorNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = constantDiscriminatorNode(constantValueNodeFromBytes('base16', 'aabbccdd'));
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/discriminatorNodes/DiscriminatorNode.typetest.ts

@@ -1,6 +1,6 @@
 import type { RegisteredDiscriminatorNode } from '@kinobi-so/node-types';
 
-import { REGISTERED_DISCRIMINATOR_NODE_KINDS } from '../../src/index.js';
+import { REGISTERED_DISCRIMINATOR_NODE_KINDS } from '../../src';
 
 // [DESCRIBE] Registered discriminator node kinds.
 {

packages/nodes/test/discriminatorNodes/FieldDiscriminatorNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { fieldDiscriminatorNode } from '../../src/index.js';
+import { fieldDiscriminatorNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = fieldDiscriminatorNode('discriminator');
-    t.is(node.kind, 'fieldDiscriminatorNode');
+    expect(node.kind).toBe('fieldDiscriminatorNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = fieldDiscriminatorNode('discriminator');
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/discriminatorNodes/SizeDiscriminatorNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { sizeDiscriminatorNode } from '../../src/index.js';
+import { sizeDiscriminatorNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = sizeDiscriminatorNode(42);
-    t.is(node.kind, 'sizeDiscriminatorNode');
+    expect(node.kind).toBe('sizeDiscriminatorNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = sizeDiscriminatorNode(42);
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/linkNodes/AccountLinkNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { accountLinkNode } from '../../src/index.js';
+import { accountLinkNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = accountLinkNode('token');
-    t.is(node.kind, 'accountLinkNode');
+    expect(node.kind).toBe('accountLinkNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = accountLinkNode('token');
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/linkNodes/DefinedTypeLinkNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { definedTypeLinkNode } from '../../src/index.js';
+import { definedTypeLinkNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = definedTypeLinkNode('config');
-    t.is(node.kind, 'definedTypeLinkNode');
+    expect(node.kind).toBe('definedTypeLinkNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = definedTypeLinkNode('config');
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/linkNodes/LinkNode.typetest.ts

@@ -1,6 +1,6 @@
 import type { RegisteredLinkNode } from '@kinobi-so/node-types';
 
-import { REGISTERED_LINK_NODE_KINDS } from '../../src/index.js';
+import { REGISTERED_LINK_NODE_KINDS } from '../../src';
 
 // [DESCRIBE] Registered link node kinds.
 {

packages/nodes/test/linkNodes/PdaLinkNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { pdaLinkNode } from '../../src/index.js';
+import { pdaLinkNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = pdaLinkNode('associatedToken');
-    t.is(node.kind, 'pdaLinkNode');
+    expect(node.kind).toBe('pdaLinkNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = pdaLinkNode('associatedToken');
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/linkNodes/ProgramLinkNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { programLinkNode } from '../../src/index.js';
+import { programLinkNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = programLinkNode('system');
-    t.is(node.kind, 'programLinkNode');
+    expect(node.kind).toBe('programLinkNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = programLinkNode('system');
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/pdaSeedNodes/ConstantPdaSeedNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { constantPdaSeedNode, numberTypeNode, numberValueNode } from '../../src/index.js';
+import { constantPdaSeedNode, numberTypeNode, numberValueNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = constantPdaSeedNode(numberTypeNode('u64'), numberValueNode(42));
-    t.is(node.kind, 'constantPdaSeedNode');
+    expect(node.kind).toBe('constantPdaSeedNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = constantPdaSeedNode(numberTypeNode('u64'), numberValueNode(42));
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/pdaSeedNodes/PdaSeedNode.typetest.ts

@@ -1,6 +1,6 @@
 import type { RegisteredPdaSeedNode } from '@kinobi-so/node-types';
 
-import { REGISTERED_PDA_SEED_NODE_KINDS } from '../../src/index.js';
+import { REGISTERED_PDA_SEED_NODE_KINDS } from '../../src';
 
 // [DESCRIBE] Registered pda seed node kinds.
 {

packages/nodes/test/pdaSeedNodes/VariablePdaSeedNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { numberTypeNode, variablePdaSeedNode } from '../../src/index.js';
+import { numberTypeNode, variablePdaSeedNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = variablePdaSeedNode('edition', numberTypeNode('u64'));
-    t.is(node.kind, 'variablePdaSeedNode');
+    expect(node.kind).toBe('variablePdaSeedNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = variablePdaSeedNode('edition', numberTypeNode('u64'));
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/typeNodes/AmountTypeNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { amountTypeNode, numberTypeNode } from '../../src/index.js';
+import { amountTypeNode, numberTypeNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = amountTypeNode(numberTypeNode('u64'), 9);
-    t.is(node.kind, 'amountTypeNode');
+    expect(node.kind).toBe('amountTypeNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = amountTypeNode(numberTypeNode('u64'), 9);
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/typeNodes/ArrayTypeNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { arrayTypeNode, numberTypeNode, remainderCountNode } from '../../src/index.js';
+import { arrayTypeNode, numberTypeNode, remainderCountNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = arrayTypeNode(numberTypeNode('u64'), remainderCountNode());
-    t.is(node.kind, 'arrayTypeNode');
+    expect(node.kind).toBe('arrayTypeNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = arrayTypeNode(numberTypeNode('u64'), remainderCountNode());
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/typeNodes/BooleanTypeNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { booleanTypeNode } from '../../src/index.js';
+import { booleanTypeNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = booleanTypeNode();
-    t.is(node.kind, 'booleanTypeNode');
+    expect(node.kind).toBe('booleanTypeNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = booleanTypeNode();
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/typeNodes/BytesTypeNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { bytesTypeNode } from '../../src/index.js';
+import { bytesTypeNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = bytesTypeNode();
-    t.is(node.kind, 'bytesTypeNode');
+    expect(node.kind).toBe('bytesTypeNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = bytesTypeNode();
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });

packages/nodes/test/typeNodes/DateTimeTypeNode.test.ts

@@ -1,13 +1,13 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 
-import { dateTimeTypeNode, numberTypeNode } from '../../src/index.js';
+import { dateTimeTypeNode, numberTypeNode } from '../../src';
 
-test('it returns the right node kind', t => {
+test('it returns the right node kind', () => {
     const node = dateTimeTypeNode(numberTypeNode('u64'));
-    t.is(node.kind, 'dateTimeTypeNode');
+    expect(node.kind).toBe('dateTimeTypeNode');
 });
 
-test('it returns a frozen object', t => {
+test('it returns a frozen object', () => {
     const node = dateTimeTypeNode(numberTypeNode('u64'));
-    t.true(Object.isFrozen(node));
+    expect(Object.isFrozen(node)).toBe(true);
 });