inibase 3.1.1 → 3.3.0

package/dist/index.js

@@ -220,6 +220,9 @@ export default class Inibase {
      * @param {TableConfig} [config]
      */
     async createTable(tableName, schema, config) {
+        return File.runWithLockStore(() => this._createTable(tableName, schema, config));
+    }
+    async _createTable(tableName, schema, config) {
         this.validateName(tableName);
         // DDL does not participate in the write-ahead journal: schema surgery
         // inside a transaction would escape the atomic publish/rollback scope.
@@ -291,6 +294,9 @@ export default class Inibase {
      * @param {(TableConfig&{name?: string})} [config]
      */
     async updateTable(tableName, schema, config) {
+        return File.runWithLockStore(() => this._updateTable(tableName, schema, config));
+    }
+    async _updateTable(tableName, schema, config) {
         this.validateName(tableName);
         // DDL does not participate in the write-ahead journal: schema surgery
         // inside a transaction would escape the atomic publish/rollback scope.
@@ -364,14 +370,14 @@ export default class Inibase {
             // row. Evaluation happens BEFORE the schema is rewritten, so a
             // failed migration (dangling link, arithmetic error, unknown
             // field, ...) leaves the old schema and column values untouched.
-            const oldComputed = new Map((table.schema ?? [])
-                .filter((field) => typeof field.computed !== "undefined")
-                .map((field) => [field.key, this.computedExprOf(field)]));
+            const oldComputed = new Map(this.computedEntries(table.schema ?? []).map(({ key, expr }) => [
+                key,
+                expr,
+            ]));
             const changedComputedKeys = new Set(totalLines > 0
-                ? schema
-                    .filter((field) => typeof field.computed !== "undefined" &&
-                    oldComputed.get(field.key) !== this.computedExprOf(field))
-                    .map((field) => field.key)
+                ? this.computedEntries(schema)
+                    .filter(({ key, expr }) => oldComputed.get(key) !== expr)
+                    .map(({ key }) => key)
                 : []);
             const backfillReplacers = changedComputedKeys.size
                 ? await (async () => {
@@ -1026,6 +1032,25 @@ export default class Inibase {
         const computed = field.computed;
         return typeof computed === "string" ? computed : (computed?.expr ?? "");
     }
+    /**
+     * Every computed field of a schema as dotted keys (computed children of an
+     * array-of-objects column use their full path, e.g. `items.lineTotal`),
+     * with its raw expression — used for updateTable change detection.
+     */
+    computedEntries(schema) {
+        const out = [];
+        const walk = (fields, prefix) => {
+            for (const field of fields) {
+                const key = prefix ? `${prefix}.${field.key}` : field.key;
+                if (typeof field.computed !== "undefined")
+                    out.push({ key, expr: this.computedExprOf(field) });
+                if (field.children && Utils.isArrayOfObjects(field.children))
+                    walk(field.children, key);
+            }
+        };
+        walk(schema, "");
+        return out;
+    }
     /**
      * Compile every `computed` expression of a schema (which must already have
      * ids assigned) into its persisted `{ expr, ast }` form, in dependency
@@ -1033,27 +1058,67 @@ export default class Inibase {
      * on-disk schema always carries compiled ASTs.
      */
     async compileComputedFields(schema) {
-        const computedFields = schema.filter((field) => typeof field.computed !== "undefined");
-        if (!computedFields.length)
-            return schema;
+        const entries = [];
         const index = buildFieldIndex(schema);
+        const walk = (fields, prefix) => {
+            for (const field of fields) {
+                const key = prefix ? `${prefix}.${field.key}` : field.key;
+                if (typeof field.computed !== "undefined") {
+                    const ref = index.get(field.id);
+                    entries.push({
+                        field,
+                        key,
+                        elementRoot: ref?.arrayAncestor
+                            ? { id: ref.arrayAncestor.id, key: ref.arrayAncestor.key }
+                            : null,
+                    });
+                }
+                if (field.children && Utils.isArrayOfObjects(field.children))
+                    walk(field.children, key);
+            }
+        };
+        walk(schema, "");
+        if (!entries.length)
+            return schema;
         const ctx = {
             language: this.language,
             ownKey: "",
             index,
             getTableIndex: async (target) => this.tableFieldIndex(target),
+            elementContext: null,
         };
         const resolved = [];
-        for (const field of computedFields) {
-            // Computed fields are evaluated from the row of the table they
-            // belong to, so v1 restricts them to top-level schema fields.
-            const ref = index.get(field.id);
-            if (!ref || ref.arrayAncestor)
-                throw this.createError("COMPUTED_FIELD_INVALID_TARGET", field.key);
-            ctx.ownKey = field.key;
-            const raw = parseExpression(this.computedExprOf(field), this.language, field.key);
+        for (const entry of entries) {
+            const ref = index.get(entry.field.id);
+            if (!ref)
+                throw this.createError("COMPUTED_FIELD_INVALID_TARGET", entry.key);
+            if (entry.elementRoot) {
+                // Element computed field (a child of an array-of-objects
+                // column): must hold a plain value (never a container), and v1
+                // keeps them numeric so writes are always summable.
+                if ((ref.nestedInArrayOfArrays && ref.arrayAncestor) ||
+                    entry.field.type !== "number")
+                    throw this.createError("COMPUTED_FIELD_INVALID_TARGET", entry.key);
+                ctx.elementContext = {
+                    arrayRootId: entry.elementRoot.id,
+                };
+            }
+            else {
+                // Top-level computed field: cannot live inside an array.
+                if (ref.arrayAncestor)
+                    throw this.createError("COMPUTED_FIELD_INVALID_TARGET", entry.key);
+                ctx.elementContext = null;
+            }
+            ctx.ownKey = entry.key;
+            const raw = parseExpression(this.computedExprOf(entry.field), this.language, entry.key);
             const { ast, deps } = await resolveExpression(raw, ctx);
-            resolved.push({ field, ast, deps });
+            resolved.push({
+                field: entry.field,
+                key: entry.key,
+                elementRoot: entry.elementRoot,
+                ast,
+                deps,
+            });
         }
         const ordered = topoSortComputedFields(resolved.map(({ field, deps }) => ({
             id: field.id,
@@ -1065,14 +1130,27 @@ export default class Inibase {
             const entry = resolved.find(({ field }) => field.id === meta.id);
             if (!entry)
                 continue;
-            specByKey.set(meta.key, {
+            specByKey.set(entry.key, {
                 expr: this.computedExprOf(entry.field),
                 ast: entry.ast,
             });
         }
-        return schema.map((field) => typeof field.computed !== "undefined"
-            ? { ...field, computed: specByKey.get(field.key) }
-            : field);
+        const applySpecs = (fields, prefix) => fields.map((field) => {
+            const key = prefix ? `${prefix}.${field.key}` : field.key;
+            let next = field;
+            if (typeof field.computed !== "undefined") {
+                const spec = specByKey.get(key);
+                if (spec)
+                    next = { ...field, computed: spec };
+            }
+            if (field.children && Utils.isArrayOfObjects(field.children))
+                next = {
+                    ...next,
+                    children: applySpecs(field.children, key),
+                };
+            return next;
+        });
+        return applySpecs(schema, "");
     }
     /**
      * Build the evaluation plan (topological order + id index) for a table's
@@ -1098,6 +1176,7 @@ export default class Inibase {
             language: this.language,
             ownKey: "",
             index,
+            elementContext: null,
             getTableIndex: async (target) => {
                 let cached = indexCache.get(target);
                 if (!cached) {
@@ -1108,29 +1187,46 @@ export default class Inibase {
                 return cached;
             },
         };
-        for (const field of s) {
-            if (typeof field.computed === "undefined")
-                continue;
-            const computed = field.computed;
-            if (typeof computed === "string") {
-                ctx.ownKey = field.key;
-                const raw = parseExpression(computed, this.language, field.key);
-                const { ast, deps } = await resolveExpression(raw, ctx);
-                fields.push({
-                    id: field.id,
-                    key: field.key,
-                    ast,
-                    deps,
-                });
+        // Collect every computed field: top-level ones and, when a schema
+        // carries them, the computed children of array-of-objects columns.
+        const walk = async (fieldsSchema, prefix) => {
+            for (const field of fieldsSchema) {
+                const key = prefix ? `${prefix}.${field.key}` : field.key;
+                if (typeof field.computed !== "undefined") {
+                    const ref = index.get(field.id);
+                    const elementRoot = ref?.arrayAncestor
+                        ? { id: ref.arrayAncestor.id, key: ref.arrayAncestor.key }
+                        : null;
+                    const computed = field.computed;
+                    if (typeof computed === "string") {
+                        ctx.ownKey = key;
+                        ctx.elementContext = elementRoot
+                            ? { arrayRootId: elementRoot.id }
+                            : null;
+                        const raw = parseExpression(computed, this.language, key);
+                        const { ast, deps } = await resolveExpression(raw, ctx);
+                        fields.push({
+                            id: field.id,
+                            key,
+                            ast,
+                            deps,
+                            elementRoot,
+                        });
+                    }
+                    else
+                        fields.push({
+                            id: field.id,
+                            key,
+                            ast: computed.ast,
+                            deps: collectFieldDeps(computed.ast),
+                            elementRoot,
+                        });
+                }
+                if (field.children && Utils.isArrayOfObjects(field.children))
+                    await walk(field.children, key);
             }
-            else
-                fields.push({
-                    id: field.id,
-                    key: field.key,
-                    ast: computed.ast,
-                    deps: collectFieldDeps(computed.ast),
-                });
-        }
+        };
+        await walk(s, "");
         if (!fields.length) {
             if (schema === undefined)
                 this.computedPlanCache.set(tableName, null);
@@ -1206,6 +1302,42 @@ export default class Inibase {
             collect,
         };
         for (const field of plan.fields) {
+            if (field.elementRoot) {
+                // Element computed field (child of an array-of-objects column):
+                // evaluate once per element (frame = element, strip =
+                // `${rootKey}.`), write back into the element so other computed
+                // fields and the flatten pass see it, and report the
+                // per-element array under the dotted column key. Missing
+                // operands read as 0 (`env.nullAsZero`), never an error.
+                const rootKey = field.elementRoot.key;
+                const childKey = field.key.slice(rootKey.length + 1);
+                const elements = Array.isArray(env.row[rootKey])
+                    ? env.row[rootKey]
+                    : [];
+                const savedFrame = env.frame;
+                const savedStrip = env.strip;
+                const savedNullAsZero = env.nullAsZero;
+                env.strip = `${rootKey}.`;
+                env.ownKey = field.key;
+                env.nullAsZero = true;
+                const values = [];
+                for (const element of elements) {
+                    if (!Utils.isObject(element)) {
+                        values.push(0);
+                        continue;
+                    }
+                    env.frame = element;
+                    const value = await this.evaluateNode(field.ast, env);
+                    const written = value === null || value === undefined ? 0 : value;
+                    element[childKey] = written;
+                    values.push(written);
+                }
+                env.frame = savedFrame;
+                env.strip = savedStrip;
+                env.nullAsZero = savedNullAsZero;
+                out[field.key] = values;
+                continue;
+            }
             env.strip = "";
             env.ownKey = field.key;
             const value = await this.evaluateNode(field.ast, env);
@@ -1223,7 +1355,7 @@ export default class Inibase {
             case "bin": {
                 const a = await this.evaluateNode(node.left, env);
                 const b = await this.evaluateNode(node.right, env);
-                return this.applyBinaryOp(node.op, a, b, env.ownKey, env.collect);
+                return this.applyBinaryOp(node.op, a, b, env.ownKey, env.collect, env.nullAsZero);
             }
             case "fn": {
                 const arrayRef = env.index.get(node.arrayFieldId);
@@ -1283,7 +1415,12 @@ export default class Inibase {
                 strip = "";
             }
             else {
-                // `value` is the id of the row this hop lives in.
+                // `value` is the id of the row this hop lives in. Rows that
+                // came off disk are eagerly resolved by processSchemaData, so
+                // table children may already be linked objects — unwrap those
+                // back to their id before the hop lookup. Nothing else hops.
+                if (typeof value === "object" && value !== null)
+                    value = value.id;
                 if (value === undefined ||
                     value === null ||
                     value === "" ||
@@ -1302,8 +1439,7 @@ export default class Inibase {
                         ? (env.links.record(table, ref.key, value), null)
                         : await env.links.read(table, ref.key, value)
                     : await this.readLinkedRow(table, value, ref.key);
-                if (!env.collect &&
-                    (row === undefined || row === null))
+                if (!env.collect && (row === undefined || row === null))
                     throw this.createError("COMPUTED_FIELD_DANGLING_LINK", [
                         env.ownKey,
                         table,
@@ -1352,18 +1488,28 @@ export default class Inibase {
             ]);
         return num;
     }
-    applyBinaryOp(op, a, b, ownKey, collect = false) {
+    applyBinaryOp(op, a, b, ownKey, collect = false, nullAsZero = false) {
         if (a === null || a === undefined || b === null || b === undefined) {
             // Collection passes must tolerate unresolved (null) link hops:
             // the pass only discovers which links are needed, so a neutral
             // result is fine. Real evaluation still throws.
             if (collect)
                 return 0;
+            // Element computed evaluation treats a missing operand as the
+            // value 0 (per the element-sum feature), so a single missing
+            // child never aborts the write.
+            if (nullAsZero) {
+                if (a === null || a === undefined)
+                    a = 0;
+                if (b === null || b === undefined)
+                    b = 0;
+            }
+        }
+        if (a === null || a === undefined || b === null || b === undefined)
             throw this.createError("COMPUTED_FIELD_ARITHMETIC", [
                 ownKey,
                 "missing or null operand",
             ]);
-        }
         const an = this.coerceNumber(a, ownKey);
         const bn = this.coerceNumber(b, ownKey);
         switch (op) {
@@ -1447,9 +1593,11 @@ export default class Inibase {
             if (existing) {
                 let matches = true;
                 for (const [line, values] of entries) {
+                    if (!Object.hasOwn(values, field.key))
+                        continue;
+                    const lineValue = values[field.key];
                     const old = existing[Number(line)]?.[field.key];
-                    const fresh = File.encode(values[field.key]);
-                    if (old === undefined || File.encode(old) !== fresh) {
+                    if (old === undefined || !this.sameCellValue(lineValue, old)) {
                         matches = false;
                         break;
                     }
@@ -1459,10 +1607,26 @@ export default class Inibase {
             }
             const content = pathesContents[path] ?? {};
             for (const [line, values] of entries)
-                content[Number(line)] = File.encode(values[field.key]);
+                if (Object.hasOwn(values, field.key) && values[field.key] !== undefined)
+                    content[Number(line)] = File.encode(values[field.key]);
             pathesContents[path] = content;
         }
     }
+    /** Compare a freshly evaluated cell value against a stored (already
+     *  decoded) one — both are scalar or index-aligned element arrays. */
+    sameCellValue(fresh, stored) {
+        if (fresh === stored)
+            return true;
+        if (Array.isArray(fresh) &&
+            Array.isArray(stored) &&
+            fresh.length === stored.length) {
+            for (let i = 0; i < fresh.length; i++)
+                if (fresh[i] !== stored[i])
+                    return false;
+            return true;
+        }
+        return File.encode(fresh) === File.encode(stored);
+    }
     // Helper function to determine if a field is simple
     isSimpleField(fieldType) {
         const complexTypes = ["array", "object", "table"];
@@ -2150,6 +2314,9 @@ export default class Inibase {
      * locked on first touch, in first-touch order.
      */
     async begin(tables = []) {
+        return File.runWithLockStore(() => this._begin(tables));
+    }
+    async _begin(tables = []) {
         if (this.transaction)
             throw this.createError("INVALID_PARAMETERS");
         await this.ensureDatabaseTmpDir();
@@ -2301,6 +2468,12 @@ export default class Inibase {
     async get(tableName, where, options = {
         page: 1,
         perPage: 15,
+    }, onlyOne, onlyLinesNumbers, _whereIsLinesNumbers) {
+        return File.runWithLockStore(() => this._get(tableName, where, options, onlyOne, onlyLinesNumbers, _whereIsLinesNumbers));
+    }
+    async _get(tableName, where, options = {
+        page: 1,
+        perPage: 15,
     }, onlyOne, onlyLinesNumbers, _whereIsLinesNumbers) {
         this.validateName(tableName);
         await this.ensureTableRecovered(tableName);
@@ -2473,9 +2646,13 @@ export default class Inibase {
         }
         else if (((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) &&
-            (_whereIsLinesNumbers ||
-                !globalConfig[this.databasePath].tables?.get(tableName)?.config
-                    .decodeID)) {
+            // Numeric where is a line number only through the internal
+            // recursion (flag set). An external numeric where is an id — even
+            // on non-decodeID tables, where ids are NOT line numbers (prepend
+            // layout / rows deleted); using them as lines edited the wrong row
+            // and padded the column file (Sep-2026 rename bug). Ids are
+            // resolved by the next branch.
+            _whereIsLinesNumbers) {
             // "where" in this case, is the line(s) number(s) and not id(s)
             let lineNumbers = where;
             if (!Array.isArray(lineNumbers))
@@ -2489,8 +2666,6 @@ export default class Inibase {
                 RETURN = RETURN[0];
         }
         else if ((!_whereIsLinesNumbers &&
-            globalConfig[this.databasePath].tables?.get(tableName)?.config
-                .decodeID &&
             ((Array.isArray(where) && where.every(Utils.isNumber)) ||
                 Utils.isNumber(where))) ||
             (Array.isArray(where) && where.every(Utils.isValidID)) ||
@@ -2616,6 +2791,9 @@ export default class Inibase {
         return onlyOne && Array.isArray(RETURN) ? RETURN[0] : RETURN;
     }
     async post(tableName, data, options, returnPostedData) {
+        return File.runWithLockStore(() => this._post(tableName, data, options, returnPostedData));
+    }
+    async _post(tableName, data, options, returnPostedData) {
         if (!options)
             options = {
                 page: 1,
@@ -2713,7 +2891,7 @@ export default class Inibase {
                     // No read-your-writes yet: return the formatted staged rows
                     // (ids + defaults) instead of a committed-state read.
                     return (Array.isArray(clonedData) ? clonedData : clonedData);
-                return this.get(tableName, globalConfig[this.databasePath].tables?.get(tableName)?.config.prepend
+                return await this.get(tableName, globalConfig[this.databasePath].tables?.get(tableName)?.config.prepend
                     ? Array.isArray(clonedData)
                         ? clonedData.map((_, index) => index + 1).toReversed()
                         : 1
@@ -2738,13 +2916,13 @@ export default class Inibase {
                 // here so nothing leaks.
                 if (!txnStaged && renameList.length)
                     await Promise.allSettled(renameList
-                        .filter((pair) => Boolean(pair[1]))
+                        .filter((pair) => Boolean(pair[0]))
                         .map(async ([tempPath, _]) => unlink(tempPath)));
             }
             else {
                 if (renameList.length)
                     await Promise.allSettled(renameList
-                        .filter((pair) => Boolean(pair[1]))
+                        .filter((pair) => Boolean(pair[0]))
                         .map(async ([tempPath, _]) => unlink(tempPath)));
                 await File.unlock(join(tablePath, ".tmp"));
             }
@@ -2753,6 +2931,12 @@ export default class Inibase {
     async put(tableName, data, where, options = {
         page: 1,
         perPage: 15,
+    }, returnUpdatedData, _whereIsLinesNumbers) {
+        return File.runWithLockStore(() => this._put(tableName, data, where, options, returnUpdatedData, _whereIsLinesNumbers));
+    }
+    async _put(tableName, data, where, options = {
+        page: 1,
+        perPage: 15,
     }, returnUpdatedData, _whereIsLinesNumbers) {
         const renameList = [];
         let txnStaged = false;
@@ -2843,13 +3027,13 @@ export default class Inibase {
                     // owns them.
                     if (!txnStaged && renameList.length)
                         await Promise.allSettled(renameList
-                            .filter((pair) => Boolean(pair[1]))
+                            .filter((pair) => Boolean(pair[0]))
                             .map(async ([tempPath, _]) => unlink(tempPath)));
                 }
                 else {
                     if (renameList.length)
                         await Promise.allSettled(renameList
-                            .filter((pair) => Boolean(pair[1]))
+                            .filter((pair) => Boolean(pair[0]))
                             .map(async ([tempPath, _]) => unlink(tempPath)));
                     await File.unlock(join(tablePath, ".tmp"));
                 }
@@ -2857,9 +3041,13 @@ export default class Inibase {
         }
         else if (((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) &&
-            (_whereIsLinesNumbers ||
-                !globalConfig[this.databasePath].tables?.get(tableName)?.config
-                    .decodeID)) {
+            // Numeric where is a line number only through the internal
+            // recursion (flag set). An external numeric where is an id — even
+            // on non-decodeID tables, where ids are NOT line numbers (prepend
+            // layout / rows deleted); using them as lines edited the wrong row
+            // and padded the column file (Sep-2026 rename bug). Ids are
+            // resolved by the next branch.
+            _whereIsLinesNumbers) {
             // "where" in this case, is the line(s) number(s) and not id(s)
             await this.validateTableData(tableName, clonedData, true);
             clonedData = this.formatData(clonedData, globalConfig[this.databasePath].tables?.get(tableName)?.schema ?? [], true);
@@ -2922,42 +3110,63 @@ export default class Inibase {
                 if (returnUpdatedData) {
                     if (this.transaction)
                         throw this.createError("INVALID_PARAMETERS");
-                    return this.get(tableName, where, options, !Array.isArray(where), undefined, true);
+                    // AWAITED readback: must complete inside the writer lock. An
+                    // async-tail `return this.get(...)` lets the finally below
+                    // unlock before the readback's file reads resume.
+                    return await this.get(tableName, where, options, !Array.isArray(where), undefined, true);
                 }
             }
             finally {
                 if (this.transaction) {
                     if (!txnStaged && renameList.length)
                         await Promise.allSettled(renameList
-                            .filter((pair) => Boolean(pair[1]))
+                            .filter((pair) => Boolean(pair[0]))
                             .map(async ([tempPath, _]) => unlink(tempPath)));
                 }
                 else {
                     if (renameList.length)
                         await Promise.allSettled(renameList
-                            .filter((pair) => Boolean(pair[1]))
+                            .filter((pair) => Boolean(pair[0]))
                             .map(async ([tempPath, _]) => unlink(tempPath)));
                     await File.unlock(join(tablePath, ".tmp"));
                 }
             }
         }
         else if ((!_whereIsLinesNumbers &&
-            globalConfig[this.databasePath].tables?.get(tableName)?.config
-                .decodeID &&
             ((Array.isArray(where) && where.every(Utils.isNumber)) ||
                 Utils.isNumber(where))) ||
             (Array.isArray(where) && where.every(Utils.isValidID)) ||
             Utils.isValidID(where)) {
-            const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
-            if (lineNumbers)
-                return this.put(tableName, clonedData, 
-                // get() with onlyLinesNumbers always returns an array; a
-                // single-id update must keep the scalar so the recursive
-                // line-numbers branch returns a single row (matching the
-                // shape of get(singleId)) instead of a one-element array.
-                !Array.isArray(where) && Array.isArray(lineNumbers)
-                    ? lineNumbers[0]
-                    : lineNumbers, options, returnUpdatedData, true);
+            // Resolve id -> line(s) WHILE holding the writer lock: a post
+            // landing between the resolution and the write would shift every
+            // line of a prepend table and the update would hit the wrong row.
+            // The recursive call re-takes the lock reentrantly (same task), so
+            // the lock is held continuously from resolution to publish.
+            let inlineLock = false;
+            try {
+                if (this.transaction)
+                    await this.ensureTxnLock(tableName);
+                else {
+                    await File.lock(join(tablePath, ".tmp"));
+                    inlineLock = true;
+                }
+                const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                if (lineNumbers)
+                    return await this.put(tableName, clonedData, 
+                    // get() with onlyLinesNumbers always returns an array; a
+                    // single-id update must keep the scalar so the recursive
+                    // line-numbers branch returns a single row (matching the
+                    // shape of get(singleId)) instead of a one-element array.
+                    !Array.isArray(where) && Array.isArray(lineNumbers)
+                        ? lineNumbers[0]
+                        : lineNumbers, options, returnUpdatedData, true);
+            }
+            finally {
+                // The recursion released its own (reentrant) acquisition;
+                // release ours too (transactions keep the lock until commit).
+                if (inlineLock)
+                    await File.unlock(join(tablePath, ".tmp"));
+            }
         }
         else if (Utils.isObject(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
@@ -2975,6 +3184,9 @@ export default class Inibase {
      * @return {boolean | null}  {(Promise<boolean | null>)}
      */
     async delete(tableName, where, _whereIsLinesNumbers, _cascadeGuard) {
+        return File.runWithLockStore(() => this._delete(tableName, where, _whereIsLinesNumbers, _cascadeGuard));
+    }
+    async _delete(tableName, where, _whereIsLinesNumbers, _cascadeGuard) {
         this.validateName(tableName);
         if (!this.transaction)
             await this.ensureDatabaseRecovered();
@@ -3023,13 +3235,13 @@ export default class Inibase {
                 if (this.transaction) {
                     if (!txnStaged && renameList.length)
                         await Promise.allSettled(renameList
-                            .filter((pair) => Boolean(pair[1]))
+                            .filter((pair) => Boolean(pair[0]))
                             .map(async ([tempPath, _]) => unlink(tempPath)));
                 }
                 else {
                     if (renameList.length)
                         await Promise.allSettled(renameList
-                            .filter((pair) => Boolean(pair[1]))
+                            .filter((pair) => Boolean(pair[0]))
                             .map(async ([tempPath, _]) => unlink(tempPath)));
                     await File.unlock(join(tablePath, ".tmp"));
                 }
@@ -3037,9 +3249,13 @@ export default class Inibase {
         }
         if (((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) &&
-            (_whereIsLinesNumbers ||
-                !globalConfig[this.databasePath].tables?.get(tableName)?.config
-                    .decodeID)) {
+            // Numeric where is a line number only through the internal
+            // recursion (flag set). An external numeric where is an id — even
+            // on non-decodeID tables, where ids are NOT line numbers (prepend
+            // layout / rows deleted); using them as lines edited the wrong row
+            // and padded the column file (Sep-2026 rename bug). Ids are
+            // resolved by the next branch.
+            _whereIsLinesNumbers) {
             // "where" in this case, is the line(s) number(s) and not id(s)
             const files = (await readdir(tablePath))?.filter((fileName) => fileName.endsWith(this.getFileExtension(tableName)));
             if (files.length) {
@@ -3105,13 +3321,13 @@ export default class Inibase {
                     if (this.transaction) {
                         if (!txnStaged && renameList.length)
                             await Promise.allSettled(renameList
-                                .filter((pair) => Boolean(pair[1]))
+                                .filter((pair) => Boolean(pair[0]))
                                 .map(async ([tempPath, _]) => unlink(tempPath)));
                     }
                     else {
                         if (renameList.length)
                             await Promise.allSettled(renameList
-                                .filter((pair) => Boolean(pair[1]))
+                                .filter((pair) => Boolean(pair[0]))
                                 .map(async ([tempPath, _]) => unlink(tempPath)));
                         await File.unlock(join(tablePath, ".tmp"));
                     }
@@ -3119,20 +3335,34 @@ export default class Inibase {
             }
         }
         if ((!_whereIsLinesNumbers &&
-            globalConfig[this.databasePath].tables?.get(tableName)?.config
-                .decodeID &&
             ((Array.isArray(where) && where.every(Utils.isNumber)) ||
                 Utils.isNumber(where))) ||
             (Array.isArray(where) && where.every(Utils.isValidID)) ||
             Utils.isValidID(where)) {
-            const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
-            // Deleting a non-existent id must not fall through to the
-            // "delete all rows" branch (this.delete(_, null, _) would truncate
-            // the whole table), so resolve the id to line numbers first and
-            // only delegate when something actually matched.
-            if (lineNumbers)
-                return this.delete(tableName, lineNumbers, true, _cascadeGuard ?? new Set());
-            return false;
+            // Resolve id -> line(s) WHILE holding the writer lock (see put():
+            // a concurrent post between resolution and delete would shift the
+            // lines of a prepend table and remove the wrong row).
+            let inlineLock = false;
+            try {
+                if (this.transaction)
+                    await this.ensureTxnLock(tableName);
+                else {
+                    await File.lock(join(tablePath, ".tmp"));
+                    inlineLock = true;
+                }
+                const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                // Deleting a non-existent id must not fall through to the
+                // "delete all rows" branch (this.delete(_, null, _) would truncate
+                // the whole table), so resolve the id to line numbers first and
+                // only delegate when something actually matched.
+                if (lineNumbers)
+                    return await this.delete(tableName, lineNumbers, true, _cascadeGuard ?? new Set());
+                return false;
+            }
+            finally {
+                if (inlineLock)
+                    await File.unlock(join(tablePath, ".tmp"));
+            }
         }
         if (Utils.isObject(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
@@ -3214,20 +3444,30 @@ export default class Inibase {
             }
         }
     }
-    async sum(tableName, columns, where) {
+    async sum(tableName, columns, where, options) {
         this.validateName(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
-        for (const column of columns)
-            this.validateName(column);
+        for (const column of columns) {
+            // Nested columns are dotted child paths (validated structurally by
+            // `sumNested`); everything else must be a plain safe name.
+            if (!options?.nested)
+                this.validateName(column);
+        }
         await this.throwErrorIfTableEmpty(tableName);
         const RETURN = {};
         const tablePath = join(this.databasePath, tableName);
+        if (options?.nested) {
+            const nested = await this.sumNested(tableName, columns, where, tablePath);
+            return columns.length > 1 ? nested : Object.values(nested)[0];
+        }
         for await (const column of columns) {
             const columnPath = join(tablePath, `${column}${this.getFileExtension(tableName)}`);
             if (await File.isExists(columnPath)) {
                 if (where) {
-                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                    // `{ perPage: -1 }` so criteria matching is never capped by
+                    // the default page size (15): every matching row counts.
+                    const lineNumbers = await this.get(tableName, where, { perPage: -1 }, undefined, true);
                     RETURN[column] = lineNumbers
                         ? await File.sum(columnPath, lineNumbers)
                         : 0;
@@ -3238,6 +3478,168 @@ export default class Inibase {
         }
         return columns.length > 1 ? RETURN : Object.values(RETURN)[0];
     }
+    /**
+     * Element-wise aggregation over an array-of-objects column (`nested` mode).
+     *
+     * `where` keys that resolve as children of the array root become per-element
+     * predicates (AND); everything else is a row-level filter. Only elements
+     * passing every element predicate, inside rows passing the row filters, are
+     * accumulated.
+     */
+    async sumNested(tableName, columns, where, tablePath) {
+        const tablePathSafe = tablePath ?? join(this.databasePath, tableName);
+        const schema = globalConfig[this.databasePath].tables?.get(tableName)?.schema ?? [];
+        const RETURN = {};
+        // Resolve the array-of-objects root from the summed columns (v1: exactly
+        // one nesting level, e.g. "items.quantity" -> root "items").
+        let rootKey = null;
+        let rootField = null;
+        const targetFields = new Map();
+        for (const column of columns) {
+            const dot = column.indexOf(".");
+            if (dot <= 0 || dot === column.length - 1 || column.indexOf(".", dot + 1) !== -1)
+                throw this.createError("INVALID_PARAMETERS", [
+                    `sum nested: '${column}' must be a single-level child path of an array-of-objects column`,
+                ]);
+            const rk = column.slice(0, dot);
+            if (rootKey !== null && rk !== rootKey)
+                throw this.createError("INVALID_PARAMETERS", [
+                    "sum nested: all summed columns must share the same array root",
+                ]);
+            rootKey = rk;
+            // NB: `getField` on a single segment that resolves to an
+            // array-of-objects field returns its *first child*, so resolve the
+            // root field directly from the top-level schema.
+            rootField = schema.find((f) => f.key === rk) ?? null;
+            const okRoot = rootField &&
+                rootField.type === "array" &&
+                Array.isArray(rootField.children) &&
+                Utils.isArrayOfObjects(rootField.children);
+            if (!okRoot)
+                throw this.createError("INVALID_PARAMETERS", [
+                    `sum nested: '${rk}' is not an array-of-objects column`,
+                ]);
+            const child = Utils.getField(column, schema);
+            if (!child || child.type === "array" || child.type === "object")
+                throw this.createError("INVALID_PARAMETERS", [
+                    `sum nested: '${column}' does not resolve to a scalar child`,
+                ]);
+            targetFields.set(column, child);
+        }
+        if (!rootKey)
+            return RETURN;
+        // Split `where` into element predicates (children of the root) and a
+        // row-level filter (everything else, incl. `and`/`or` groups).
+        const elementPredicates = [];
+        const rowWhere = {};
+        let idWhere;
+        if (where && Utils.isObject(where)) {
+            for (const [key, value] of Object.entries(where)) {
+                if (key === "and" || key === "or") {
+                    rowWhere[key] = value;
+                    continue;
+                }
+                const candidate = key.startsWith(`${rootKey}.`)
+                    ? key
+                    : `${rootKey}.${key}`;
+                const child = Utils.getField(candidate, schema);
+                if (child) {
+                    if (Utils.isObject(value))
+                        throw this.createError("INVALID_PARAMETERS", [
+                            `sum nested: element predicate '${key}' must be a scalar, not an object`,
+                        ]);
+                    const [operator, comparedValue] = typeof value === "string"
+                        ? Utils.FormatObjectCriteriaValue(value)
+                        : ["=", value];
+                    if (operator === "[]" || operator === "![]")
+                        throw this.createError("INVALID_PARAMETERS", [
+                            `sum nested: operator '${operator}' is not supported on element predicates`,
+                        ]);
+                    elementPredicates.push({
+                        field: child,
+                        operator,
+                        comparedValue,
+                    });
+                }
+                else {
+                    if (!Utils.getField(key, schema))
+                        throw this.createError("INVALID_PARAMETERS", [
+                            `sum nested: criteria key '${key}' matches neither the array root nor a row column`,
+                        ]);
+                    rowWhere[key] = value;
+                }
+            }
+        }
+        else if (typeof where === "number" ||
+            typeof where === "string" ||
+            Array.isArray(where)) {
+            idWhere = where;
+        }
+        // Row-level narrowing (ids or criteria). `undefined` lines = whole file.
+        let lines;
+        if (idWhere !== undefined)
+            lines = (await this.get(tableName, idWhere, { perPage: -1 }, undefined, true));
+        else if (Object.keys(rowWhere).length)
+            lines = (await this.get(tableName, rowWhere, { perPage: -1 }, undefined, true));
+        if (lines === null) {
+            for (const column of columns)
+                RETURN[column] = 0;
+            return RETURN;
+        }
+        const fieldOpt = (field) => ({
+            ...field,
+            databasePath: this.databasePath,
+        });
+        const ext = this.getFileExtension(tableName);
+        // Element predicate cells, read once for every summed column.
+        const predCells = new Map();
+        for (const p of elementPredicates) {
+            const path = join(tablePathSafe, `${rootKey}.${p.field.key}${ext}`);
+            if (!(await File.isExists(path)))
+                continue;
+            const cell = (await File.get(path, lines, fieldOpt(p.field)));
+            if (cell)
+                predCells.set(p.field.key, cell);
+        }
+        for (const [column, child] of targetFields) {
+            const path = join(tablePathSafe, `${column}${ext}`);
+            if (!(await File.isExists(path))) {
+                RETURN[column] = 0;
+                continue;
+            }
+            const cell = (await File.get(path, lines, fieldOpt(child)));
+            if (!cell) {
+                RETURN[column] = 0;
+                continue;
+            }
+            let sum = 0;
+            for (const [lineStr, values] of Object.entries(cell)) {
+                if (!Array.isArray(values))
+                    continue;
+                for (let i = 0; i < values.length; i++) {
+                    const v = values[i];
+                    if (v === null || v === undefined)
+                        continue;
+                    let matches = true;
+                    for (const p of elementPredicates) {
+                        const pv = predCells.get(p.field.key)?.[Number(lineStr)]?.[i];
+                        if (pv === undefined || !UtilsServer.compare(p.operator, pv, p.comparedValue, p.field.type)) {
+                            matches = false;
+                            break;
+                        }
+                    }
+                    if (!matches)
+                        continue;
+                    const num = Number(v);
+                    if (Number.isNaN(num))
+                        continue;
+                    sum += num;
+                }
+            }
+            RETURN[column] = sum;
+        }
+        return RETURN;
+    }
     async avg(tableName, columns, where) {
         this.validateName(tableName);
         if (!Array.isArray(columns))
@@ -3251,7 +3653,7 @@ export default class Inibase {
             const columnPath = join(tablePath, `${column}${this.getFileExtension(tableName)}`);
             if (await File.isExists(columnPath)) {
                 if (where) {
-                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                    const lineNumbers = await this.get(tableName, where, { perPage: -1 }, undefined, true);
                     RETURN[column] = lineNumbers
                         ? await File.avg(columnPath, lineNumbers)
                         : 0;
@@ -3275,7 +3677,7 @@ export default class Inibase {
             const columnPath = join(tablePath, `${column}${this.getFileExtension(tableName)}`);
             if (await File.isExists(columnPath)) {
                 if (where) {
-                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                    const lineNumbers = await this.get(tableName, where, { perPage: -1 }, undefined, true);
                     RETURN[column] = lineNumbers
                         ? await File.max(columnPath, lineNumbers)
                         : 0;
@@ -3299,7 +3701,7 @@ export default class Inibase {
             const columnPath = join(tablePath, `${column}${this.getFileExtension(tableName)}`);
             if (await File.isExists(columnPath)) {
                 if (where) {
-                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                    const lineNumbers = await this.get(tableName, where, { perPage: -1 }, undefined, true);
                     RETURN[column] = lineNumbers
                         ? await File.min(columnPath, lineNumbers)
                         : 0;