sqlite-zod-orm 3.25.0 → 3.26.0

package/dist/index.js

@@ -5221,7 +5221,7 @@ function createQueryBuilder(ctx, entityName, initialCols) {
   const schema = ctx.schemas[entityName];
   const executor = (sql, params, raw) => {
     return ctx._m(`SQL: ${sql.slice(0, 60)}`, () => {
-      const rows = ctx.db.query(sql).all(...params);
+      const rows = ctx._stmt(sql).all(...params);
       if (raw)
         return rows;
       return rows.map((row) => ctx.attachMethods(entityName, transformFromStorage(row, schema)));
@@ -5269,7 +5269,7 @@ function createQueryBuilder(ctx, entityName, initialCols) {
       if (belongsTo2) {
         const fk = belongsTo2.foreignKey;
         const placeholders = parentIds.map(() => "?").join(", ");
-        const childRows = ctx.db.query(`SELECT * FROM ${hasMany.to} WHERE ${fk} IN (${placeholders})`).all(...parentIds);
+        const childRows = ctx._stmt(`SELECT * FROM ${hasMany.to} WHERE ${fk} IN (${placeholders})`).all(...parentIds);
         const groups = new Map;
         const childSchema = ctx.schemas[hasMany.to];
         for (const rawRow of childRows) {
@@ -5381,21 +5381,21 @@ function buildWhereClause(conditions, tablePrefix) {
 
 // src/crud.ts
 function getById(ctx, entityName, id) {
-  const row = ctx.db.query(`SELECT * FROM "${entityName}" WHERE id = ?`).get(id);
+  const row = ctx._stmt(`SELECT * FROM "${entityName}" WHERE id = ?`).get(id);
   if (!row)
     return null;
   return ctx.attachMethods(entityName, transformFromStorage(row, ctx.schemas[entityName]));
 }
 function getOne(ctx, entityName, conditions) {
   const { clause, values } = ctx.buildWhereClause(conditions);
-  const row = ctx.db.query(`SELECT * FROM "${entityName}" ${clause} LIMIT 1`).get(...values);
+  const row = ctx._stmt(`SELECT * FROM "${entityName}" ${clause} LIMIT 1`).get(...values);
   if (!row)
     return null;
   return ctx.attachMethods(entityName, transformFromStorage(row, ctx.schemas[entityName]));
 }
 function findMany(ctx, entityName, conditions = {}) {
   const { clause, values } = ctx.buildWhereClause(conditions);
-  const rows = ctx.db.query(`SELECT * FROM "${entityName}" ${clause}`).all(...values);
+  const rows = ctx._stmt(`SELECT * FROM "${entityName}" ${clause}`).all(...values);
   return rows.map((row) => ctx.attachMethods(entityName, transformFromStorage(row, ctx.schemas[entityName])));
 }
 function insert(ctx, entityName, data) {
@@ -5419,7 +5419,7 @@ function insert(ctx, entityName, data) {
   const sql = columns.length === 0 ? `INSERT INTO "${entityName}" DEFAULT VALUES` : `INSERT INTO "${entityName}" (${quotedCols.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
   let lastId = 0;
   ctx._m(`SQL: ${sql.slice(0, 40)}`, () => {
-    const result = ctx.db.query(sql).run(...Object.values(transformed));
+    const result = ctx._stmt(sql).run(...Object.values(transformed));
     lastId = result.lastInsertRowid;
   });
   const newEntity = getById(ctx, entityName, lastId);
@@ -5448,7 +5448,7 @@ function update(ctx, entityName, id, data) {
   const setClause = Object.keys(transformed).map((key) => `"${key}" = ?`).join(", ");
   const sql = `UPDATE "${entityName}" SET ${setClause} WHERE id = ?`;
   ctx._m(`SQL: UPDATE ${entityName} SET ...`, () => {
-    ctx.db.query(sql).run(...Object.values(transformed), id);
+    ctx._stmt(sql).run(...Object.values(transformed), id);
   });
   const updated = getById(ctx, entityName, id);
   if (hooks?.afterUpdate && updated)
@@ -5466,7 +5466,7 @@ function updateWhere(ctx, entityName, data, conditions) {
     throw new Error("update().where() requires at least one condition");
   const setCols = Object.keys(transformed);
   const setClause = setCols.map((key) => `"${key}" = ?`).join(", ");
-  const result = ctx.db.query(`UPDATE "${entityName}" SET ${setClause} ${clause}`).run(...setCols.map((key) => transformed[key]), ...whereValues);
+  const result = ctx._stmt(`UPDATE "${entityName}" SET ${setClause} ${clause}`).run(...setCols.map((key) => transformed[key]), ...whereValues);
   return result.changes ?? 0;
 }
 function createUpdateBuilder(ctx, entityName, data) {
@@ -5507,7 +5507,7 @@ function deleteEntity(ctx, entityName, id) {
     if (result === false)
       return;
   }
-  ctx.db.query(`DELETE FROM "${entityName}" WHERE id = ?`).run(id);
+  ctx._stmt(`DELETE FROM "${entityName}" WHERE id = ?`).run(id);
   if (hooks?.afterDelete)
     hooks.afterDelete(id);
 }
@@ -5518,11 +5518,11 @@ function deleteWhere(ctx, entityName, conditions) {
   if (ctx.softDeletes) {
     const now = new Date().toISOString();
     const sql2 = `UPDATE "${entityName}" SET "deletedAt" = ? ${clause}`;
-    const result2 = ctx._m(`SQL: ${sql2.slice(0, 50)}`, () => ctx.db.query(sql2).run(now, ...values));
+    const result2 = ctx._m(`SQL: ${sql2.slice(0, 50)}`, () => ctx._stmt(sql2).run(now, ...values));
     return result2.changes ?? 0;
   }
   const sql = `DELETE FROM "${entityName}" ${clause}`;
-  const result = ctx._m(`SQL: ${sql.slice(0, 50)}`, () => ctx.db.query(sql).run(...values));
+  const result = ctx._m(`SQL: ${sql.slice(0, 50)}`, () => ctx._stmt(sql).run(...values));
   return result.changes ?? 0;
 }
 function createDeleteBuilder(ctx, entityName) {
@@ -5561,7 +5561,7 @@ function insertMany(ctx, entityName, rows) {
       const columns = Object.keys(transformed);
       const quotedCols = columns.map((c) => `"${c}"`);
       const sql = columns.length === 0 ? `INSERT INTO "${entityName}" DEFAULT VALUES` : `INSERT INTO "${entityName}" (${quotedCols.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
-      const result = ctx.db.query(sql).run(...Object.values(transformed));
+      const result = ctx._stmt(sql).run(...Object.values(transformed));
       ids2.push(result.lastInsertRowid);
     }
     return ids2;
@@ -5647,6 +5647,15 @@ class _Database {
   _pollTimer = null;
   _pollInterval;
   _measure;
+  _stmtCache = new Map;
+  _stmt(sql) {
+    let stmt = this._stmtCache.get(sql);
+    if (!stmt) {
+      stmt = this.db.query(sql);
+      this._stmtCache.set(sql, stmt);
+    }
+    return stmt;
+  }
   _m(label, fn) {
     if (this._debug)
       return this._measure.measureSync.assert(label, fn);
@@ -5678,7 +5687,8 @@ class _Database {
       hooks: options.hooks ?? {},
       computed: options.computed ?? {},
       cascade: options.cascade ?? {},
-      _m: (label, fn) => this._m(label, fn)
+      _m: (label, fn) => this._m(label, fn),
+      _stmt: (sql) => this._stmt(sql)
     };
     this._m("Init tables", () => this.initializeTables());
     if (this._reactive)
@@ -5717,16 +5727,16 @@ class _Database {
                   if (rel) {
                     if (this._softDeletes) {
                       const now = new Date().toISOString();
-                      this.db.query(`UPDATE "${childTable}" SET "deletedAt" = ? WHERE "${rel.foreignKey}" = ?`).run(now, id);
+                      this._stmt(`UPDATE "${childTable}" SET "deletedAt" = ? WHERE "${rel.foreignKey}" = ?`).run(now, id);
                     } else {
-                      this.db.query(`DELETE FROM "${childTable}" WHERE "${rel.foreignKey}" = ?`).run(id);
+                      this._stmt(`DELETE FROM "${childTable}" WHERE "${rel.foreignKey}" = ?`).run(id);
                     }
                   }
                 }
               }
               if (this._softDeletes) {
                 const now = new Date().toISOString();
-                this.db.query(`UPDATE "${entityName}" SET "deletedAt" = ? WHERE id = ?`).run(now, id);
+                this._stmt(`UPDATE "${entityName}" SET "deletedAt" = ? WHERE id = ?`).run(now, id);
                 if (hooks?.afterDelete)
                   hooks.afterDelete(id);
                 return;
@@ -5740,12 +5750,12 @@ class _Database {
           if (!this._softDeletes)
             throw new Error("restore() requires softDeletes: true");
           this._m(`${entityName}.restore(${id})`, () => {
-            this.db.query(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
+            this._stmt(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
           });
         },
         select: (...cols) => createQueryBuilder(this._ctx, entityName, cols),
         count: () => this._m(`${entityName}.count`, () => {
-          const row = this.db.query(`SELECT COUNT(*) as count FROM "${entityName}"${this._softDeletes ? ' WHERE "deletedAt" IS NULL' : ""}`).get();
+          const row = this._stmt(`SELECT COUNT(*) as count FROM "${entityName}"${this._softDeletes ? ' WHERE "deletedAt" IS NULL' : ""}`).get();
           return row?.count ?? 0;
         }),
         on: (event, callback) => {
@@ -5861,11 +5871,11 @@ class _Database {
     }
   }
   _processChanges() {
-    const head = this.db.query('SELECT MAX(id) as m FROM "_changes"').get();
+    const head = this._stmt('SELECT MAX(id) as m FROM "_changes"').get();
     const maxId = head?.m ?? 0;
     if (maxId <= this._changeWatermark)
       return;
-    const changes = this.db.query('SELECT id, tbl, op, row_id FROM "_changes" WHERE id > ? ORDER BY id').all(this._changeWatermark);
+    const changes = this._stmt('SELECT id, tbl, op, row_id FROM "_changes" WHERE id > ? ORDER BY id').all(this._changeWatermark);
     for (const change of changes) {
       const listeners = this._listeners.filter((l) => l.table === change.tbl && l.event === change.op);
       if (listeners.length > 0) {
@@ -5889,22 +5899,23 @@ class _Database {
       }
       this._changeWatermark = change.id;
     }
-    this.db.query('DELETE FROM "_changes" WHERE id <= ?').run(this._changeWatermark);
+    this._stmt('DELETE FROM "_changes" WHERE id <= ?').run(this._changeWatermark);
   }
   transaction(callback) {
     return this._m("transaction", () => this.db.transaction(callback)());
   }
   close() {
     this._stopPolling();
+    this._stmtCache.clear();
     this.db.close();
   }
   query(callback) {
     return this._m("query(proxy)", () => executeProxyQuery(this.schemas, callback, (sql, params) => {
-      return this.db.query(sql).all(...params);
+      return this._stmt(sql).all(...params);
     }));
   }
   raw(sql, ...params) {
-    return this._m(`raw: ${sql.slice(0, 60)}`, () => this.db.query(sql).all(...params));
+    return this._m(`raw: ${sql.slice(0, 60)}`, () => this._stmt(sql).all(...params));
   }
   exec(sql, ...params) {
     this._m(`exec: ${sql.slice(0, 60)}`, () => this.db.run(sql, ...params));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlite-zod-orm",
-  "version": "3.25.0",
+  "version": "3.26.0",
   "description": "Type-safe SQLite ORM for Bun — Zod schemas, fluent queries, auto relationships, zero SQL",
   "type": "module",
   "main": "./dist/index.js",

package/src/context.ts

@@ -46,4 +46,10 @@ export interface DatabaseContext {
      * When debug is off, executes fn directly with zero overhead.
      */
     _m<T>(label: string, fn: () => T): T;
+
+    /**
+     * Get a cached prepared statement. Compiles SQL once, reuses on subsequent calls.
+     * Falls back to `db.query(sql)` if the statement was finalized.
+     */
+    _stmt(sql: string): ReturnType<SqliteDatabase['query']>;
 }

package/src/crud.ts

@@ -14,21 +14,21 @@ import type { DatabaseContext } from './context';
 // ---------------------------------------------------------------------------
 
 export function getById(ctx: DatabaseContext, entityName: string, id: number): AugmentedEntity<any> | null {
-    const row = ctx.db.query(`SELECT * FROM "${entityName}" WHERE id = ?`).get(id) as any;
+    const row = ctx._stmt(`SELECT * FROM "${entityName}" WHERE id = ?`).get(id) as any;
     if (!row) return null;
     return ctx.attachMethods(entityName, transformFromStorage(row, ctx.schemas[entityName]!));
 }
 
 export function getOne(ctx: DatabaseContext, entityName: string, conditions: Record<string, any>): AugmentedEntity<any> | null {
     const { clause, values } = ctx.buildWhereClause(conditions);
-    const row = ctx.db.query(`SELECT * FROM "${entityName}" ${clause} LIMIT 1`).get(...values) as any;
+    const row = ctx._stmt(`SELECT * FROM "${entityName}" ${clause} LIMIT 1`).get(...values) as any;
     if (!row) return null;
     return ctx.attachMethods(entityName, transformFromStorage(row, ctx.schemas[entityName]!));
 }
 
 export function findMany(ctx: DatabaseContext, entityName: string, conditions: Record<string, any> = {}): AugmentedEntity<any>[] {
     const { clause, values } = ctx.buildWhereClause(conditions);
-    const rows = ctx.db.query(`SELECT * FROM "${entityName}" ${clause}`).all(...values);
+    const rows = ctx._stmt(`SELECT * FROM "${entityName}" ${clause}`).all(...values);
     return rows.map((row: any) =>
         ctx.attachMethods(entityName, transformFromStorage(row, ctx.schemas[entityName]!))
     );
@@ -68,7 +68,7 @@ export function insert<T extends Record<string, any>>(ctx: DatabaseContext, enti
 
     let lastId = 0;
     ctx._m(`SQL: ${sql.slice(0, 40)}`, () => {
-        const result = ctx.db.query(sql).run(...Object.values(transformed));
+        const result = ctx._stmt(sql).run(...Object.values(transformed));
         lastId = result.lastInsertRowid as number;
     });
     const newEntity = getById(ctx, entityName, lastId);
@@ -103,7 +103,7 @@ export function update<T extends Record<string, any>>(ctx: DatabaseContext, enti
     const setClause = Object.keys(transformed).map(key => `"${key}" = ?`).join(', ');
     const sql = `UPDATE "${entityName}" SET ${setClause} WHERE id = ?`;
     ctx._m(`SQL: UPDATE ${entityName} SET ...`, () => {
-        ctx.db.query(sql).run(...Object.values(transformed), id);
+        ctx._stmt(sql).run(...Object.values(transformed), id);
     });
 
     const updated = getById(ctx, entityName, id);
@@ -125,7 +125,7 @@ export function updateWhere(ctx: DatabaseContext, entityName: string, data: Reco
 
     const setCols = Object.keys(transformed);
     const setClause = setCols.map(key => `"${key}" = ?`).join(', ');
-    const result = ctx.db.query(`UPDATE "${entityName}" SET ${setClause} ${clause}`).run(
+    const result = ctx._stmt(`UPDATE "${entityName}" SET ${setClause} ${clause}`).run(
         ...setCols.map(key => transformed[key]),
         ...whereValues
     );
@@ -181,7 +181,7 @@ export function deleteEntity(ctx: DatabaseContext, entityName: string, id: numbe
         if (result === false) return;
     }
 
-    ctx.db.query(`DELETE FROM "${entityName}" WHERE id = ?`).run(id);
+    ctx._stmt(`DELETE FROM "${entityName}" WHERE id = ?`).run(id);
 
     // afterDelete hook
     if (hooks?.afterDelete) hooks.afterDelete(id);
@@ -196,12 +196,12 @@ export function deleteWhere(ctx: DatabaseContext, entityName: string, conditions
         // Soft delete: set deletedAt instead of removing rows
         const now = new Date().toISOString();
         const sql = `UPDATE "${entityName}" SET "deletedAt" = ? ${clause}`;
-        const result = ctx._m(`SQL: ${sql.slice(0, 50)}`, () => ctx.db.query(sql).run(now, ...values));
+        const result = ctx._m(`SQL: ${sql.slice(0, 50)}`, () => ctx._stmt(sql).run(now, ...values));
         return (result as any).changes ?? 0;
     }
 
     const sql = `DELETE FROM "${entityName}" ${clause}`;
-    const result = ctx._m(`SQL: ${sql.slice(0, 50)}`, () => ctx.db.query(sql).run(...values));
+    const result = ctx._m(`SQL: ${sql.slice(0, 50)}`, () => ctx._stmt(sql).run(...values));
     return (result as any).changes ?? 0;
 }
 
@@ -247,7 +247,7 @@ export function insertMany<T extends Record<string, any>>(ctx: DatabaseContext,
             const sql = columns.length === 0
                 ? `INSERT INTO "${entityName}" DEFAULT VALUES`
                 : `INSERT INTO "${entityName}" (${quotedCols.join(', ')}) VALUES (${columns.map(() => '?').join(', ')})`;
-            const result = ctx.db.query(sql).run(...Object.values(transformed));
+            const result = ctx._stmt(sql).run(...Object.values(transformed));
             ids.push(result.lastInsertRowid as number);
         }
         return ids;

package/src/database.ts

@@ -67,6 +67,19 @@ class _Database<Schemas extends SchemaMap> {
     /** Scoped measure-fn instance for instrumentation. */
     private _measure: ReturnType<typeof createMeasure>;
 
+    /** Prepared statement cache — avoids re-compiling identical SQL. */
+    private _stmtCache = new Map<string, ReturnType<SqliteDatabase['query']>>();
+
+    /** Get or create a cached prepared statement. */
+    private _stmt(sql: string): ReturnType<SqliteDatabase['query']> {
+        let stmt = this._stmtCache.get(sql);
+        if (!stmt) {
+            stmt = this.db.query(sql);
+            this._stmtCache.set(sql, stmt);
+        }
+        return stmt;
+    }
+
     /**
      * Conditional measurement helper — wraps with measure-fn only when debug is on.
      * When debug is off, executes fn directly with zero overhead.
@@ -105,6 +118,7 @@ class _Database<Schemas extends SchemaMap> {
             computed: options.computed ?? {},
             cascade: options.cascade ?? {},
             _m: <T>(label: string, fn: () => T): T => this._m(label, fn),
+            _stmt: (sql: string) => this._stmt(sql),
         };
 
         this._m('Init tables', () => this.initializeTables());
@@ -146,9 +160,9 @@ class _Database<Schemas extends SchemaMap> {
                                     if (rel) {
                                         if (this._softDeletes) {
                                             const now = new Date().toISOString();
-                                            this.db.query(`UPDATE "${childTable}" SET "deletedAt" = ? WHERE "${rel.foreignKey}" = ?`).run(now, id);
+                                            this._stmt(`UPDATE "${childTable}" SET "deletedAt" = ? WHERE "${rel.foreignKey}" = ?`).run(now, id);
                                         } else {
-                                            this.db.query(`DELETE FROM "${childTable}" WHERE "${rel.foreignKey}" = ?`).run(id);
+                                            this._stmt(`DELETE FROM "${childTable}" WHERE "${rel.foreignKey}" = ?`).run(id);
                                         }
                                     }
                                 }
@@ -156,7 +170,7 @@ class _Database<Schemas extends SchemaMap> {
 
                             if (this._softDeletes) {
                                 const now = new Date().toISOString();
-                                this.db.query(`UPDATE "${entityName}" SET "deletedAt" = ? WHERE id = ?`).run(now, id);
+                                this._stmt(`UPDATE "${entityName}" SET "deletedAt" = ? WHERE id = ?`).run(now, id);
                                 if (hooks?.afterDelete) hooks.afterDelete(id);
                                 return;
                             }
@@ -168,12 +182,12 @@ class _Database<Schemas extends SchemaMap> {
                 restore: ((id: number) => {
                     if (!this._softDeletes) throw new Error('restore() requires softDeletes: true');
                     this._m(`${entityName}.restore(${id})`, () => {
-                        this.db.query(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
+                        this._stmt(`UPDATE "${entityName}" SET "deletedAt" = NULL WHERE id = ?`).run(id);
                     });
                 }) as any,
                 select: (...cols: string[]) => createQueryBuilder(this._ctx, entityName, cols),
                 count: () => this._m(`${entityName}.count`, () => {
-                    const row = this.db.query(`SELECT COUNT(*) as count FROM "${entityName}"${this._softDeletes ? ' WHERE "deletedAt" IS NULL' : ''}`).get() as any;
+                    const row = this._stmt(`SELECT COUNT(*) as count FROM "${entityName}"${this._softDeletes ? ' WHERE "deletedAt" IS NULL' : ''}`).get() as any;
                     return row?.count ?? 0;
                 }),
                 on: (event: ChangeEvent, callback: (row: any) => void | Promise<void>) => {
@@ -339,11 +353,11 @@ class _Database<Schemas extends SchemaMap> {
      */
     private _processChanges(): void {
         // Fast path: check if anything changed at all (single scalar, index-only)
-        const head = this.db.query('SELECT MAX(id) as m FROM "_changes"').get() as any;
+        const head = this._stmt('SELECT MAX(id) as m FROM "_changes"').get() as any;
         const maxId: number = head?.m ?? 0;
         if (maxId <= this._changeWatermark) return;
 
-        const changes = this.db.query(
+        const changes = this._stmt(
             'SELECT id, tbl, op, row_id FROM "_changes" WHERE id > ? ORDER BY id'
         ).all(this._changeWatermark) as { id: number; tbl: string; op: string; row_id: number }[];
 
@@ -374,7 +388,7 @@ class _Database<Schemas extends SchemaMap> {
         }
 
         // Clean up consumed changes
-        this.db.query('DELETE FROM "_changes" WHERE id <= ?').run(this._changeWatermark);
+        this._stmt('DELETE FROM "_changes" WHERE id <= ?').run(this._changeWatermark);
     }
 
     // =========================================================================
@@ -385,9 +399,10 @@ class _Database<Schemas extends SchemaMap> {
         return this._m('transaction', () => this.db.transaction(callback)());
     }
 
-    /** Close the database: stops polling and releases the SQLite handle. */
+    /** Close the database: stops polling, clears cache, and releases the SQLite handle. */
     public close(): void {
         this._stopPolling();
+        this._stmtCache.clear();
         this.db.close();
     }
 
@@ -403,7 +418,7 @@ class _Database<Schemas extends SchemaMap> {
             this.schemas,
             callback as any,
             (sql: string, params: any[]) => {
-                return this.db.query(sql).all(...params) as T[];
+                return this._stmt(sql).all(...params) as T[];
             },
         ));
     }
@@ -414,7 +429,7 @@ class _Database<Schemas extends SchemaMap> {
 
     /** Execute a raw SQL query and return results. */
     public raw<T = any>(sql: string, ...params: any[]): T[] {
-        return this._m(`raw: ${sql.slice(0, 60)}`, () => this.db.query(sql).all(...params) as T[]);
+        return this._m(`raw: ${sql.slice(0, 60)}`, () => this._stmt(sql).all(...params) as T[]);
     }
 
     /** Execute a raw SQL statement (INSERT/UPDATE/DELETE) without returning rows. */

package/src/query.ts

@@ -40,7 +40,7 @@ export function createQueryBuilder(ctx: DatabaseContext, entityName: string, ini
 
     const executor = (sql: string, params: any[], raw: boolean): any[] => {
         return ctx._m(`SQL: ${sql.slice(0, 60)}`, () => {
-            const rows = ctx.db.query(sql).all(...params);
+            const rows = ctx._stmt(sql).all(...params);
             if (raw) return rows;
             return rows.map((row: any) => ctx.attachMethods(entityName, transformFromStorage(row, schema)));
         });
@@ -103,7 +103,7 @@ export function createQueryBuilder(ctx: DatabaseContext, entityName: string, ini
             if (belongsTo) {
                 const fk = belongsTo.foreignKey;
                 const placeholders = parentIds.map(() => '?').join(', ');
-                const childRows = ctx.db.query(
+                const childRows = ctx._stmt(
                     `SELECT * FROM ${hasMany.to} WHERE ${fk} IN (${placeholders})`
                 ).all(...parentIds) as any[];