inibase 3.2.0 → 3.4.0

package/README.md

@@ -206,7 +206,7 @@ interface {
 
 ```ts
 interface Field {
-  id: number; // stored as a Number but displayed as a hashed ID
+  id: number; // position in the schema; 0 = the row id, -1 = createdAt, -2 = updatedAt
   key: string;
   required?: boolean;
   unique?: boolean | string; // boolean for simple uniqueness, string for grouped uniqueness
@@ -402,6 +402,30 @@ const userTableSchema = [
 await db.createTable("user", userTableSchema, userTableConfig);
 ```
 
+#### `decodeID`
+
+By default a row's `id` is stored as a number but only ever handed back as an
+encrypted (`aes-256-cbc`, hex) string, so ids can't be guessed by incrementing.
+Set `decodeID: true` and the id is exposed as the **plain number** everywhere —
+`get` rows, `get`/`put`/`delete` by id, relation lookups, and the id returned by
+`post`:
+
+```js
+const db = new Inibase("/databaseName");
+await db.createTable("item", [{ key: "name", type: "string" }], {
+  decodeID: true,
+});
+
+const id = await db.post("item", { name: "widget" }); // => 1  (a number)
+await db.get("item", 1); // works with the raw number
+```
+
+So `post` returns a `number` on a `decodeID` table and an encrypted `string` on
+every other table — in TypeScript its return type is `string | number`
+(`(string | number)[]` for a bulk post). Encrypted ids stay valid inputs on a
+`decodeID` table too, so existing clients that round-trip an id keep working
+either way. `decodeID` can be toggled later with `updateTable`.
+
 </blockquote>
 </details>
 

package/dist/file.d.ts

@@ -1,5 +1,21 @@
 import { type ComparisonOperator, type Field } from "./index.js";
 export declare const DURABLE: boolean;
+/**
+ * Run `fn` with a per-logical-task lock-owner store on its AsyncLocalStorage
+ * context. Every await continuation below `fn` then shares that store, so
+ * nested/reentrant acquisitions (put/delete id->line recursion, journal
+ * recovery re-locks, transaction flows) see the SAME store the outermost
+ * acquisition recorded as owner.
+ *
+ * Do NOT replace this with an enterWith() from inside lock(): that store is
+ * created in lock()'s own frame and (a) never propagates back to the caller's
+ * await continuation — every recursion then waits on its OWN lock until the
+ * watchdog (LOCK_WAIT_TIMEOUT) — and (b) can leak into sibling tasks, which
+ * then pass the writer lock as "reentrant" and re-race the Sep-2026 commit
+ * interleave (ENOENT renames, duplicate ids). `run()` gives clean per-op
+ * isolation and correct same-chain propagation.
+ */
+export declare const runWithLockStore: <T>(fn: () => T) => T;
 export declare const lock: (folderPath: string, prefix?: string, ttl?: number) => Promise<void>;
 /**
  * Non-blocking lock acquisition (used by the read path and the open-time

package/dist/file.js

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { access, appendFile, copyFile, constants as fsConstants, open, readFile, stat, unlink, } from "node:fs/promises";
 import { hostname } from "node:os";
 import { join, resolve } from "node:path";
@@ -31,6 +32,87 @@ const LOCK_RETRY_MS = 13;
 // multiple times (e.g. post() -> get() -> sort-cache). Depth 1 is a real
 // filesystem acquisition; deeper acquisitions just bump the counter.
 const lockDepths = new Map();
+// In-process serialization: sibling tasks (e.g. two concurrent HTTP requests
+// posting to the same table) must QUEUE behind the holder instead of passing
+// straight through the depth counter. That bypass is exactly what let
+// concurrent writers share the fixed `.tmp/<column>` staging path and race the
+// pagination rename (diverged column files, duplicate ids, lost rows in the
+// Sep-2026 pteam incident). Reentrancy from the *same* logical task (post() ->
+// get() -> ensureTableRecovered re-lock, transaction flows) still bumps the
+// depth without touching the filesystem, proven by the AsyncLocalStorage
+// context recorded at acquisition time.
+const lockReleaseWaiters = new Map();
+const lockOwners = new Map();
+// Upper bound on in-process wait time: converts a wedged or undetectable
+// holder into a visible error instead of a silent hang. 0 disables it.
+const LOCK_WAIT_TIMEOUT_MS = Number(process.env.INIBASE_LOCK_WAIT_TIMEOUT_MS ?? 120_000);
+const lockContext = new AsyncLocalStorage();
+// Resolve once the holder releases so the waiter can re-race for the lock.
+const waitForLockRelease = (resolvedPath) => new Promise((resolveWaiter, rejectWaiter) => {
+    let waiters = lockReleaseWaiters.get(resolvedPath);
+    if (!waiters) {
+        waiters = new Set();
+        lockReleaseWaiters.set(resolvedPath, waiters);
+    }
+    let timer = null;
+    const wake = (error) => {
+        waiters.delete(wake);
+        if (timer)
+            clearTimeout(timer);
+        error ? rejectWaiter(error) : resolveWaiter();
+    };
+    waiters.add(wake);
+    if (LOCK_WAIT_TIMEOUT_MS > 0)
+        timer = setTimeout(() => wake(new Error(`LOCK_WAIT_TIMEOUT: ${resolvedPath}`)), LOCK_WAIT_TIMEOUT_MS);
+});
+// The AsyncLocalStorage store of this task chain (created on first acquire).
+const currentLockStore = () => {
+    let store = lockContext.getStore();
+    if (!store) {
+        store = new Set();
+        lockContext.enterWith(store);
+    }
+    return store;
+};
+/**
+ * Run `fn` with a per-logical-task lock-owner store on its AsyncLocalStorage
+ * context. Every await continuation below `fn` then shares that store, so
+ * nested/reentrant acquisitions (put/delete id->line recursion, journal
+ * recovery re-locks, transaction flows) see the SAME store the outermost
+ * acquisition recorded as owner.
+ *
+ * Do NOT replace this with an enterWith() from inside lock(): that store is
+ * created in lock()'s own frame and (a) never propagates back to the caller's
+ * await continuation — every recursion then waits on its OWN lock until the
+ * watchdog (LOCK_WAIT_TIMEOUT) — and (b) can leak into sibling tasks, which
+ * then pass the writer lock as "reentrant" and re-race the Sep-2026 commit
+ * interleave (ENOENT renames, duplicate ids). `run()` gives clean per-op
+ * isolation and correct same-chain propagation.
+ */
+export const runWithLockStore = (fn) => {
+    if (lockContext.getStore())
+        return fn();
+    const store = new Set();
+    return lockContext.run(store, fn);
+};
+// True when this task already owns the lock (depth > 0 and the recorded owner
+// context is this task's context). Bumps the depth and returns.
+const isReentrant = (resolvedPath) => {
+    if (!lockDepths.get(resolvedPath))
+        return false;
+    if (lockOwners.get(resolvedPath) !== lockContext.getStore())
+        return false;
+    lockDepths.set(resolvedPath, lockDepths.get(resolvedPath) + 1);
+    return true;
+};
+const notifyLockReleased = (resolvedPath) => {
+    const waiters = lockReleaseWaiters.get(resolvedPath);
+    if (!waiters)
+        return;
+    lockReleaseWaiters.delete(resolvedPath);
+    for (const wake of waiters)
+        wake();
+};
 const lockFilePathFor = (folderPath, prefix) => join(folderPath, `${prefix ?? ""}.locked`);
 const lockOwnerState = async (lockFilePath) => {
     try {
@@ -67,12 +149,16 @@ const stealableLock = async (lockFilePath, mtimeMs, ttl) => {
 export const lock = async (folderPath, prefix, ttl = DEFAULT_LOCK_TTL_MS) => {
     const lockFilePath = lockFilePathFor(folderPath, prefix);
     const resolvedPath = resolve(lockFilePath);
-    const depth = lockDepths.get(resolvedPath);
-    if (depth) {
-        lockDepths.set(resolvedPath, depth + 1);
-        return;
-    }
     for (;;) {
+        // Same logical task already holds it -> reentrant depth bump.
+        if (isReentrant(resolvedPath))
+            return;
+        // A different in-process task holds it -> wait for the release, then
+        // re-race for the filesystem lock like any process.
+        if (lockDepths.get(resolvedPath)) {
+            await waitForLockRelease(resolvedPath);
+            continue;
+        }
         try {
             const lockFile = await open(lockFilePath, "wx");
             try {
@@ -100,6 +186,7 @@ export const lock = async (folderPath, prefix, ttl = DEFAULT_LOCK_TTL_MS) => {
                 }
             }
             lockDepths.set(resolvedPath, 1);
+            lockOwners.set(resolvedPath, currentLockStore());
             return;
         }
         catch (error) {
@@ -129,11 +216,10 @@ export const lock = async (folderPath, prefix, ttl = DEFAULT_LOCK_TTL_MS) => {
 export const tryLock = async (folderPath, prefix, ttl = DEFAULT_LOCK_TTL_MS) => {
     const lockFilePath = lockFilePathFor(folderPath, prefix);
     const resolvedPath = resolve(lockFilePath);
-    const depth = lockDepths.get(resolvedPath);
-    if (depth) {
-        lockDepths.set(resolvedPath, depth + 1);
+    if (isReentrant(resolvedPath))
         return true;
-    }
+    if (lockDepths.get(resolvedPath))
+        return false; // held by another in-process task: non-blocking
     for (let attempt = 0; attempt < 2; attempt++) {
         try {
             const lockFile = await open(lockFilePath, "wx");
@@ -157,6 +243,7 @@ export const tryLock = async (folderPath, prefix, ttl = DEFAULT_LOCK_TTL_MS) =>
                 }
             }
             lockDepths.set(resolvedPath, 1);
+            lockOwners.set(resolvedPath, currentLockStore());
             return true;
         }
         catch (error) {
@@ -183,12 +270,15 @@ export const unlock = async (folderPath, prefix) => {
         return;
     }
     lockDepths.delete(resolvedPath);
+    lockOwners.delete(resolvedPath);
     try {
         await unlink(lockFilePath);
     }
     catch {
         // Already released (stolen by a foreign-host stealer or cleaned up).
     }
+    // Wake in-process waiters so they re-race for the released lock.
+    notifyLockReleased(resolvedPath);
 };
 export const write = async (filePath, data) => {
     const handle = await open(filePath, "w");
@@ -242,6 +332,17 @@ export function escapeShellPath(filePath) {
     // Escape double quotes and special shell characters
     return `"${resolvedPath.replace(/(["\\$`])/g, "\\$1")}"`;
 }
+/**
+ * Unique-per-operation staging path: concurrent writers must never share the
+ * `.tmp/<column>` file. The fixed name let sibling operations clobber each
+ * other's in-progress temp and publish a temp that only contained one writer's
+ * content (column files following different winners -> diverged line counts).
+ * A pid + per-process counter suffix keeps every temp private; each pair is
+ * carried through the rename list and the journal, so commit/rollback/recovery
+ * still know exactly which files to move.
+ */
+let tempSeq = 0;
+const tempPathFor = (filePath) => filePath.replace(/([^/]+)\/?$/, `.tmp/$1.${process.pid}-${(tempSeq++).toString(36)}`);
 const _pipeline = async (filePath, rl, writeStream, transform) => {
     if (filePath.endsWith(".gz"))
         await pipeline(rl, transform, createGzip(), writeStream);
@@ -505,7 +606,7 @@ export async function get(filePath, lineNumbers, field, readWholeFile = false) {
  * Note: If the file doesn't exist and replacements is an object, it creates a new file with the specified replacements.
  */
 export const replace = async (filePath, replacements, totalItems) => {
-    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
+    const fileTempPath = tempPathFor(filePath);
     const isReplacementsObject = isObject(replacements);
     const isReplacementsLineNumbered = isReplacementsObject && !Number.isNaN(Number(Object.keys(replacements)[0]));
     if (await isExists(filePath)) {
@@ -581,19 +682,33 @@ export const replace = async (filePath, replacements, totalItems) => {
                 const replacementsKeys = Object.keys(replacements)
                     .map(Number)
                     .toSorted((a, b) => a - b);
-                await write(fileTempPath, `${"\n".repeat(replacementsKeys[0] - 1) +
-                    replacementsKeys
-                        .map((lineNumber, index) => index === 0 ||
-                        lineNumber - replacementsKeys[index - 1] - 1 === 0
-                        ? replacements[lineNumber]
-                        : "\n".repeat(lineNumber - replacementsKeys[index - 1] - 1) +
-                            replacements[lineNumber])
-                        .join("\n")}\n`);
+                await write(fileTempPath, 
+                // First-write for a compressed column: see append() — the
+                // unique temp path hides the ".gz" suffix from write().
+                filePath.endsWith(".gz")
+                    ? await gzip(`${"\n".repeat(replacementsKeys[0] - 1) +
+                        replacementsKeys
+                            .map((lineNumber, index) => index === 0 ||
+                            lineNumber - replacementsKeys[index - 1] - 1 === 0
+                            ? replacements[lineNumber]
+                            : "\n".repeat(lineNumber - replacementsKeys[index - 1] - 1) + replacements[lineNumber])
+                            .join("\n")}\n`)
+                    : `${"\n".repeat(replacementsKeys[0] - 1) +
+                        replacementsKeys
+                            .map((lineNumber, index) => index === 0 ||
+                            lineNumber - replacementsKeys[index - 1] - 1 === 0
+                            ? replacements[lineNumber]
+                            : "\n".repeat(lineNumber - replacementsKeys[index - 1] - 1) + replacements[lineNumber])
+                            .join("\n")}\n`);
             }
             else {
                 if (!totalItems)
                     throw new Error("INVALID_PARAMETERS");
-                await write(fileTempPath, `${`${replacements}\n`.repeat(totalItems)}\n`);
+                await write(fileTempPath, 
+                // First-write for a compressed column: see append().
+                filePath.endsWith(".gz")
+                    ? await gzip(`${`${replacements}\n`.repeat(totalItems)}\n`)
+                    : `${`${replacements}\n`.repeat(totalItems)}\n`);
             }
             return [fileTempPath, filePath];
         }
@@ -612,7 +727,7 @@ export const replace = async (filePath, replacements, totalItems) => {
  *
  */
 export const append = async (filePath, data) => {
-    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
+    const fileTempPath = tempPathFor(filePath);
     try {
         if (await isExists(filePath)) {
             await copyFile(filePath, fileTempPath);
@@ -627,7 +742,13 @@ export const append = async (filePath, data) => {
             }
         }
         else
-            await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+            await write(fileTempPath, 
+            // Unique temp paths no longer end with the original extension
+            // (.tmp/<col>.<pid>-<seq>), so write()'s suffix check can't
+            // gzip a first-write for a compressed column. Do it here.
+            filePath.endsWith(".gz")
+                ? await gzip(`${Array.isArray(data) ? data.join("\n") : data}\n`)
+                : `${Array.isArray(data) ? data.join("\n") : data}\n`);
         return [fileTempPath, filePath];
     }
     catch {
@@ -643,7 +764,7 @@ export const append = async (filePath, data) => {
  *
  */
 export const prepend = async (filePath, data) => {
-    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
+    const fileTempPath = tempPathFor(filePath);
     if (await isExists(filePath)) {
         if (!filePath.endsWith(".gz")) {
             let fileHandle = null;
@@ -673,7 +794,7 @@ export const prepend = async (filePath, data) => {
             }
         }
         else {
-            const fileChildTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/tmp_$1");
+            const fileChildTempPath = `${tempPathFor(filePath)}.child`;
             try {
                 await write(fileChildTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
                 const escapedFilePath = escapeShellPath(filePath);
@@ -691,7 +812,12 @@ export const prepend = async (filePath, data) => {
     }
     else {
         try {
-            await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+            await write(fileTempPath, 
+            // First-write for a compressed column: see append() — the
+            // unique temp path hides the ".gz" suffix from write().
+            filePath.endsWith(".gz")
+                ? await gzip(`${Array.isArray(data) ? data.join("\n") : data}\n`)
+                : `${Array.isArray(data) ? data.join("\n") : data}\n`);
         }
         catch {
             return [fileTempPath, null];
@@ -714,7 +840,7 @@ export const remove = async (filePath, linesToDelete) => {
         : [Number(linesToDelete)];
     if (linesToDelete.some(Number.isNaN))
         throw new Error("UNVALID_LINE_NUMBERS");
-    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
+    const fileTempPath = tempPathFor(filePath);
     try {
         const escapedFilePath = escapeShellPath(filePath);
         const escapedFileTempPath = escapeShellPath(fileTempPath);

package/dist/index.d.ts

@@ -155,6 +155,7 @@ export default class Inibase {
      * @param {TableConfig} [config]
      */
     createTable(tableName: string, schema?: Schema, config?: TableConfig): Promise<void>;
+    private _createTable;
     private replaceStringInFile;
     /**
      * Update table schema or config
@@ -166,6 +167,7 @@ export default class Inibase {
     updateTable(tableName: string, schema?: Schema, config?: TableConfig & {
         name?: string;
     }): Promise<void>;
+    private _updateTable;
     private updateTableLocked;
     /**
      * Get table schema and config
@@ -333,6 +335,7 @@ export default class Inibase {
      * locked on first touch, in first-touch order.
      */
     begin(tables?: string[]): Promise<void>;
+    private _begin;
     /**
      * Publish every staged mutation atomically: per table (sorted), the
      * pagination rename comes first (the atomic publication point readers
@@ -371,6 +374,7 @@ export default class Inibase {
     get<TData extends Record<string, any> & Partial<Data>>(tableName: string, where?: string | number | (string | number)[] | Criteria, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false, _whereIsLinesNumbers?: boolean): Promise<(Data & TData)[] | null>;
     get<_TData extends Record<string, any> & Partial<Data>>(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: false | undefined, onlyLinesNumbers: true, _whereIsLinesNumbers?: boolean): Promise<number[] | null>;
     get<_TData extends Record<string, any> & Partial<Data>>(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers: true, _whereIsLinesNumbers?: boolean): Promise<number | null>;
+    private _get;
     private getOnce;
     /**
      * Create new item(s) in a table
@@ -380,11 +384,16 @@ export default class Inibase {
      * @param {Options} [options] Pagination options, useful when the returnPostedData param is true
      * @param {boolean} [returnPostedData] By default function returns void, if you want to get the posted data, set this param to true
      * @return {*}  {Promise<Data | Data[] | null | void>}
+     *
+     * @remarks Without `returnPostedData` the return value is the new id: a
+     * `number` on a table created with `decodeID: true`, an encrypted
+     * `string` on every other table.
      */
-    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: Data & TData, options?: Options, returnPostedData?: boolean): Promise<string>;
-    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData)[], options?: Options, returnPostedData?: boolean): Promise<string[]>;
+    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: Data & TData, options?: Options, returnPostedData?: boolean): Promise<string | number>;
+    post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData)[], options?: Options, returnPostedData?: boolean): Promise<(string | number)[]>;
     post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: Data & TData, options: Options | undefined, returnPostedData: true): Promise<(Data & TData) | null>;
     post<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData)[], options: Options | undefined, returnPostedData: true): Promise<(Data & TData)[] | null>;
+    private _post;
     /**
      * Update item(s) in a table
      *
@@ -399,6 +408,7 @@ export default class Inibase {
     put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: Data & TData, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true | boolean, _whereIsLinesNumbers?: boolean): Promise<(Data & TData) | null>;
     put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData)[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true | boolean, _whereIsLinesNumbers?: boolean): Promise<(Data & TData)[] | null>;
     put<TData extends Record<string, any> & Partial<Data>>(tableName: string, data: (Data & TData) | (Data & TData)[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true | boolean, _whereIsLinesNumbers?: boolean): Promise<(Data & TData) | (Data & TData)[] | null>;
+    private _put;
     /**
      * Delete item(s) in a table
      *
@@ -407,6 +417,7 @@ export default class Inibase {
      * @return {boolean | null}  {(Promise<boolean | null>)}
      */
     delete(tableName: string, where?: number | string | (number | string)[] | Criteria, _whereIsLinesNumbers?: boolean, _cascadeGuard?: Set<string>): Promise<boolean | null>;
+    private _delete;
     /**
      * Cascade delete: remove rows in other tables whose `table`-typed schema
      * fields reference the given rows. Reference columns store the numeric
@@ -424,8 +435,8 @@ export default class Inibase {
      * @param {(number | string | (number | string)[] | Criteria)} [where]
      * @return {*}  {Promise<number | Record<string, number>>}
      */
-    sum(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
-    sum(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
+    sum(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria, options?: AggregateOptions): Promise<number>;
+    sum(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria, options?: AggregateOptions): Promise<Record<string, number>>;
     /**
      * Element-wise aggregation over an array-of-objects column (`nested` mode).
      *

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.
@@ -2308,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();
@@ -2459,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);
@@ -2631,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))
@@ -2647,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)) ||
@@ -2774,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,
@@ -2871,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
@@ -2882,12 +2902,18 @@ export default class Inibase {
                         : this.totalItems.get(`${tableName}-*`), options, !Utils.isArrayOfObjects(clonedData), // return only one item if data is not array of objects
                 undefined, true);
             }
+            // On a decodeID table the id *is* the plain number — that is the
+            // whole point of the config: get(), put(), delete() and the
+            // returnPostedData read all hand back raw numbers, so post() must
+            // not encode it here. Every other table keeps returning the
+            // encrypted id.
+            const tableConfig = globalConfig[this.databasePath].tables?.get(tableName)?.config;
+            const postedID = (id) => tableConfig?.decodeID === true
+                ? Number(id)
+                : UtilsServer.encodeID(id);
             return Array.isArray(clonedData)
-                ? (globalConfig[this.databasePath].tables?.get(tableName)?.config
-                    .prepend
-                    ? clonedData.toReversed()
-                    : clonedData).map(({ id }) => UtilsServer.encodeID(id))
-                : UtilsServer.encodeID(clonedData.id);
+                ? (tableConfig?.prepend ? clonedData.toReversed() : clonedData).map(({ id }) => postedID(id))
+                : postedID(clonedData.id);
         }
         finally {
             if (this.transaction) {
@@ -2896,13 +2922,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"));
             }
@@ -2911,6 +2937,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;
@@ -3001,13 +3033,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"));
                 }
@@ -3015,9 +3047,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);
@@ -3080,42 +3116,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);
@@ -3133,6 +3190,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();
@@ -3181,13 +3241,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"));
                 }
@@ -3195,9 +3255,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) {
@@ -3263,13 +3327,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"));
                     }
@@ -3277,20 +3341,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",
@@ -88,7 +88,7 @@
     "benchmark": "./benchmark/run.js",
     "benchmark:durability": "tsx ./benchmark/durability.ts",
     "benchmark:computed": "tsx ./benchmark/computed.ts",
-    "test": "tsx ./tests/inibase.test.ts && tsx ./tests/inibase.advanced.test.ts && tsx ./tests/transaction.test.ts && tsx ./tests/durability.test.ts && tsx ./tests/expression.test.ts && tsx ./tests/utils.test.ts && tsx ./tests/sum.nested.test.ts && tsx ./tests/computed.child.test.ts",
+    "test": "tsx ./tests/inibase.test.ts && tsx ./tests/inibase.advanced.test.ts && tsx ./tests/transaction.test.ts && tsx ./tests/durability.test.ts && tsx ./tests/expression.test.ts && tsx ./tests/utils.test.ts && tsx ./tests/sum.nested.test.ts && tsx ./tests/computed.child.test.ts && tsx ./tests/hardening.test.ts",
     "test:durability": "tsx ./tests/durability.test.ts",
     "test:transaction": "tsx ./tests/transaction.test.ts",
     "test:utils": "tsx ./tests/utils.test.ts",