perf: replace multiple tsImport() calls with a shared tsx register

tsImport() from tsx/esm/api creates a new module.register() and
MessageChannel per invocation. The CLI calls it up to 3 times. By
creating a single register({namespace}) instance and reusing its
.import() method, we eliminate redundant hook registrations.

Micro-benchmark shows ~90ms savings per additional tsImport call
(96ms for 2x tsImport vs 3ms for shared register + 2x import).

* Add src/cli/ts-import.ts with lazy shared register singleton
* Replace tsImport() in config.ts (1 call) and drizzle-kit.ts (2 calls)

Author: Alp

src/cli/config.ts

@@ -2,8 +2,8 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as url from 'node:url';
 import type {Project} from 'ts-morph';
-import {tsImport} from 'tsx/esm/api';
 import type {DrizzleToZeroSchema} from '../relations';
+import {tsImportShared} from './ts-import';
 
 export const defaultConfigFilePath = 'drizzle-zero.config.ts';
 
@@ -40,7 +40,7 @@ export const getConfigFromFile = async ({
 
   try {
     const zeroConfigFilePathUrl = url.pathToFileURL(fullConfigPath).href;
-    const zeroConfigImport = await tsImport(
+    const zeroConfigImport = await tsImportShared(
       zeroConfigFilePathUrl,
       import.meta.url,
     );

src/cli/drizzle-kit.ts

@@ -3,8 +3,8 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as url from 'node:url';
 import type {Project} from 'ts-morph';
-import {tsImport} from 'tsx/esm/api';
 import {drizzleZeroConfig, type DrizzleToZeroSchema} from '../relations';
+import {tsImportShared} from './ts-import';
 import {ensureSourceFileInProject} from './ts-project';
 
 export const getDefaultConfig = async ({
@@ -30,7 +30,7 @@ export const getDefaultConfig = async ({
     resolvedDrizzleSchemaPath,
   ).href;
 
-  const drizzleSchema = await tsImport(
+  const drizzleSchema = await tsImportShared(
     resolvedDrizzleSchemaPathUrl,
     import.meta.url,
   );
@@ -92,7 +92,7 @@ export const getFullDrizzleSchemaFilePath = async ({
       await fs.access(fullPath);
 
       const drizzleKitConfigFilePathUrl = url.pathToFileURL(fullPath).href;
-      const drizzleKitConfigImport = await tsImport(
+      const drizzleKitConfigImport = await tsImportShared(
         drizzleKitConfigFilePathUrl,
         import.meta.url,
       );

src/cli/ts-import.ts

@@ -0,0 +1,21 @@
+import {register} from 'tsx/esm/api';
+
+type TsxRegister = ReturnType<typeof register> & {
+  import: (specifier: string, parentURL: string) => Promise<any>;
+};
+
+let tsxRegister: TsxRegister | undefined;
+
+/**
+ * Import a TypeScript module using a shared tsx register instance.
+ * Lazily creates a single tsx register on first call, then reuses it
+ * for all subsequent imports. This avoids the overhead of creating a
+ * new module register per call (which is what `tsImport()` does internally).
+ */
+export const tsImportShared = (
+  specifier: string,
+  parentURL: string,
+): Promise<any> => {
+  tsxRegister ??= register({namespace: 'drizzle-zero'}) as TsxRegister;
+  return tsxRegister.import(specifier, parentURL);
+};

tests/cli.test.ts

@@ -1610,13 +1610,15 @@ describe('drizzle-kit functions', () => {
 
       try {
         // Setup mocks before importing the function
+        const mockImport = vi.fn().mockImplementation(path => {
+          if (path.includes('temp-drizzle-schema.ts')) {
+            return {users: {}};
+          }
+          return {};
+        });
         vi.doMock('tsx/esm/api', () => ({
-          tsImport: vi.fn().mockImplementation(path => {
-            if (path.includes('temp-drizzle-schema.ts')) {
-              return {users: {}};
-            }
-            return {};
-          }),
+          tsImport: mockImport,
+          register: vi.fn().mockReturnValue({import: mockImport}),
         }));
 
         vi.doMock('../src/relations', () => ({