@flowblade/sqlduck 0.32.0 → 0.34.0

package/README.md

@@ -128,75 +128,79 @@ const queryResult = await dbDuckDbMemoryConn.query<{
 
 ## Benchmarks
 
-### Node 24.15
+### Node 24.19
 
 ```
- RUN  v4.1.5 /home/sebastien/github/flowblade/packages/sqlduck
+ RUN  v4.1.10 /home/sebastien/github/flowblade/packages/sqlduck
 
 
- ✓ bench/appender.bench.ts > appender benches 3477ms
-     name                                                        hz     min     max    mean     p75     p99    p995    p999      rme  samples
-   · duckdb appender memory, count: 100000, chunk size 2048  2.9578  336.81  339.37  338.09  339.37  339.37  339.37  339.37   ±4.82%        2
-   · duckdb appender file, count: 100000, chunk size 2048    1.5359  651.07  651.07  651.07  651.07  651.07  651.07  651.07   ±0.00%        1
-   · duckdb appender, count: 100000, chunk size 1024         2.8450  328.25  374.74  351.50  374.74  374.74  374.74  374.74  ±84.06%        2
+ ✓ bench/appender.bench.ts > appender benches 4702ms
+     name                                                             hz     min     max    mean     p75     p99    p995    p999       rme  samples
+   · duckdb appender memory, count: 100000, chunk size 2048       2.9565  297.19  379.28  338.23  379.28  379.28  379.28  379.28  ±154.25%        2
+   · duckdb appender file, count: 100000, chunk size 2048         3.2467  302.16  313.84  308.00  313.84  313.84  313.84  313.84   ±24.10%        2
+   · duckdb appender file no wal, count: 100000, chunk size 2048  3.5982  272.83  283.01  277.92  283.01  283.01  283.01  283.01   ±23.29%        2
+   · duckdb appender file no wal, count: 100000, chunk size 1024  3.1962  307.89  317.86  312.87  317.86  317.86  317.86  317.86   ±20.24%        2
+   · duckdb appender, count: 100000, chunk size 1024              3.9457  238.32  268.56  253.44  268.56  268.56  268.56  268.56   ±75.84%        2
 
- ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 3514ms
+ ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 2768ms
      name                                                                         hz      min     max     mean      p75     p99    p995    p999      rme  samples
-   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   10.6932  76.7549  197.03  93.5173  88.9991  197.03  197.03  197.03  ±28.09%       10
-   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  10.2660  87.8295  141.15  97.4092  97.0299  141.15  141.15  141.15  ±11.56%       10
-   · mapFakeRowStream with chunkSize 2048 (count: 100000)                     8.3811   113.83  136.27   119.32   118.84  136.27  136.27  136.27   ±4.30%       10
+   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   14.7282  55.8866  117.44  67.8968  66.1927  117.44  117.44  117.44  ±18.84%       10
+   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  12.1404  62.2024  138.60  82.3693  80.8803  138.60  138.60  138.60  ±26.30%       10
+   · mapFakeRowStream with chunkSize 2048 (count: 100000)                    11.5408  79.1225  102.85  86.6494  89.3379  102.85  102.85  102.85   ±5.60%       10
 
- ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 614ms
+ ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 613ms
      name                          hz     min     max    mean     p75     p99    p995    p999     rme  samples
-   · getTableCreateFromZod  20,399.65  0.0328  1.2897  0.0490  0.0425  0.1957  0.2681  0.6023  ±1.77%    10201
+   · getTableCreateFromZod  24,208.11  0.0247  5.2321  0.0413  0.0434  0.1512  0.2186  0.7364  ±2.68%    12105
 
  BENCH  Summary
 
-  duckdb appender memory, count: 100000, chunk size 2048 - bench/appender.bench.ts > appender benches
-    1.04x faster than duckdb appender, count: 100000, chunk size 1024
-    1.93x faster than duckdb appender file, count: 100000, chunk size 2048
+  duckdb appender, count: 100000, chunk size 1024 - bench/appender.bench.ts > appender benches
+    1.10x faster than duckdb appender file no wal, count: 100000, chunk size 2048
+    1.22x faster than duckdb appender file, count: 100000, chunk size 2048
+    1.23x faster than duckdb appender file no wal, count: 100000, chunk size 1024
+    1.33x faster than duckdb appender memory, count: 100000, chunk size 2048
 
   rowToColumnsChunk with chunkSize 2048 (count: 100000) - bench/stream.bench.ts > Bench rowsToColumnsChunks
-    1.04x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
+    1.21x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
     1.28x faster than mapFakeRowStream with chunkSize 2048 (count: 100000)
-
-  getTableCreateFromZod - bench/table-create.bench.ts > Bench getTableCreateFromZod
-
 ```
 
-### Bun 1.3.13
+### Bun 1.4.0-dev
 
 ```
- RUN  v4.1.5 /home/sebastien/github/flowblade/packages/sqlduck
+RUN  v4.1.10 /home/sebastien/github/flowblade/packages/sqlduck
 
 
- ✓ bench/appender.bench.ts > appender benches 3382ms
-     name                                                        hz     min     max    mean     p75     p99    p995    p999      rme  samples
-   · duckdb appender memory, count: 100000, chunk size 2048  3.0570  310.57  343.67  327.12  343.67  343.67  343.67  343.67  ±64.30%        2
-   · duckdb appender file, count: 100000, chunk size 2048    2.6163  377.75  386.70  382.22  386.70  386.70  386.70  386.70  ±14.88%        2
-   · duckdb appender, count: 100000, chunk size 1024         3.0427  319.38  337.93  328.65  337.93  337.93  337.93  337.93  ±35.86%        2
+ ✓ bench/appender.bench.ts > appender benches 4421ms
+     name                                                             hz     min     max    mean     p75     p99    p995    p999      rme  samples
+   · duckdb appender memory, count: 100000, chunk size 2048       3.6500  271.84  276.10  273.97  276.10  276.10  276.10  276.10   ±9.88%        2
+   · duckdb appender file, count: 100000, chunk size 2048         3.6469  272.29  276.12  274.21  276.12  276.12  276.12  276.12   ±8.88%        2
+   · duckdb appender file no wal, count: 100000, chunk size 2048  3.6858  271.23  271.39  271.31  271.39  271.39  271.39  271.39   ±0.36%        2
+   · duckdb appender file no wal, count: 100000, chunk size 1024  3.8828  245.82  269.28  257.55  269.28  269.28  269.28  269.28  ±57.90%        2
+   · duckdb appender, count: 100000, chunk size 1024              4.3164  228.90  233.35  231.68  233.35  233.35  233.35  233.35   ±2.60%        3
 
- ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 3075ms
-     name                                                                         hz      min      max     mean      p75      p99     p995     p999     rme  samples
-   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   12.5039  68.9091  89.8222  79.9751  84.4430  89.8222  89.8222  89.8222  ±5.45%       10
-   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  10.9097  83.6090   124.66  91.6616  92.3154   124.66   124.66   124.66  ±9.42%       10
-   · mapFakeRowStream with chunkSize 2048 (count: 100000)                    10.2729  90.7410   104.18  97.3436   100.41   104.18   104.18   104.18  ±2.93%       10
+ ✓ bench/stream.bench.ts > Bench rowsToColumnsChunks 1944ms
+     name                                                                         hz      min      max     mean      p75      p99     p995     p999      rme  samples
+   · rowToColumnsChunk with chunkSize 2048 (count: 100000)                   23.3620  34.5897  57.6520  42.8045  46.5939  57.6520  57.6520  57.6520   ±9.96%       12
+   · rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)  19.9773  38.8665  71.6678  50.0569  51.5838  71.6678  71.6678  71.6678  ±14.39%       10
+   · mapFakeRowStream with chunkSize 2048 (count: 100000)                    19.0996  45.5100  66.2385  52.3572  53.0091  66.2385  66.2385  66.2385   ±7.43%       10
 
- ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 629ms
+ ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 634ms
      name                          hz     min     max    mean     p75     p99    p995    p999     rme  samples
-   · getTableCreateFromZod  20,285.23  0.0260  6.9886  0.0493  0.0466  0.1700  0.2249  2.6988  ±6.12%    10143
+   · getTableCreateFromZod  30,647.46  0.0177  4.5320  0.0326  0.0335  0.1058  0.1550  0.7740  ±4.73%    15324
 
  BENCH  Summary
 
   rowToColumnsChunk with chunkSize 2048 (count: 100000) - bench/stream.bench.ts > Bench rowsToColumnsChunks
-    1.15x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
+    1.17x faster than rowToColumnsChunk with transformer with chunkSize 2048 (count: 100000)
     1.22x faster than mapFakeRowStream with chunkSize 2048 (count: 100000)
 
-  getTableCreateFromZod - bench/table-create.bench.ts > Bench getTableCreateFromZod
+  duckdb appender, count: 100000, chunk size 1024 - bench/appender.bench.ts > appender benches
+    1.11x faster than duckdb appender file no wal, count: 100000, chunk size 1024
+    1.17x faster than duckdb appender file no wal, count: 100000, chunk size 2048
+    1.18x faster than duckdb appender memory, count: 100000, chunk size 2048
+    1.18x faster than duckdb appender file, count: 100000, chunk size 2048
 
-  duckdb appender memory, count: 100000, chunk size 2048 - bench/appender.bench.ts > appender benches
-    1.00x faster than duckdb appender, count: 100000, chunk size 1024
-    1.17x faster than duckdb appender file, count: 100000, chunk size 2048
 ```
 
 ### Local scripts

package/dist/{index-CvC0hHHa.d.mts → index-BKsJVkXZ.d.mts}

@@ -254,4 +254,8 @@ type MapRelaxedZodSchemaField<T extends z.ZodTypeAny> = T extends z.ZodDate ? st
  */
 type InferZodRelaxedDataSchema<T extends z.ZodObject<any>> = { [K in keyof T['shape']]: MapRelaxedZodSchemaField<T['shape'][K]>; };
 //#endregion
-export { assertValidAliasName as a, DuckConnectionParams as c, duckDsnZodSchema as i, duckAllConnectionOptionsZodSchema as l, ensureZodTableSchema as n, assertValidSchemaName as o, duckValidatorsZod as r, assertValidTableName as s, InferZodRelaxedDataSchema as t, duckConnectionParamsZodSchema as u };
+//#region src/validation/zod/table-schema-zod.d.ts
+type ZodSchemaSupportedTypes = z.ZodString | z.ZodNumber | z.ZodInt | z.ZodInt32 | z.ZodUInt32 | z.ZodBigInt | z.ZodBoolean | z.ZodDate | z.ZodISODateTime | z.ZodISOTime | z.ZodISODate | z.ZodEmail | z.ZodURL | z.ZodUUID | z.ZodCUID | z.ZodCUID2 | z.ZodULID | z.ZodEnum;
+type TableSchemaZod = z.ZodObject<Record<string, ZodSchemaSupportedTypes | z.ZodNullable<ZodSchemaSupportedTypes> | z.ZodCodec | z.ZodNullable<z.ZodCodec>>>;
+//#endregion
+export { duckDsnZodSchema as a, assertValidTableName as c, duckConnectionParamsZodSchema as d, duckValidatorsZod as i, DuckConnectionParams as l, InferZodRelaxedDataSchema as n, assertValidAliasName as o, ensureZodTableSchema as r, assertValidSchemaName as s, TableSchemaZod as t, duckAllConnectionOptionsZodSchema as u };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { c as DuckConnectionParams, t as InferZodRelaxedDataSchema } from "./index-CvC0hHHa.mjs";
+import { l as DuckConnectionParams, n as InferZodRelaxedDataSchema, t as TableSchemaZod } from "./index-BKsJVkXZ.mjs";
 import { DuckDBConnection, DuckDBType } from "@duckdb/node-api";
 import { Logger } from "@logtape/logtape";
 import * as z from "zod";
@@ -77,10 +77,6 @@ declare class Table {
   withSchema: (schema: string) => Table;
 }
 //#endregion
-//#region src/table/table-schema-zod.type.d.ts
-type ZodSchemaSupportedTypes = z.ZodString | z.ZodNumber | z.ZodInt | z.ZodInt32 | z.ZodUInt32 | z.ZodBigInt | z.ZodBoolean | z.ZodDate | z.ZodISODateTime | z.ZodISOTime | z.ZodISODate | z.ZodEmail | z.ZodURL | z.ZodUUID | z.ZodCUID | z.ZodCUID2 | z.ZodULID | z.ZodEnum;
-type TableSchemaZod = z.ZodObject<Record<string, ZodSchemaSupportedTypes | z.ZodNullable<ZodSchemaSupportedTypes> | z.ZodCodec | z.ZodNullable<z.ZodCodec>>>;
-//#endregion
 //#region src/table/get-table-create-from-zod.d.ts
 type TableCreateOptions = {
   create?: 'CREATE' | 'CREATE_OR_REPLACE' | 'IF_NOT_EXISTS';
@@ -278,14 +274,23 @@ declare const duckDatabaseManagerZodSchemas: {
   }, z.core.$strict>;
 };
 //#endregion
-//#region src/manager/database/commands/duck-database-attach-command.d.ts
-type Behaviour = 'OR REPLACE' | 'IF NOT EXISTS';
-type DuckDatabaseAttachCommandOptions = {
-  behaviour?: Behaviour;
-};
-//#endregion
 //#region src/manager/database/duck-database-manager.d.ts
 type GetDatabaseInfo = z.infer<typeof duckDatabaseManagerZodSchemas.getDatabases>;
+type AttachOptions = {
+  behaviour: 'OR REPLACE';
+  /**
+   * Since duckdb 1.5.4, the ATTACH OR REPLACE fails if the database is already attached.
+   * If this option is set to true, when an attachOrReplace fails with the already attached
+   * message, the database will be detached first with regular detach command an re-tried
+   *
+   * This option might be deprecated in the future as duckdb will fix the issue upstream
+   *
+   * @default false
+   */
+  runDetachIfAttachOrReplaceFailWithAlreadyAttached?: boolean;
+} | {
+  behaviour: 'IF NOT EXISTS';
+};
 declare class DuckDatabaseManager {
   #private;
   readonly className = "DuckDatabaseManager";
@@ -307,8 +312,39 @@ declare class DuckDatabaseManager {
    * console.log(database.alias); // 'mydb'
    * ```
    */
-  attach: (dbParams: DuckConnectionParams, options?: DuckDatabaseAttachCommandOptions) => Promise<Database>;
-  attachOrReplace: (dbParams: DuckConnectionParams) => Promise<Database>;
+  attach: (dbParams: DuckConnectionParams, options?: AttachOptions) => Promise<Database>;
+  /**
+   * Attach or replace a database to the current connection
+   *
+   * @example
+   * ```typescript
+   * const dbManager = new DuckDatabaseManager(conn);
+   * const database = dbManager.attachOrReplace({
+   *   type: 'memory', // can be 'filesystem'...
+   *   alias: 'mydb',
+   *   options: { COMPRESS: 'true' },
+   * }, {
+   *   // as tested on duckdb 1.5.5, the attach or replace might not work
+   *   // and complain about already attached database. Set this to true
+   *   // to implement a detach / attach if the attachOrReplace fails
+   *   runDetachIfAttachOrReplaceFailWithAlreadyAttached?: boolean;
+   * });
+   *
+   * console.log(database.alias); // 'mydb'
+   * ```
+   */
+  attachOrReplace: (dbParams: DuckConnectionParams, options?: {
+    /**
+     * Since duckdb 1.5.4, the ATTACH OR REPLACE fails if the database is already attached.
+     * If this option is set to true, when an attachOrReplace fails with the already attached
+     * message, the database will be detached first with regular detach command an re-tried
+     *
+     * This option might be deprecated in the future as duckdb will fix the issue upstream
+     *
+     * @default false
+     */
+    runDetachIfAttachOrReplaceFailWithAlreadyAttached?: boolean;
+  }) => Promise<Database>;
   attachIfNotExists: (dbParams: DuckConnectionParams) => Promise<Database>;
   /**
    * Check whether a specific database name / alias is currently attached

package/dist/index.mjs

@@ -379,6 +379,23 @@ var DuckDatabaseAttachCommand = class {
 	};
 };
 //#endregion
+//#region src/manager/database/utils/get-already-attached-database-from-error.ts
+/**
+* Return the database name that is already attached to the error message
+*
+* Note duckdb might complain about already attached databases with a message like
+* Binder Error: Unique file handle conflict: Cannot attach "duckdb_second_attached_file" - the database file "/home/sebastien/github/flowblade/packages/sqlduck/tests/tmp/duckdb_test_reattachable_file.db" is already attached by database "duckdb_first_attached_file"
+*/
+const getAlreadyAttachedDatabaseFromError = (error) => {
+	if (!(error instanceof Error)) return { isAlreadyAttached: false };
+	const dbAlias = /Binder Error:.*Cannot attach.*already attached by database\s+['"“]?\b(?<dbAlias>[\w$]+)\b['"”]?/is.exec(error.message)?.groups?.dbAlias ?? null;
+	if (dbAlias === null || dbAlias.trim() === "") return { isAlreadyAttached: false };
+	return {
+		isAlreadyAttached: true,
+		dbAlias
+	};
+};
+//#endregion
 //#region src/manager/database/duck-database-manager.ts
 var DuckDatabaseManager = class {
 	#conn;
@@ -410,15 +427,48 @@ var DuckDatabaseManager = class {
 		const params = duckConnectionParamsZodSchema.parse(dbParams);
 		const rawSql = new DuckDatabaseAttachCommand(params, options).getRawSql();
 		const { behaviour } = options ?? {};
-		await this.#executor.getRowObjectsJS([
-			`attach(${params.alias}`,
-			behaviour ?? null,
-			")"
-		].filter(Boolean).join(","), rawSql);
+		try {
+			await this.#executor.getRowObjectsJS([
+				`attach(${params.alias}`,
+				behaviour ?? null,
+				")"
+			].filter(Boolean).join(","), rawSql);
+		} catch (e) {
+			if (options?.behaviour === "OR REPLACE" && options?.runDetachIfAttachOrReplaceFailWithAlreadyAttached === true) {
+				const alreadyAttached = getAlreadyAttachedDatabaseFromError(e);
+				if (alreadyAttached.isAlreadyAttached === true) {
+					await this.detachOrIgnore(alreadyAttached.dbAlias);
+					await this.attach(dbParams);
+				} else throw e;
+			} else throw e;
+		}
 		return new Database({ alias: params.alias });
 	};
-	attachOrReplace = async (dbParams) => {
-		return this.attach(dbParams, { behaviour: "OR REPLACE" });
+	/**
+	* Attach or replace a database to the current connection
+	*
+	* @example
+	* ```typescript
+	* const dbManager = new DuckDatabaseManager(conn);
+	* const database = dbManager.attachOrReplace({
+	*   type: 'memory', // can be 'filesystem'...
+	*   alias: 'mydb',
+	*   options: { COMPRESS: 'true' },
+	* }, {
+	*   // as tested on duckdb 1.5.5, the attach or replace might not work
+	*   // and complain about already attached database. Set this to true
+	*   // to implement a detach / attach if the attachOrReplace fails
+	*   runDetachIfAttachOrReplaceFailWithAlreadyAttached?: boolean;
+	* });
+	*
+	* console.log(database.alias); // 'mydb'
+	* ```
+	*/
+	attachOrReplace = async (dbParams, options) => {
+		return this.attach(dbParams, {
+			behaviour: "OR REPLACE",
+			runDetachIfAttachOrReplaceFailWithAlreadyAttached: options?.runDetachIfAttachOrReplaceFailWithAlreadyAttached
+		});
 	};
 	attachIfNotExists = async (dbParams) => {
 		return this.attach(dbParams, { behaviour: "IF NOT EXISTS" });

package/dist/validation/zod/index.d.mts

@@ -1,2 +1,2 @@
-import { a as assertValidAliasName, i as duckDsnZodSchema, l as duckAllConnectionOptionsZodSchema, n as ensureZodTableSchema, o as assertValidSchemaName, r as duckValidatorsZod, s as assertValidTableName, t as InferZodRelaxedDataSchema, u as duckConnectionParamsZodSchema } from "../../index-CvC0hHHa.mjs";
-export { type InferZodRelaxedDataSchema, assertValidAliasName, assertValidSchemaName, assertValidTableName, duckAllConnectionOptionsZodSchema, duckConnectionParamsZodSchema, duckDsnZodSchema, duckValidatorsZod, ensureZodTableSchema };
+import { a as duckDsnZodSchema, c as assertValidTableName, d as duckConnectionParamsZodSchema, i as duckValidatorsZod, n as InferZodRelaxedDataSchema, o as assertValidAliasName, r as ensureZodTableSchema, s as assertValidSchemaName, t as TableSchemaZod, u as duckAllConnectionOptionsZodSchema } from "../../index-BKsJVkXZ.mjs";
+export { type InferZodRelaxedDataSchema, type TableSchemaZod, assertValidAliasName, assertValidSchemaName, assertValidTableName, duckAllConnectionOptionsZodSchema, duckConnectionParamsZodSchema, duckDsnZodSchema, duckValidatorsZod, ensureZodTableSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowblade/sqlduck",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -67,12 +67,12 @@
   },
   "dependencies": {
     "@flowblade/core": "^0.2.29",
-    "@flowblade/source-duckdb": "^0.26.0",
+    "@flowblade/source-duckdb": "^0.27.0",
     "@flowblade/sql-tag": "^0.3.4",
-    "@httpx/assert": "^0.17.2",
-    "@httpx/dsn-parser": "^1.9.12",
-    "@httpx/plain-object": "^2.1.12",
-    "@logtape/logtape": "^2.2.4",
+    "@httpx/assert": "^0.18.0",
+    "@httpx/dsn-parser": "^1.10.0",
+    "@httpx/plain-object": "^2.2.0",
+    "@logtape/logtape": "^2.3.1",
     "@standard-schema/spec": "^1.1.0",
     "is-safe-filename": "0.1.1",
     "p-queue": "^9.3.3",
@@ -92,47 +92,47 @@
     }
   },
   "devDependencies": {
-    "@belgattitude/eslint-config-bases": "8.19.0",
-    "@dotenvx/dotenvx": "2.19.0",
-    "@duckdb/node-api": "1.5.5-r.2",
+    "@belgattitude/eslint-config-bases": "8.19.1",
+    "@dotenvx/dotenvx": "2.21.0",
+    "@duckdb/node-api": "1.5.5-r.4",
     "@faker-js/faker": "10.5.0",
-    "@flowblade/source-kysely": "^1.6.2",
-    "@httpx/assert": "0.17.2",
+    "@flowblade/source-kysely": "^1.7.0",
+    "@httpx/assert": "0.18.0",
     "@mitata/counters": "0.0.8",
-    "@size-limit/esbuild": "13.0.1",
-    "@size-limit/file": "13.0.1",
-    "@testcontainers/mssqlserver": "12.0.4",
+    "@size-limit/esbuild": "13.0.3",
+    "@size-limit/file": "13.0.3",
+    "@testcontainers/mssqlserver": "12.1.0",
     "@total-typescript/ts-reset": "0.6.1",
-    "@types/node": "26.1.1",
-    "@typescript-eslint/eslint-plugin": "8.65.0",
-    "@typescript-eslint/parser": "8.65.0",
+    "@types/node": "26.2.0",
+    "@typescript-eslint/eslint-plugin": "8.67.0",
+    "@typescript-eslint/parser": "8.67.0",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "@vitest/coverage-v8": "4.1.10",
     "@vitest/ui": "4.1.10",
     "ansis": "4.3.1",
     "browserslist-to-esbuild": "2.1.1",
-    "core-js": "3.49.0",
+    "core-js": "3.50.0",
     "cross-env": "10.1.0",
     "es-check": "9.6.4",
     "es-toolkit": "1.50.0",
-    "esbuild": "0.28.1",
+    "esbuild": "0.28.2",
     "eslint": "8.57.1",
-    "execa": "10.0.0",
+    "execa": "10.0.1",
     "is-in-ci": "2.0.0",
-    "kysely": "0.29.4",
+    "kysely": "0.29.5",
     "mitata": "1.0.34",
-    "npm-run-all2": "9.0.2",
+    "npm-run-all2": "9.0.3",
     "prettier": "3.9.6",
-    "publint": "0.3.22",
+    "publint": "0.3.23",
     "regexp.escape": "2.0.1",
     "rimraf": "6.1.3",
-    "size-limit": "13.0.1",
+    "size-limit": "13.0.3",
     "sql-formatter": "15.8.2",
     "tarn": "3.1.2",
     "tedious": "20.0.0",
-    "testcontainers": "12.0.4",
+    "testcontainers": "12.1.0",
     "tsdown": "0.22.14",
-    "tsx": "4.23.1",
+    "tsx": "4.23.12",
     "typedoc": "0.28.20",
     "typedoc-plugin-markdown": "4.12.0",
     "typescript": "6.0.3",