@flowblade/sqlduck 0.8.3 → 0.9.0

package/README.md

@@ -54,6 +54,72 @@ const queryResult = await dbDuckDbMemoryConn.query<{
 `);
 ```
 
+## Benchmarks
+
+### Node 24
+
+```
+ RUN  v4.1.1 /home/sebastien/github/flowblade/packages/sqlduck
+
+
+ ✓ bench/appender.bench.ts > appender benches 66030ms
+     name                                                  hz        min        max       mean        p75        p99       p995       p999     rme  samples
+   · duckdb appender, count: 1000000, chunk size 2048  0.0642  15,577.01  15,577.01  15,577.01  15,577.01  15,577.01  15,577.01  15,577.01  ±0.00%        1
+   · duckdb appender, count: 1000000, chunk size 1024  0.0579  17,263.44  17,263.44  17,263.44  17,263.44  17,263.44  17,263.44  17,263.44  ±0.00%        1
+
+ ✓ bench/stream.bench.ts > Bench stream 22923ms
+     name                                                        hz       min       max      mean       p75       p99      p995      p999     rme  samples
+   · rowToColumnsChunk with chunkSize 2048 (count: 1000000)  1.2126    742.59    906.65    824.67    863.91    906.65    906.65    906.65  ±4.26%       10
+   · mapFakeRowStream with chunkSize 2048 (count: 1000000)   0.8049  1,123.18  1,498.68  1,242.43  1,257.91  1,498.68  1,498.68  1,498.68  ±6.40%       10
+
+ ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 615ms
+     name                          hz     min     max    mean     p75     p99    p995    p999     rme  samples
+   · getTableCreateFromZod  16,562.93  0.0242  2.5902  0.0604  0.0734  0.2555  0.3741  0.8135  ±2.32%     8282
+
+ BENCH  Summary
+
+  duckdb appender, count: 1000000, chunk size 2048 - bench/appender.bench.ts > appender benches
+    1.11x faster than duckdb appender, count: 1000000, chunk size 1024
+
+  rowToColumnsChunk with chunkSize 2048 (count: 1000000) - bench/stream.bench.ts > Bench stream
+    1.51x faster than mapFakeRowStream with chunkSize 2048 (count: 1000000)
+
+  getTableCreateFromZod - bench/table-create.bench.ts > Bench getTableCreateFromZod
+
+```
+
+### Bun 1.3.11
+
+```
+ RUN  v4.1.1 /home/sebastien/github/flowblade/packages/sqlduck
+
+
+ ✓ bench/appender.bench.ts > appender benches 36627ms
+     name                                                  hz       min       max      mean       p75       p99      p995      p999     rme  samples
+   · duckdb appender, count: 1000000, chunk size 2048  0.1177  8,495.41  8,495.41  8,495.41  8,495.41  8,495.41  8,495.41  8,495.41  ±0.00%        1
+   · duckdb appender, count: 1000000, chunk size 1024  0.1064  9,397.97  9,397.97  9,397.97  9,397.97  9,397.97  9,397.97  9,397.97  ±0.00%        1
+
+ ✓ bench/stream.bench.ts > Bench stream 23421ms
+     name                                                        hz       min       max      mean       p75       p99      p995      p999     rme  samples
+   · rowToColumnsChunk with chunkSize 2048 (count: 1000000)  1.1378    801.60  1,080.22    878.91    910.91  1,080.22  1,080.22  1,080.22  ±6.85%       10
+   · mapFakeRowStream with chunkSize 2048 (count: 1000000)   0.8118  1,130.36  1,448.99  1,231.78  1,268.45  1,448.99  1,448.99  1,448.99  ±5.34%       10
+
+ ✓ bench/table-create.bench.ts > Bench getTableCreateFromZod 622ms
+     name                          hz     min     max    mean     p75     p99    p995    p999     rme  samples
+   · getTableCreateFromZod  22,447.94  0.0210  5.4621  0.0445  0.0442  0.1657  0.2167  2.5852  ±5.37%    11224
+
+ BENCH  Summary
+
+  rowToColumnsChunk with chunkSize 2048 (count: 1000000) - bench/stream.bench.ts > Bench stream
+    1.40x faster than mapFakeRowStream with chunkSize 2048 (count: 1000000)
+
+  getTableCreateFromZod - bench/table-create.bench.ts > Bench getTableCreateFromZod
+
+  duckdb appender, count: 1000000, chunk size 2048 - bench/appender.bench.ts > appender benches
+    1.11x faster than duckdb appender, count: 1000000, chunk size 1024
+
+```
+
 ### Local scripts
 
 | Name              | Description                    |

package/dist/index.cjs

@@ -141,21 +141,52 @@ const createOnDataAppendedCollector = () => {
 	};
 };
 //#endregion
+//#region src/table/get-duckdb-number-column-type.ts
+const isFloatValue = (value) => {
+	if (!Number.isFinite(value)) return true;
+	if (Math.abs(value) > Number.MAX_SAFE_INTEGER) return true;
+	return !Number.isInteger(value);
+};
+const getDuckdbNumberColumnType = (params) => {
+	const { minimum, maximum } = params;
+	if (minimum === void 0 || maximum === void 0) return _duckdb_node_api.BIGINT;
+	if (isFloatValue(minimum) || isFloatValue(maximum)) {
+		if (minimum >= -34028235e31 && maximum <= 34028235e31) return _duckdb_node_api.FLOAT;
+		return _duckdb_node_api.DOUBLE;
+	}
+	if (minimum >= 0) {
+		if (maximum <= 255) return _duckdb_node_api.UTINYINT;
+		if (maximum <= 65535) return _duckdb_node_api.USMALLINT;
+		if (maximum <= 4294967295) return _duckdb_node_api.UINTEGER;
+		if (maximum <= 18446744073709551615n) return _duckdb_node_api.UBIGINT;
+		return _duckdb_node_api.UHUGEINT;
+	}
+	if (minimum >= -128 && maximum <= 127) return _duckdb_node_api.TINYINT;
+	if (minimum >= -32768 && maximum <= 32767) return _duckdb_node_api.SMALLINT;
+	if (minimum >= -2147483648 && maximum <= 2147483647) return _duckdb_node_api.INTEGER;
+	if (minimum >= -9223372036854775808n && maximum <= 9223372036854775807n) return _duckdb_node_api.BIGINT;
+	return _duckdb_node_api.HUGEINT;
+};
+//#endregion
 //#region src/table/get-table-create-from-zod.ts
-const createMap = {
+const createOptions = {
 	CREATE: "CREATE TABLE",
 	CREATE_OR_REPLACE: "CREATE OR REPLACE TABLE",
 	IF_NOT_EXISTS: "CREATE TABLE IF NOT EXISTS"
 };
-const getTableCreateFromZod = (table, schema, options) => {
+const getTableCreateFromZod = (params) => {
+	const { table, schema, options } = params;
 	const { create = "CREATE" } = options ?? {};
 	const fqTable = table.getFullName();
-	const json = schema.toJSONSchema({ target: "openapi-3.0" });
+	const json = schema.toJSONSchema({
+		target: "openapi-3.0",
+		unrepresentable: "throw"
+	});
 	const columns = [];
 	if (json.properties === void 0) throw new TypeError("Schema must have at least one property");
-	const columnTypes = [];
+	const columnTypesMap = /* @__PURE__ */ new Map();
 	for (const [columnName, def] of Object.entries(json.properties)) {
-		const { type, nullable, format, primaryKey } = def;
+		const { type, nullable, format, primaryKey, minimum, maximum } = def;
 		const c = { name: columnName };
 		switch (type) {
 			case "string":
@@ -166,22 +197,37 @@ const getTableCreateFromZod = (table, schema, options) => {
 					case "int64":
 						c.duckdbType = _duckdb_node_api.BIGINT;
 						break;
+					case "uuid":
+						c.duckdbType = _duckdb_node_api.UUID;
+						break;
 					default: c.duckdbType = _duckdb_node_api.VARCHAR;
 				}
 				break;
 			case "number":
-				c.duckdbType = _duckdb_node_api.INTEGER;
+				c.duckdbType = getDuckdbNumberColumnType({
+					minimum,
+					maximum
+				});
 				break;
-			default: throw new Error("Not a supported type");
+			case "integer":
+				c.duckdbType = getDuckdbNumberColumnType({
+					minimum,
+					maximum
+				});
+				break;
+			case "boolean":
+				c.duckdbType = _duckdb_node_api.BOOLEAN;
+				break;
+			default: throw new Error(`Cannot guess '${columnName}' type - ${JSON.stringify(def)}`);
 		}
 		if (primaryKey === true) c.constraint = "PRIMARY KEY";
 		else if (nullable !== true) c.constraint = "NOT NULL";
-		columnTypes.push([columnName, c.duckdbType]);
+		columnTypesMap.set(columnName, c.duckdbType);
 		columns.push(c);
 	}
 	return {
 		ddl: [
-			`${createMap[create]} ${fqTable} (\n`,
+			`${createOptions[create]} ${fqTable} (\n`,
 			columns.map((colDDL) => {
 				const { name, duckdbType, constraint } = colDDL;
 				return `  ${[
@@ -192,14 +238,18 @@ const getTableCreateFromZod = (table, schema, options) => {
 			}).join(",\n"),
 			"\n)"
 		].join(""),
-		columnTypes
+		columnTypes: columnTypesMap
 	};
 };
 //#endregion
 //#region src/table/create-table-from-zod.ts
 const createTableFromZod = async (params) => {
 	const { conn, table, schema, options } = params;
-	const { ddl, columnTypes } = getTableCreateFromZod(table, schema, options);
+	const { ddl, columnTypes } = getTableCreateFromZod({
+		table,
+		schema,
+		options
+	});
 	try {
 		await conn.run(ddl);
 	} catch (e) {
@@ -214,6 +264,7 @@ const createTableFromZod = async (params) => {
 //#region src/utils/rows-to-columns-chunks.ts
 const toDuckValue = (value) => {
 	if (value instanceof Date) return new _duckdb_node_api.DuckDBTimestampValue(BigInt(value.getTime() * 1e3));
+	if (typeof value === "bigint") return value.toString(10);
 	return value === void 0 ? null : value;
 };
 /**
@@ -225,7 +276,8 @@ const toDuckValue = (value) => {
 *   input rows: [{id:'1',name:'A'}, {id:'2',name:'B'}, {id:'3',name:'C'}]
 *   yields: [[['1','2'], ['A','B']], [['3'], ['C']]]
 */
-async function* rowsToColumnsChunks(rows, chunkSize) {
+async function* rowsToColumnsChunks(params) {
+	const { rows, chunkSize } = params;
 	if (!Number.isSafeInteger(chunkSize) || chunkSize <= 0) throw new Error(`chunkSize must be a positive integer, got ${chunkSize}`);
 	const first = await rows.next();
 	if (first.done) return;
@@ -262,7 +314,6 @@ var SqlDuck = class {
 	/**
 	* Create a table from a Zod schema and fill it with data from a row stream.
 	*
-	*
 	* @example
 	* ```typescript
 	* import * as z from 'zod';
@@ -308,10 +359,13 @@ var SqlDuck = class {
 			options: createOptions
 		});
 		const appender = await this.#duck.createAppender(table.tableName, table.schemaName, table.databaseName);
-		const chunkTypes = columnTypes.map((v) => v[1]);
+		const chunkTypes = Array.from(columnTypes.values());
 		let totalRows = 0;
 		const dataAppendedCollector = createOnDataAppendedCollector();
-		const columnStream = rowsToColumnsChunks(rowStream, chunkSize);
+		const columnStream = rowsToColumnsChunks({
+			rows: rowStream,
+			chunkSize
+		});
 		for await (const dataChunk of columnStream) {
 			const chunk = _duckdb_node_api.DuckDBDataChunk.create(chunkTypes);
 			if (this.#logger) this.#logger(`Inserting chunk of ${dataChunk.length} rows`);
@@ -325,6 +379,7 @@ var SqlDuck = class {
 				else onDataAppended(payload);
 			}
 		}
+		appender.closeSync();
 		return {
 			timeMs: Math.round(Date.now() - timeStart),
 			totalRows,

package/dist/index.d.cts

@@ -76,17 +76,25 @@ 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;
+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';
 };
-declare const getTableCreateFromZod: <T extends ZodObject>(table: Table, schema: T, options?: TableCreateOptions) => {
+type DuckdbColumnTypeMap<TKeys extends string> = Map<TKeys, DuckDBType>;
+type TableCreateFromZodResult<TSchema extends TableSchemaZod> = {
   ddl: string;
-  columnTypes: [name: string, type: DuckDBType][];
+  columnTypes: DuckdbColumnTypeMap<Exclude<keyof TSchema['shape'], symbol | number>>;
 };
-//#endregion
-//#region src/table/table-schema-zod.type.d.ts
-type TableSchemaZod = ZodObject;
+type GetTableCreateFromZodParams<TSchema extends TableSchemaZod> = {
+  table: Table;
+  schema: TSchema;
+  options?: TableCreateOptions;
+};
+declare const getTableCreateFromZod: <TSchema extends TableSchemaZod>(params: GetTableCreateFromZodParams<TSchema>) => TableCreateFromZodResult<TSchema>;
 //#endregion
 //#region src/sql-duck.d.ts
 type SqlDuckParams = {
@@ -142,7 +150,6 @@ declare class SqlDuck {
   /**
    * Create a table from a Zod schema and fill it with data from a row stream.
    *
-   *
    * @example
    * ```typescript
    * import * as z from 'zod';

package/dist/index.d.mts

@@ -76,17 +76,25 @@ 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;
+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';
 };
-declare const getTableCreateFromZod: <T extends ZodObject>(table: Table, schema: T, options?: TableCreateOptions) => {
+type DuckdbColumnTypeMap<TKeys extends string> = Map<TKeys, DuckDBType>;
+type TableCreateFromZodResult<TSchema extends TableSchemaZod> = {
   ddl: string;
-  columnTypes: [name: string, type: DuckDBType][];
+  columnTypes: DuckdbColumnTypeMap<Exclude<keyof TSchema['shape'], symbol | number>>;
 };
-//#endregion
-//#region src/table/table-schema-zod.type.d.ts
-type TableSchemaZod = ZodObject;
+type GetTableCreateFromZodParams<TSchema extends TableSchemaZod> = {
+  table: Table;
+  schema: TSchema;
+  options?: TableCreateOptions;
+};
+declare const getTableCreateFromZod: <TSchema extends TableSchemaZod>(params: GetTableCreateFromZodParams<TSchema>) => TableCreateFromZodResult<TSchema>;
 //#endregion
 //#region src/sql-duck.d.ts
 type SqlDuckParams = {
@@ -142,7 +150,6 @@ declare class SqlDuck {
   /**
    * Create a table from a Zod schema and fill it with data from a row stream.
    *
-   *
    * @example
    * ```typescript
    * import * as z from 'zod';

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { BIGINT, DuckDBDataChunk, DuckDBTimestampValue, INTEGER, TIMESTAMP, VARCHAR } from "@duckdb/node-api";
+import { BIGINT, BOOLEAN, DOUBLE, DuckDBDataChunk, DuckDBTimestampValue, FLOAT, HUGEINT, INTEGER, SMALLINT, TIMESTAMP, TINYINT, UBIGINT, UHUGEINT, UINTEGER, USMALLINT, UTINYINT, UUID, VARCHAR } from "@duckdb/node-api";
 import * as z from "zod";
 //#region src/helpers/duck-exec.ts
 var DuckExec = class {
@@ -117,21 +117,52 @@ const createOnDataAppendedCollector = () => {
 	};
 };
 //#endregion
+//#region src/table/get-duckdb-number-column-type.ts
+const isFloatValue = (value) => {
+	if (!Number.isFinite(value)) return true;
+	if (Math.abs(value) > Number.MAX_SAFE_INTEGER) return true;
+	return !Number.isInteger(value);
+};
+const getDuckdbNumberColumnType = (params) => {
+	const { minimum, maximum } = params;
+	if (minimum === void 0 || maximum === void 0) return BIGINT;
+	if (isFloatValue(minimum) || isFloatValue(maximum)) {
+		if (minimum >= -34028235e31 && maximum <= 34028235e31) return FLOAT;
+		return DOUBLE;
+	}
+	if (minimum >= 0) {
+		if (maximum <= 255) return UTINYINT;
+		if (maximum <= 65535) return USMALLINT;
+		if (maximum <= 4294967295) return UINTEGER;
+		if (maximum <= 18446744073709551615n) return UBIGINT;
+		return UHUGEINT;
+	}
+	if (minimum >= -128 && maximum <= 127) return TINYINT;
+	if (minimum >= -32768 && maximum <= 32767) return SMALLINT;
+	if (minimum >= -2147483648 && maximum <= 2147483647) return INTEGER;
+	if (minimum >= -9223372036854775808n && maximum <= 9223372036854775807n) return BIGINT;
+	return HUGEINT;
+};
+//#endregion
 //#region src/table/get-table-create-from-zod.ts
-const createMap = {
+const createOptions = {
 	CREATE: "CREATE TABLE",
 	CREATE_OR_REPLACE: "CREATE OR REPLACE TABLE",
 	IF_NOT_EXISTS: "CREATE TABLE IF NOT EXISTS"
 };
-const getTableCreateFromZod = (table, schema, options) => {
+const getTableCreateFromZod = (params) => {
+	const { table, schema, options } = params;
 	const { create = "CREATE" } = options ?? {};
 	const fqTable = table.getFullName();
-	const json = schema.toJSONSchema({ target: "openapi-3.0" });
+	const json = schema.toJSONSchema({
+		target: "openapi-3.0",
+		unrepresentable: "throw"
+	});
 	const columns = [];
 	if (json.properties === void 0) throw new TypeError("Schema must have at least one property");
-	const columnTypes = [];
+	const columnTypesMap = /* @__PURE__ */ new Map();
 	for (const [columnName, def] of Object.entries(json.properties)) {
-		const { type, nullable, format, primaryKey } = def;
+		const { type, nullable, format, primaryKey, minimum, maximum } = def;
 		const c = { name: columnName };
 		switch (type) {
 			case "string":
@@ -142,22 +173,37 @@ const getTableCreateFromZod = (table, schema, options) => {
 					case "int64":
 						c.duckdbType = BIGINT;
 						break;
+					case "uuid":
+						c.duckdbType = UUID;
+						break;
 					default: c.duckdbType = VARCHAR;
 				}
 				break;
 			case "number":
-				c.duckdbType = INTEGER;
+				c.duckdbType = getDuckdbNumberColumnType({
+					minimum,
+					maximum
+				});
 				break;
-			default: throw new Error("Not a supported type");
+			case "integer":
+				c.duckdbType = getDuckdbNumberColumnType({
+					minimum,
+					maximum
+				});
+				break;
+			case "boolean":
+				c.duckdbType = BOOLEAN;
+				break;
+			default: throw new Error(`Cannot guess '${columnName}' type - ${JSON.stringify(def)}`);
 		}
 		if (primaryKey === true) c.constraint = "PRIMARY KEY";
 		else if (nullable !== true) c.constraint = "NOT NULL";
-		columnTypes.push([columnName, c.duckdbType]);
+		columnTypesMap.set(columnName, c.duckdbType);
 		columns.push(c);
 	}
 	return {
 		ddl: [
-			`${createMap[create]} ${fqTable} (\n`,
+			`${createOptions[create]} ${fqTable} (\n`,
 			columns.map((colDDL) => {
 				const { name, duckdbType, constraint } = colDDL;
 				return `  ${[
@@ -168,14 +214,18 @@ const getTableCreateFromZod = (table, schema, options) => {
 			}).join(",\n"),
 			"\n)"
 		].join(""),
-		columnTypes
+		columnTypes: columnTypesMap
 	};
 };
 //#endregion
 //#region src/table/create-table-from-zod.ts
 const createTableFromZod = async (params) => {
 	const { conn, table, schema, options } = params;
-	const { ddl, columnTypes } = getTableCreateFromZod(table, schema, options);
+	const { ddl, columnTypes } = getTableCreateFromZod({
+		table,
+		schema,
+		options
+	});
 	try {
 		await conn.run(ddl);
 	} catch (e) {
@@ -190,6 +240,7 @@ const createTableFromZod = async (params) => {
 //#region src/utils/rows-to-columns-chunks.ts
 const toDuckValue = (value) => {
 	if (value instanceof Date) return new DuckDBTimestampValue(BigInt(value.getTime() * 1e3));
+	if (typeof value === "bigint") return value.toString(10);
 	return value === void 0 ? null : value;
 };
 /**
@@ -201,7 +252,8 @@ const toDuckValue = (value) => {
 *   input rows: [{id:'1',name:'A'}, {id:'2',name:'B'}, {id:'3',name:'C'}]
 *   yields: [[['1','2'], ['A','B']], [['3'], ['C']]]
 */
-async function* rowsToColumnsChunks(rows, chunkSize) {
+async function* rowsToColumnsChunks(params) {
+	const { rows, chunkSize } = params;
 	if (!Number.isSafeInteger(chunkSize) || chunkSize <= 0) throw new Error(`chunkSize must be a positive integer, got ${chunkSize}`);
 	const first = await rows.next();
 	if (first.done) return;
@@ -238,7 +290,6 @@ var SqlDuck = class {
 	/**
 	* Create a table from a Zod schema and fill it with data from a row stream.
 	*
-	*
 	* @example
 	* ```typescript
 	* import * as z from 'zod';
@@ -284,10 +335,13 @@ var SqlDuck = class {
 			options: createOptions
 		});
 		const appender = await this.#duck.createAppender(table.tableName, table.schemaName, table.databaseName);
-		const chunkTypes = columnTypes.map((v) => v[1]);
+		const chunkTypes = Array.from(columnTypes.values());
 		let totalRows = 0;
 		const dataAppendedCollector = createOnDataAppendedCollector();
-		const columnStream = rowsToColumnsChunks(rowStream, chunkSize);
+		const columnStream = rowsToColumnsChunks({
+			rows: rowStream,
+			chunkSize
+		});
 		for await (const dataChunk of columnStream) {
 			const chunk = DuckDBDataChunk.create(chunkTypes);
 			if (this.#logger) this.#logger(`Inserting chunk of ${dataChunk.length} rows`);
@@ -301,6 +355,7 @@ var SqlDuck = class {
 				else onDataAppended(payload);
 			}
 		}
+		appender.closeSync();
 		return {
 			timeMs: Math.round(Date.now() - timeStart),
 			totalRows,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowblade/sqlduck",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -35,8 +35,8 @@
     "docgen-typedoc": "rimraf ./docs/api && typedoc --plugin typedoc-plugin-markdown --out ./docs/api",
     "bench": "vitest bench --run",
     "bench-bun": "bun --bun run vitest bench --run",
-    "bench-mitata": "node --experimental-strip-types --expose-gc ./bench/stream.mitata.ts ",
-    "bench-mitata-bun": "bun --expose-gc ./bench/stream.mitata.ts ",
+    "bench-mitata": "node --experimental-strip-types --expose-gc bench/run_mitata.ts",
+    "bench-mitata-bun": "bun --expose-gc bench/run_mitata.ts",
     "bench-codspeed": "cross-env CODSPEED=1 vitest bench --run",
     "bench-watch": "vitest bench",
     "test": "vitest run",