utilitas 2001.1.136 → 2001.1.139

package/lib/dbio.mjs

@@ -1,13 +1,14 @@
 import {
-    assertSet, checkChance, ensureArray, ensureString, ignoreErrFunc,
+    assertSet, checkChance, ensureArray, ensureString,
     log as _log, need, throwError,
 } from './utilitas.mjs';
 
 import { isPrimary } from './callosum.mjs';
+import { getTempPath } from './storage.mjs';
 
 const _NEED = ['mysql2', 'pg'];
 const [mysqlDefaultPort, postgresqlDefaultPort] = [3306, 5432];
-const [mysqlQuote, postgresqlQuote] = ['`', ''];
+const [mysqlQuote, postgresqlQuote, sqliteQuote] = ['`', '', '"'];
 const IFSC = 'information_schema';
 const orders = { '+': 'ASC', ASC: 'ASC', '-': 'DESC', DESC: 'DESC', VECTOR: ' ' };
 const [INSERT, UPDATE, RETURNING] = ['INSERT', 'UPDATE', 'RETURNING'];
@@ -21,7 +22,7 @@ const log = content => _log(content, import.meta.url);
 const defaultKey = options => options && options.key ? options.key : fieldId;
 const queryOne = async (...args) => (await query(...args))[0];
 const assertForce = op => assert(op?.force, "Option 'force' is required.", 500);
-const [MYSQL, POSTGRESQL] = ['MYSQL', 'POSTGRESQL'];
+const [MYSQL, POSTGRESQL, SQLITE] = ['MYSQL', 'POSTGRESQL', 'SQLITE'];
 const quote = name => `${bracket}${name}${bracket}`;
 const join = elements => elements.join(', ');
 const assembleDelete = table => `DELETE FROM ${quote(assertTable(table))}`;
@@ -32,12 +33,255 @@ const cleanSql = sql => sql.replace(/\s+/g, ' ');
 
 let provider, pool, actExecute, bracket, sqlShowTables, placeholder, sqlDesc,
     sqlShowIndexes, fieldCountResult, doublePlaceholder, pgvector,
-    pgCheckedClients = new WeakSet();
+    pgCheckedClients = new WeakSet(), workerDb = null,
+    sqliteModule = null, workerThreadsModule = null;
+
+const getSqliteModule = async () =>
+    sqliteModule || (sqliteModule = await need('node:sqlite', { raw: true }));
+
+const getWorkerThreadsModule = async () => workerThreadsModule
+    || (workerThreadsModule = await need('node:worker_threads', { raw: true }));
+
+const normalizeSqliteParams = (params) => {
+    if (params === undefined || params === null) { return []; }
+    if (Array.isArray(params)) { return params; }
+    if (typeof params === 'object') { return params; }
+    return [params];
+};
+
+const assembleKeyValueParams = value =>
+    provider === SQLITE && Array.isArray(value) ? value : [value];
+
+const normalizeKeyValue = (key, value) => {
+    if (Object.isObject(key)) { key = Object.entries(key); }
+    return Array.isArray(key)
+        ? { key, value, params: key.map(x => x[1]) }
+        : { key, value, params: assembleKeyValueParams(value) };
+};
+
+const callSqliteStatement = (statement, method, params) => {
+    const normalized = normalizeSqliteParams(params);
+    return Array.isArray(normalized)
+        ? statement[method](...normalized)
+        : statement[method](normalized);
+};
+
+const requireWorkerDb = () => {
+    if (!workerDb) {
+        throw new Error('SQLite database has not been initialized.');
+    }
+    return workerDb;
+};
+
+const runSqliteWorkerOperation = (operation = {}) => {
+    const db = requireWorkerDb();
+    const type = String(operation.type || '').trim();
+    const sql = String(operation.sql || '');
+    if (type === 'exec') {
+        db.exec(sql);
+        return null;
+    }
+    if (type === 'run') {
+        const result = callSqliteStatement(
+            db.prepare(sql), type, operation.params
+        );
+        return {
+            affectedRows: Number(result?.changes || 0),
+            changes: Number(result?.changes || 0),
+            insertId: Number(result?.lastInsertRowid || 0),
+            lastInsertRowid: Number(result?.lastInsertRowid || 0),
+        };
+    }
+    if (type === 'get' || type === 'all') {
+        return callSqliteStatement(db.prepare(sql), type, operation.params);
+    }
+    throw new Error(`Unknown SQLite operation: ${type}`);
+};
+
+const getDefaultSqlitePath = () => getTempPath({
+    sub: `utilitas-dbio-${Date.now()}-${Math.random()
+        .toString(36).slice(2)}.sqlite`,
+});
+
+const handleSqliteWorkerCall = async (message = {}, context = {}) => {
+    const id = message.id;
+    const { path, parentPort } = context;
+    try {
+        const method = String(message.method || '').trim();
+        if (method === 'open') {
+            if (!workerDb) {
+                const { DatabaseSync } = await getSqliteModule();
+                workerDb = new DatabaseSync(path);
+            }
+            parentPort.postMessage({ id, ok: true, result: null });
+            return;
+        }
+        if (method === 'close') {
+            workerDb?.close();
+            workerDb = null;
+            parentPort.postMessage({ id, ok: true, result: null });
+            return;
+        }
+        if (method === 'transaction') {
+            const db = requireWorkerDb();
+            const operations = Array.isArray(message.operations)
+                ? message.operations : [];
+            db.exec('BEGIN');
+            try {
+                const result = operations.map(runSqliteWorkerOperation);
+                db.exec('COMMIT');
+                parentPort.postMessage({ id, ok: true, result });
+            } catch (error) {
+                db.exec('ROLLBACK');
+                throw error;
+            }
+            return;
+        }
+        const result = runSqliteWorkerOperation({
+            type: method,
+            sql: message.sql,
+            params: message.params,
+        });
+        parentPort.postMessage({ id, ok: true, result });
+    } catch (error) {
+        parentPort.postMessage({
+            id,
+            ok: false,
+            error: {
+                message: error?.message || String(error),
+                stack: error?.stack || '',
+            },
+        });
+    }
+};
+
+const startSqliteWorker = async (path) => {
+    const { parentPort } = await getWorkerThreadsModule();
+    parentPort.on('message', (message) => {
+        void handleSqliteWorkerCall(message, { path, parentPort });
+    });
+};
+
+class SQLiteWorkerPool {
+    constructor(path) {
+        this.path = path;
+        this.worker = null;
+        this.nextRequestId = 1;
+        this.pending = new Map();
+        this.openPromise = null;
+        this.closed = false;
+    }
+
+    async open() {
+        if (this.openPromise) { return await this.openPromise; }
+        this.openPromise = this.#call({ method: 'open' });
+        try {
+            await this.openPromise;
+        } finally {
+            this.openPromise = null;
+        }
+    }
+
+    async close() {
+        if (this.closed) { return; }
+        const worker = this.worker;
+        if (!worker) {
+            this.closed = true;
+            return;
+        }
+        try {
+            await this.#call({ method: 'close' });
+        } finally {
+            this.closed = true;
+            this.worker = null;
+            for (const { reject } of this.pending.values()) {
+                reject(new Error('SQLite worker closed'));
+            }
+            this.pending.clear();
+            await worker.terminate();
+        }
+    }
+
+    async exec(sql) { return await this.#call({ method: 'exec', sql }); }
+    async run(sql, params = []) {
+        return await this.#call({ method: 'run', sql, params });
+    }
+    async get(sql, params = []) {
+        return await this.#call({ method: 'get', sql, params });
+    }
+    async all(sql, params = []) {
+        return await this.#call({ method: 'all', sql, params });
+    }
+    async transaction(operations = []) {
+        return await this.#call({
+            method: 'transaction',
+            operations: Array.isArray(operations) ? operations : [],
+        });
+    }
+    query(...args) { return this.all(...args); }
+    execute(...args) { return this.run(...args); }
+    end() { return this.close(); }
+
+    async #ensureWorker() {
+        if (this.worker) { return; }
+        const { Worker } = await getWorkerThreadsModule();
+        const worker = new Worker(`
+            import ${JSON.stringify(new URL('./horizon.mjs', import.meta.url).href)};
+            import { startSqliteWorker } from ${JSON.stringify(import.meta.url)};
+            await startSqliteWorker(${JSON.stringify(this.path)});
+        `, {
+            eval: true,
+            execArgv: process.execArgv.filter(
+                arg => !arg.startsWith('--input-type')
+            ),
+        });
+        worker.on('message', (message) => {
+            const id = Number(message?.id || 0);
+            const pending = this.pending.get(id);
+            if (!pending) { return; }
+            this.pending.delete(id);
+            if (message.ok) {
+                pending.resolve(message.result);
+                return;
+            }
+            const error = new Error(
+                message?.error?.message || 'SQLite worker failed'
+            );
+            if (message?.error?.stack) { error.stack = message.error.stack; }
+            pending.reject(error);
+        });
+        worker.on('error', (error) => this.#rejectAll(error));
+        worker.on('exit', (code) => {
+            if (!this.closed && code !== 0) {
+                this.#rejectAll(new Error(`SQLite worker exited: ${code}`));
+            }
+            this.worker = null;
+        });
+        this.worker = worker;
+    }
+
+    async #call(payload = {}) {
+        if (this.closed) {
+            return Promise.reject(new Error('SQLite worker is closed'));
+        }
+        await this.#ensureWorker();
+        const id = this.nextRequestId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.worker.postMessage({ ...payload, id });
+        });
+    }
+
+    #rejectAll(error) {
+        for (const { reject } of this.pending.values()) { reject(error); }
+        this.pending.clear();
+    }
+}
 
 const init = async (options) => {
     if (options) {
         const _provider = ensureString(options?.provider, { case: 'UP' });
-        let port, vector = '';
+        let [port, vector, uri] = [null, '', ''];
         switch (_provider) {
             case MYSQL:
             case 'MARIA':
@@ -56,6 +300,9 @@ const init = async (options) => {
                     `SHOW INDEXES FROM ${doublePlaceholder}`,
                     `DESC ${doublePlaceholder}`,
                 ];
+                uri = `${_provider.toLowerCase()}://${options.user}@`
+                    + `${options.host}:${options.port || port}/`
+                    + `${options.database}`;
                 break;
             case 'PG':
             case 'POSTGRE':
@@ -79,6 +326,30 @@ const init = async (options) => {
                     await enableVector();
                     vector = '(vector)';
                 }
+                uri = `${_provider.toLowerCase()}://${options.user}@`
+                    + `${options.host}:${options.port || port}/`
+                    + `${options.database}`;
+                break;
+            case 'SQL':
+            case 'SQLITE3':
+            case SQLITE:
+                const path = options.path || getDefaultSqlitePath();
+                [
+                    provider, pool, actExecute, bracket, placeholder,
+                    fieldCountResult,
+                ] = [
+                        SQLITE, new SQLiteWorkerPool(path), 'run',
+                        sqliteQuote, '?', fieldCount,
+                    ];
+                await pool.open();
+                doublePlaceholder = placeholder;
+                [sqlShowTables, sqlShowIndexes, sqlDesc] = [
+                    'SELECT name FROM sqlite_master WHERE type = \'table\' '
+                    + 'AND name NOT LIKE \'sqlite_%\' ORDER BY name',
+                    table => `PRAGMA index_list(${quote(table)})`,
+                    table => `PRAGMA table_info(${quote(table)})`,
+                ];
+                uri = `sqlite://${path}`;
                 break;
             default:
                 assert(
@@ -87,17 +358,21 @@ const init = async (options) => {
                 );
         }
         isPrimary && !options.silent && log(
-            `Initialized: ${_provider.toLowerCase()}://${options.user}@`
-            + `${options.host}:${options.port || port}/${options.database}`
-            + `${vector}`
+            `Initialized: ${uri}${vector}`
         );
     }
     assert(pool, 'Database has not been initialized.');
     return pool;
 };
 
-const end = async (options) => {
-    pool && pool.end();
+const end = async () => {
+    if (pool) { await pool.end(); }
+    [
+        provider, pool, actExecute, bracket, sqlShowTables, placeholder,
+        sqlDesc, sqlShowIndexes, fieldCountResult, doublePlaceholder,
+        pgvector,
+    ] = [];
+    pgCheckedClients = new WeakSet();
     log('Terminated.');
 };
 
@@ -157,6 +432,7 @@ const handleResult = result => {
     switch (provider) {
         case MYSQL: return result[0];
         case POSTGRESQL: return result.rows;
+        case SQLITE: return result;
     }
 };
 
@@ -169,6 +445,7 @@ const execute = async (...args) => {
     switch (provider) {
         case MYSQL: return resp[0];
         case POSTGRESQL: return resp;
+        case SQLITE: return resp;
     }
 };
 
@@ -213,16 +490,22 @@ const rawAssembleKeyValue = (key, value, options) => {
         let _placeholder;
         switch (provider) {
             case MYSQL:
+            case SQLITE:
                 _placeholder = placeholder;
                 break;
             case POSTGRESQL:
-                _placeholder = `$${options?.placeholderIndex || (~~i + 1)}`;
+                _placeholder = `$${options?.placeholderIndex
+                    ? options.placeholderIndex + i : (~~i + 1)}`;
         }
         const val = options?.direct ? value : _placeholder;
         let express = `${getComparison(value) || '='} ${val}`;
         if (Array.isArray(value)) {
             assert(value.length, 'Invalid array value.', 500);
-            express = `IN (${val})`;
+            if (provider === SQLITE) {
+                express = `IN (${value.map(() => placeholder).join(', ')})`;
+            } else {
+                express = `IN (${val})`;
+            }
         } else if (value === null) { express = `IS ${val}`; }
         conditions.push(`${quote(keys[i])} ${express}`);
     });
@@ -248,6 +531,7 @@ const assembleSet = (data, options) => {
             keys.push(k);
             switch (provider) {
                 case MYSQL:
+                case SQLITE:
                     vals.push('?');
                     pairs.push(`${quote(k)} = ?`);
                     break;
@@ -258,19 +542,36 @@ const assembleSet = (data, options) => {
             pushValue(values, item[k]);
         }
         if (options?.upsert) {
-            for (let k in item) {
-                switch (provider) {
-                    case MYSQL: dupSql.push(`${quote(k)} = ?`); break;
-                    case POSTGRESQL: dupSql.push(`${quote(k)} = $${++i}`); break;
-                }
-                pushValue(values, item[k]);
+            switch (provider) {
+                case MYSQL:
+                case POSTGRESQL:
+                    for (let k in item) {
+                        switch (provider) {
+                            case MYSQL:
+                                dupSql.push(`${quote(k)} = ?`);
+                                break;
+                            case POSTGRESQL:
+                                dupSql.push(`${quote(k)} = $${++i}`);
+                                break;
+                        }
+                        pushValue(values, item[k]);
+                    }
+                    break;
+                case SQLITE:
+                    for (let k in item) {
+                        dupSql.push(`${quote(k)} = excluded.${quote(k)}`);
+                    }
+                    break;
             }
             switch (provider) {
                 case MYSQL:
                     dupSql = ` ON DUPLICATE KEY UPDATE ${join(dupSql)}`;
                     break;
                 case POSTGRESQL:
-                    dupSql = ` ON CONFLICT (${defaultKey(options)}) DO UPDATE SET ${join(dupSql)}`;
+                case SQLITE:
+                    dupSql = ' ON CONFLICT '
+                        + `(${quote(defaultKey(options))}) DO UPDATE SET `
+                        + join(dupSql);
                     break;
             }
         } else { dupSql = ''; }
@@ -318,28 +619,36 @@ const tables = async (options) => {
         switch (provider) {
             case MYSQL: return Object.values(x)[0];
             case POSTGRESQL: return x.table_name;
+            case SQLITE: return x.name;
         }
     });
 };
 
 const desc = async (table, options) => {
     assertTable(table);
-    const [resp, result] = [await query(sqlDesc, [table]), {}];
+    const sql = typeof sqlDesc === 'function' ? sqlDesc(table) : sqlDesc;
+    const params = typeof sqlDesc === 'function' ? [] : [table];
+    const [resp, result] = [await query(sql, params), {}];
     if (options?.raw) { return resp; }
     switch (provider) {
         case MYSQL: resp.map(x => result[x.Field] = x); break;
         case POSTGRESQL: resp.map(x => result[x.column_name] = x); break;
+        case SQLITE: resp.map(x => result[x.name] = x); break;
     }
     return result;
 };
 
 const indexes = async (table, options) => {
     assertTable(table);
-    const [resp, result] = [await query(sqlShowIndexes, [table]), {}];
+    const sql = typeof sqlShowIndexes === 'function'
+        ? sqlShowIndexes(table) : sqlShowIndexes;
+    const params = typeof sqlShowIndexes === 'function' ? [] : [table];
+    const [resp, result] = [await query(sql, params), {}];
     if (options?.raw) { return resp; }
     switch (provider) {
         case MYSQL: resp.map(x => result[x.Key_name] = x); break;
         case POSTGRESQL: resp.map(x => result[x.indexname] = x); break;
+        case SQLITE: resp.map(x => result[x.name] = x); break;
     }
     return result;
 };
@@ -350,6 +659,7 @@ const drop = async (table, options) => {
     const act = {
         [MYSQL]: [query, [`DROP TABLE IF EXISTS ${doublePlaceholder}`, [table]]],
         [POSTGRESQL]: [execute, [`DROP TABLE IF EXISTS ${table}`]],
+        [SQLITE]: [execute, [`DROP TABLE IF EXISTS ${quote(table)}`]],
     }[provider]
     return await act[0](...act[1]);
 };
@@ -358,11 +668,11 @@ const queryAll = (table, options) =>
     query(`${assembleQuery(table, options)}${assembleTail(options)}`);
 
 const queryByKeyValue = async (table, key, value, options) => {
-    Object.isObject(key) && (key = Object.entries(key));
+    const where = normalizeKeyValue(key, value);
     const sql = assembleQuery(table, options)
-        + assembleKeyValue(key, value)
+        + assembleKeyValue(where.key, where.value)
         + assembleTail(options);
-    const resp = await query(sql, Array.isArray(key) ? key.map(x => x[1]) : [value]);
+    const resp = await query(sql, where.params);
     return options?.unique ? (resp && resp.length ? resp[0] : null) : resp;
 };
 
@@ -387,7 +697,9 @@ const insert = async (table, fields, options) => {
                 await vacuum(table, { auto: true, ...options || {} });
             }
             resp.key = key;
-            !resp.insertId && item.object[key]
+            key !== fieldId && item.object[key]
+                ? (resp.insertId = item.object[key])
+                : !resp.insertId && item.object[key]
                 && (resp.insertId = item.object[key]);
             result.push(resp);
             ids.push(resp.insertId);
@@ -396,6 +708,7 @@ const insert = async (table, fields, options) => {
     if (!options?.skipEcho && ids.length) {
         switch (provider) {
             case MYSQL:
+            case SQLITE:
                 result = await queryById(table, ids, options);
                 break;
             case POSTGRESQL:
@@ -418,24 +731,29 @@ const countAll = async (table) => {
 };
 
 const countByKeyValue = async (table, key, value) => {
+    const where = normalizeKeyValue(key, value);
     const sql = assembleQuery(table, { fields: fieldCount })
-        + assembleKeyValue(key, value);
-    return (await query(sql, [value]))[0][fieldCountResult];
+        + assembleKeyValue(where.key, where.value);
+    return (await query(sql, where.params))[0][fieldCountResult];
 };
 
 const updateByKeyValue = async (table, key, value, fields, options) => {
     assertTable(table);
+    const where = normalizeKeyValue(key, value);
     const dfKey = defaultKey(options);
-    const subfix = assembleKeyValue(key, value, {
+    const subfix = assembleKeyValue(where.key, where.value, {
         placeholderIndex: Object.keys(fields).length + 1,
     }) + (provider === POSTGRESQL ? (options?.skipEcho ? (
         options?.key ? ` ${RETURNING} ${dfKey}` : ''
     ) : RETURNING_ALL) : '');
     let { sql, values } = assembleUpdate(table, fields, { subfix });
     sql += assembleTail(options);
-    const resp = await query(sql, [...values, value]);
-    return !options?.skipEcho && provider === MYSQL
-        ? await queryByKeyValue(table, key, value, options) : resp;
+    const params = [...values, ...where.params];
+    const resp = provider === POSTGRESQL
+        ? await query(sql, params)
+        : await execute(sql, params);
+    return !options?.skipEcho && [MYSQL, SQLITE].includes(provider)
+        ? await queryByKeyValue(table, where.key, where.value, options) : resp;
 };
 
 const updateById = async (table, id, fields, options) => {
@@ -446,12 +764,13 @@ const updateById = async (table, id, fields, options) => {
 };
 
 const deleteByKeyValue = async (table, key, value, options) => {
+    const where = normalizeKeyValue(key, value);
     const sql = assembleDelete(table)
-        + assembleKeyValue(key, value)
+        + assembleKeyValue(where.key, where.value)
         + assembleTail(options);
     return await {
-        [MYSQL]: query, [POSTGRESQL]: execByQuery,
-    }[provider](sql, [value]);
+        [MYSQL]: query, [POSTGRESQL]: execByQuery, [SQLITE]: execute,
+    }[provider](sql, where.params);
 };
 
 const deleteById = async (table, id, options) =>
@@ -480,6 +799,7 @@ export {
     _NEED,
     MYSQL,
     POSTGRESQL,
+    SQLITE,
     assembleInsert,
     assembleQuery,
     assembleSet,
@@ -510,6 +830,7 @@ export {
     rawAssembleKeyValue,
     rawExecute,
     rawQuery,
+    startSqliteWorker,
     tables,
     updateById,
     updateByKeyValue,

package/lib/manifest.mjs

@@ -1,13 +1,13 @@
 const manifest = {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "2001.1.136",
+    "version": "2001.1.139",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",
     "type": "module",
     "engines": {
-        "node": ">=20.x"
+        "node": ">=22.5.0"
     },
     "author": "Leask Wong <i@leaskh.com>",
     "license": "MIT",
@@ -19,19 +19,19 @@ const manifest = {
         "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.1/xlsx-0.20.1.tgz"
     },
     "dependencies": {
-        "file-type": "^21.3.3",
-        "mathjs": "^15.1.1",
-        "uuid": "^13.0.0"
+        "file-type": "^22.0.1",
+        "mathjs": "^15.2.0",
+        "uuid": "^14.0.0"
     },
     "devDependencies": {
         "@ffmpeg-installer/ffmpeg": "^1.1.0",
         "@ffprobe-installer/ffprobe": "^2.1.2",
-        "@google-cloud/discoveryengine": "^2.5.3",
+        "@google-cloud/discoveryengine": "^2.6.0",
         "@google-cloud/storage": "^7.19.0",
-        "@google/genai": "^1.46.0",
+        "@google/genai": "^1.51.0",
         "@mozilla/readability": "github:mozilla/readability",
-        "@sentry/node": "^10.44.0",
-        "@sentry/profiling-node": "^10.44.0",
+        "@sentry/node": "^10.51.0",
+        "@sentry/profiling-node": "^10.51.0",
         "acme-client": "^5.4.0",
         "browserify-fs": "^1.0.0",
         "buffer": "^6.0.3",
@@ -40,35 +40,35 @@ const manifest = {
         "fluent-ffmpeg": "^2.1.3",
         "form-data": "^4.0.5",
         "google-gax": "^5.0.6",
-        "ioredis": "^5.10.0",
-        "jsdom": "^29.0.0",
+        "ioredis": "^5.10.1",
+        "jsdom": "^29.1.0",
         "lorem-ipsum": "^2.0.8",
-        "mailgun.js": "^12.7.1",
-        "mailparser": "^3.9.4",
+        "mailgun.js": "^13.0.0",
+        "mailparser": "^3.9.8",
         "mime": "^4.1.0",
-        "mysql2": "^3.20.0",
+        "mysql2": "^3.22.3",
         "node-mailjet": "^6.0.11",
         "node-polyfill-webpack-plugin": "^4.1.0",
         "office-text-extractor": "^4.0.0",
-        "openai": "^6.32.0",
+        "openai": "^6.35.0",
         "pdf-lib": "^1.17.1",
-        "pdfjs-dist": "^5.5.207",
+        "pdfjs-dist": "^5.7.284",
         "pg": "^8.20.0",
         "pgvector": "^0.2.1",
         "ping": "^1.0.0",
         "process": "^0.11.10",
-        "puppeteer": "^24.39.1",
+        "puppeteer": "^24.42.0",
         "say": "^0.16.0",
         "telegraf": "^4.16.3",
         "telesignsdk": "^5.0.0",
         "tesseract.js": "^7.0.0",
-        "twilio": "^5.13.0",
+        "twilio": "^6.0.0",
         "url": "github:Leask/node-url",
         "webpack-cli": "^7.0.2",
         "whisper-node": "^1.1.1",
-        "wrangler": "^4.75.0",
+        "wrangler": "^4.86.0",
         "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.1/xlsx-0.20.1.tgz",
-        "youtube-transcript": "^1.3.0"
+        "youtube-transcript": "^1.3.1"
     }
 };