@nklisch/pi-enhanced 0.1.0 → 0.1.2

package/node_modules/@nklisch/pi-plugins/dist/infrastructure/state/sqlite-scope-lock.js

@@ -1,37 +1,14 @@
-import { randomUUID } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
-import { mkdtemp, rm } from "node:fs/promises";
-import { chmodSync, closeSync, linkSync, lstatSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import { chmodSync, lstatSync } from "node:fs";
+import { join } from "node:path";
 import { BoundaryError } from "../../domain/errors.js";
 import { ScopeReferenceSchema, } from "../../domain/state/scope.js";
 import { ensurePrivateLockRoot, LOCAL_LOCK_DATABASE_MODE, verifyLocalFilesystemCapability, } from "./local-lock-filesystem.js";
-import { classifyProcessIdentity, readLinuxProcessStartToken } from "../process/process-identity.js";
 const PROTOCOL = "pi-plugin-host-scope-lock";
 const PROTOCOL_VERSION = 1;
 const PROTOCOL_TABLE = "scope_lock_protocol";
-const ROOT_MARKER_NAME = ".scope-lock-root.identity";
-const DATABASE_MARKER_SUFFIX = ".identity";
-const DATABASE_INITIALIZATION_CLAIM_SUFFIX = ".initializing";
-const DATABASE_HANDLE_ALIAS_SUFFIX = ".handle";
-const ROOT_MARKER_PROTOCOL = "pi-plugin-host-scope-lock-root";
-const DATABASE_MARKER_PROTOCOL = "pi-plugin-host-scope-lock-database";
 const DEFAULT_RETRY_DELAY = Object.freeze({ minimum: 2, maximum: 25 });
 const SQLITE_BUSY = 5;
-class DatabaseInitializationInProgress extends Error {
-    owner;
-    constructor(owner) {
-        super("scope lock database initialization is in progress");
-        this.owner = owner;
-        this.name = "DatabaseInitializationInProgress";
-    }
-}
-class DatabaseInitializationSnapshotChanged extends Error {
-    constructor() {
-        super("scope lock database initialization snapshot changed");
-        this.name = "DatabaseInitializationSnapshotChanged";
-    }
-}
 function assertSignal(signal) {
     if (signal === null ||
         typeof signal !== "object" ||
@@ -87,249 +64,9 @@ function scopeDatabaseName(scope) {
 function databasePath(root, scope) {
     return join(root, scopeDatabaseName(scope));
 }
-function sameFileIdentity(left, right) {
-    return left.device === right.device && left.inode === right.inode;
-}
-function regularFileIdentity(path) {
-    const stats = lstatSync(path);
-    if (stats.isSymbolicLink() || !stats.isFile())
-        throw new Error("scope lock identity path is not a regular file");
-    return { device: String(stats.dev), inode: String(stats.ino) };
-}
-function currentInitializationOwner() {
-    const startTime = readLinuxProcessStartToken(process.pid);
-    if (startTime === undefined)
-        throw new Error("scope lock cannot establish process identity");
-    return { pid: process.pid, startTime };
-}
-function ownerStatus(owner) {
-    return classifyProcessIdentity({ pid: owner.pid, startToken: owner.startTime });
-}
-function parseInitializationOwner(input) {
-    if (input === null || typeof input !== "object" || Array.isArray(input)) {
-        throw new Error("scope lock initialization owner is invalid");
-    }
-    const value = input;
-    const pid = value.pid;
-    const startTime = value.startTime;
-    if (Object.keys(value).length !== 2 ||
-        typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0 ||
-        typeof startTime !== "string" || !/^\d+$/.test(startTime)) {
-        throw new Error("scope lock initialization owner is invalid");
-    }
-    return { pid, startTime };
-}
-function parseRootIdentityMarker(input) {
-    if (input === null || typeof input !== "object" || Array.isArray(input))
-        throw new Error("scope lock root identity marker is invalid");
-    const value = input;
-    if (Object.keys(value).length !== 3 ||
-        value.protocol !== ROOT_MARKER_PROTOCOL ||
-        value.version !== 1 ||
-        typeof value.identity !== "string" ||
-        value.identity.length === 0)
-        throw new Error("scope lock root identity marker is invalid");
-    return value;
-}
-function rootIdentityMarkerPath(root) {
-    return join(root, ROOT_MARKER_NAME);
-}
-function ensureRootIdentityMarker(root) {
-    const path = rootIdentityMarkerPath(root);
-    let markerExists = false;
-    try {
-        regularFileIdentity(path);
-        markerExists = true;
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-    if (!markerExists) {
-        const marker = {
-            protocol: ROOT_MARKER_PROTOCOL,
-            version: 1,
-            identity: randomUUID(),
-        };
-        // Exclusive creation exposes an empty file before writeFileSync has
-        // populated it. Publish a complete marker through a hard-link so another
-        // first-use process can never parse a partially-written identity.
-        const temporary = `${path}.${randomUUID()}.tmp`;
-        writeFileSync(temporary, `${JSON.stringify(marker)}\n`, {
-            flag: "wx",
-            mode: LOCAL_LOCK_DATABASE_MODE,
-        });
-        try {
-            linkSync(temporary, path);
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-        }
-        finally {
-            try {
-                unlinkSync(temporary);
-            }
-            catch (error) {
-                if (error.code !== "ENOENT")
-                    throw error;
-            }
-        }
-    }
-    chmodSync(path, LOCAL_LOCK_DATABASE_MODE);
-    return parseRootIdentityMarker(JSON.parse(readFileSync(path, "utf8"))).identity;
-}
-function databaseIdentityMarkerPath(path) {
-    return `${path}${DATABASE_MARKER_SUFFIX}`;
-}
-function databaseInitializationClaimPath(path) {
-    return `${path}${DATABASE_INITIALIZATION_CLAIM_SUFFIX}`;
-}
-function parseDatabaseIdentityMarker(input) {
-    if (input === null || typeof input !== "object" || Array.isArray(input))
-        throw new Error("scope lock database identity marker is invalid");
-    const value = input;
-    if ((value.state !== "initializing" && value.state !== "ready") ||
-        Object.keys(value).length !== (value.state === "ready" ? 6 : 6) ||
-        value.protocol !== DATABASE_MARKER_PROTOCOL ||
-        value.version !== 1 ||
-        typeof value.rootIdentity !== "string" ||
-        value.rootIdentity.length === 0 ||
-        typeof value.database !== "string" ||
-        value.database.length === 0)
-        throw new Error("scope lock database identity marker is invalid");
-    if (value.state === "initializing")
-        return {
-            protocol: DATABASE_MARKER_PROTOCOL,
-            version: 1,
-            rootIdentity: value.rootIdentity,
-            database: value.database,
-            state: "initializing",
-            owner: parseInitializationOwner(value.owner),
-        };
-    const identity = value.identity;
-    if (identity === null || typeof identity !== "object" || Array.isArray(identity)) {
-        throw new Error("scope lock database identity marker is invalid");
-    }
-    const fileIdentity = identity;
-    if (Object.keys(fileIdentity).length !== 2 ||
-        typeof fileIdentity.device !== "string" ||
-        typeof fileIdentity.inode !== "string" ||
-        fileIdentity.device.length === 0 ||
-        fileIdentity.inode.length === 0)
-        throw new Error("scope lock database identity marker is invalid");
-    return {
-        protocol: DATABASE_MARKER_PROTOCOL,
-        version: 1,
-        rootIdentity: value.rootIdentity,
-        database: value.database,
-        state: "ready",
-        identity: { device: fileIdentity.device, inode: fileIdentity.inode },
-    };
-}
-function readDatabaseIdentityMarker(path) {
-    const markerPath = databaseIdentityMarkerPath(path);
-    try {
-        regularFileIdentity(markerPath);
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-        return undefined;
-    }
-    chmodSync(markerPath, LOCAL_LOCK_DATABASE_MODE);
-    return parseDatabaseIdentityMarker(JSON.parse(readFileSync(markerPath, "utf8")));
-}
-function readInitializationClaim(path) {
-    const claimPath = databaseInitializationClaimPath(path);
-    try {
-        regularFileIdentity(claimPath);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
-    const claim = parseDatabaseIdentityMarker(JSON.parse(readFileSync(claimPath, "utf8")));
-    if (claim.state !== "initializing")
-        throw new Error("scope lock initialization claim is invalid");
-    return claim;
-}
-function sameDatabaseMarker(left, right) {
-    if (left.protocol !== right.protocol || left.version !== right.version ||
-        left.rootIdentity !== right.rootIdentity || left.database !== right.database ||
-        left.state !== right.state)
-        return false;
-    if (left.state === "initializing" && right.state === "initializing") {
-        return left.owner.pid === right.owner.pid && left.owner.startTime === right.owner.startTime;
-    }
-    return left.state === "ready" && right.state === "ready" &&
-        left.identity.device === right.identity.device && left.identity.inode === right.identity.inode;
-}
-function markerMatchesDatabase(marker, rootIdentity, databaseName) {
-    return marker.rootIdentity === rootIdentity && marker.database === databaseName;
-}
-function removeIfRegular(path) {
-    try {
-        regularFileIdentity(path);
-        unlinkSync(path);
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-}
-function reclaimDeadInitialization(path, marker, rootIdentity, databaseName) {
-    if (marker.state !== "initializing")
-        throw new Error("scope lock initialization marker is not reclaimable");
-    if (!markerMatchesDatabase(marker, rootIdentity, databaseName)) {
-        throw new Error("scope lock initialization marker does not match its path");
-    }
-    const status = ownerStatus(marker.owner);
-    if (status !== "dead") {
-        throw new DatabaseInitializationInProgress(marker.owner);
-    }
-    // Only a proven-dead owner permits removing the marker, claim, and any
-    // partially-created database. Unknown and live owners remain cancellable.
-    removeIfRegular(databaseIdentityMarkerPath(path));
-    removeIfRegular(databaseInitializationClaimPath(path));
-    removeIfRegular(path);
-}
-function createExclusiveClaim(path, marker) {
-    const claimPath = databaseInitializationClaimPath(path);
-    const temporary = `${claimPath}.${randomUUID()}.tmp`;
-    writeFileSync(temporary, `${JSON.stringify(marker)}\n`, {
-        flag: "wx",
-        mode: LOCAL_LOCK_DATABASE_MODE,
-    });
-    try {
-        linkSync(temporary, claimPath);
-    }
-    finally {
-        try {
-            unlinkSync(temporary);
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-    }
-}
-function validateDatabaseIdentity(root, rootIdentity, path, databaseName, marker) {
-    if (marker.state === "initializing")
-        throw new DatabaseInitializationInProgress(marker.owner);
-    if (marker.rootIdentity !== rootIdentity ||
-        marker.database !== databaseName ||
-        basename(path) !== databaseName)
-        throw new Error("scope lock database identity marker does not match its path");
-    regularFileIdentity(rootIdentityMarkerPath(root));
-    if (parseRootIdentityMarker(JSON.parse(readFileSync(rootIdentityMarkerPath(root), "utf8"))).identity !== rootIdentity) {
-        throw new Error("scope lock root identity marker changed");
-    }
-    const identity = regularFileIdentity(path);
-    if (marker.identity === undefined || !sameFileIdentity(identity, marker.identity))
-        throw new Error("scope lock database path was replaced");
-    return identity;
+function createProtocolSchema(database) {
+    database.exec(`CREATE TABLE IF NOT EXISTS ${PROTOCOL_TABLE} (protocol TEXT PRIMARY KEY NOT NULL CHECK (protocol = '${PROTOCOL}'), version INTEGER NOT NULL CHECK (version = ${PROTOCOL_VERSION})) STRICT;`);
+    database.prepare(`INSERT OR IGNORE INTO ${PROTOCOL_TABLE} (protocol, version) VALUES ('${PROTOCOL}', ${PROTOCOL_VERSION})`).run();
 }
 function validateProtocolSchema(database) {
     const objects = database
@@ -369,227 +106,47 @@ function validateProtocolSchema(database) {
         throw new Error("scope lock protocol version is invalid");
     }
 }
-function validateOpenedDatabaseIdentity(prepared, root, rootIdentity, path, databaseName, marker) {
-    const pathIdentity = validateDatabaseIdentity(root, rootIdentity, path, databaseName, marker);
-    const aliasIdentity = regularFileIdentity(prepared.aliasPath);
-    if (!sameFileIdentity(pathIdentity, aliasIdentity)) {
-        throw new Error("scope lock opened database handle identity does not match its marker");
-    }
-}
-async function prepareDatabase(root, rootIdentity, path, databaseName, retryingMissingMarkerDatabase = false, initializationMarkerRead) {
-    const owner = currentInitializationOwner();
-    for (;;) {
-        let marker = readDatabaseIdentityMarker(path);
-        await initializationMarkerRead?.({
-            path,
-            databaseName,
-            markerState: marker?.state ?? "absent",
-        });
-        let existing = true;
-        try {
-            regularFileIdentity(path);
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-            existing = false;
-        }
-        if (marker?.state === "initializing") {
-            reclaimDeadInitialization(path, marker, rootIdentity, databaseName);
-            continue;
-        }
-        if (marker === undefined && existing) {
-            // The marker and database path are independent files. A first-use loser
-            // can read the old marker state, yield to the winner, then observe the
-            // newly-created database through its later path check. That combination
-            // is stale evidence, not proof of an orphan. Retry once through the
-            // caller's cancellable acquisition loop; if the same coherent state is
-            // still present, fail closed rather than adopting the database.
-            const claim = readInitializationClaim(path);
-            if (claim !== undefined) {
-                reclaimDeadInitialization(path, claim, rootIdentity, databaseName);
-                continue;
-            }
-            if (retryingMissingMarkerDatabase)
-                throw new Error("scope lock database identity marker is missing");
-            throw new DatabaseInitializationSnapshotChanged();
-        }
-        if (marker === undefined) {
-            if (existing)
-                throw new Error("scope lock database identity marker is missing");
-            const initializing = {
-                protocol: DATABASE_MARKER_PROTOCOL,
-                version: 1,
-                rootIdentity,
-                database: databaseName,
-                state: "initializing",
-                owner,
-            };
-            try {
-                // The claim is a complete atomically-linked file. The marker is then
-                // published by rename, so a crash at either boundary leaves an owner
-                // identity that a later process can evaluate without guessing.
-                createExclusiveClaim(path, initializing);
-                const temporary = `${databaseIdentityMarkerPath(path)}.${randomUUID()}.tmp`;
-                writeFileSync(temporary, `${JSON.stringify(initializing)}\n`, {
-                    flag: "wx",
-                    mode: LOCAL_LOCK_DATABASE_MODE,
-                });
-                try {
-                    renameSync(temporary, databaseIdentityMarkerPath(path));
-                }
-                finally {
-                    try {
-                        unlinkSync(temporary);
-                    }
-                    catch (error) {
-                        if (error.code !== "ENOENT")
-                            throw error;
-                    }
-                }
-                marker = initializing;
-            }
-            catch (error) {
-                if (error.code !== "EEXIST")
-                    throw error;
-                const observed = readDatabaseIdentityMarker(path) ?? readInitializationClaim(path);
-                if (observed === undefined)
-                    throw new Error("scope lock initialization claim disappeared");
-                if (observed.state === "initializing")
-                    reclaimDeadInitialization(path, observed, rootIdentity, databaseName);
-                continue;
-            }
-        }
-        if (marker === undefined)
-            throw new Error("scope lock database identity marker disappeared");
-        if (marker.state === "ready" && !existing) {
-            throw new Error("scope lock database is missing after initialization");
-        }
-        let created = false;
-        if (!existing) {
-            let descriptor;
-            try {
-                descriptor = openSync(path, "wx", LOCAL_LOCK_DATABASE_MODE);
-            }
-            catch (error) {
-                if (error.code === "EEXIST") {
-                    const observed = readDatabaseIdentityMarker(path) ?? readInitializationClaim(path);
-                    if (observed?.state === "initializing")
-                        throw new DatabaseInitializationInProgress(observed.owner);
-                    throw new DatabaseInitializationInProgress();
-                }
-                throw error;
-            }
-            closeSync(descriptor);
-            const identity = regularFileIdentity(path);
-            marker = {
-                protocol: DATABASE_MARKER_PROTOCOL,
-                version: 1,
-                rootIdentity,
-                database: databaseName,
-                state: "ready",
-                identity,
-            };
-            created = true;
-        }
-        validateDatabaseIdentity(root, rootIdentity, path, databaseName, marker);
-        const aliasPath = `${path}${DATABASE_HANDLE_ALIAS_SUFFIX}-${randomUUID()}`;
-        let database;
-        let aliasLinked = false;
-        try {
-            // DatabaseSync accepts a path rather than an fd. A private hard-link
-            // alias pins the exact inode the native handle opens; the durable path
-            // and marker are checked separately before BEGIN and on every assert.
-            linkSync(path, aliasPath);
-            aliasLinked = true;
-            database = new DatabaseSync(aliasPath, {
-                allowExtension: false,
-                defensive: true,
-                enableDoubleQuotedStringLiterals: false,
-                enableForeignKeyConstraints: true,
-                readOnly: false,
-                timeout: 0,
-            });
-            const prepared = { database, aliasPath };
-            validateOpenedDatabaseIdentity(prepared, root, rootIdentity, path, databaseName, marker);
-            database.enableLoadExtension(false);
-            database.enableDefensive(true);
-            chmodSync(path, LOCAL_LOCK_DATABASE_MODE);
-            if (process.platform !== "win32" && (lstatSync(path).mode & 0o777) !== LOCAL_LOCK_DATABASE_MODE) {
-                throw new Error("scope lock database is not private");
-            }
-            database.exec("PRAGMA journal_mode = DELETE; PRAGMA locking_mode = NORMAL; PRAGMA foreign_keys = ON; PRAGMA trusted_schema = OFF;");
-            if (created) {
-                database.exec(`CREATE TABLE ${PROTOCOL_TABLE} (protocol TEXT PRIMARY KEY NOT NULL CHECK (protocol = '${PROTOCOL}'), version INTEGER NOT NULL CHECK (version = ${PROTOCOL_VERSION})) STRICT;`);
-                database.exec(`INSERT INTO ${PROTOCOL_TABLE} (protocol, version) VALUES ('${PROTOCOL}', ${PROTOCOL_VERSION});`);
-            }
-            validateProtocolSchema(database);
-            validateOpenedDatabaseIdentity(prepared, root, rootIdentity, path, databaseName, marker);
-            const journal = database.prepare("PRAGMA journal_mode").get();
-            if (journal?.journal_mode !== "delete")
-                throw new Error("scope lock database is not using rollback journal mode");
-            if (created) {
-                const temporary = `${databaseIdentityMarkerPath(path)}.${randomUUID()}.tmp`;
-                try {
-                    writeFileSync(temporary, `${JSON.stringify(marker)}\n`, { flag: "wx", mode: LOCAL_LOCK_DATABASE_MODE });
-                    renameSync(temporary, databaseIdentityMarkerPath(path));
-                    unlinkSync(databaseInitializationClaimPath(path));
-                }
-                catch (error) {
-                    throw new Error("scope lock database identity marker could not be finalized", { cause: error });
-                }
-            }
-            const durableMarker = readDatabaseIdentityMarker(path);
-            if (durableMarker === undefined || !sameDatabaseMarker(durableMarker, marker)) {
-                throw new Error("scope lock database identity marker changed during setup");
-            }
-            validateOpenedDatabaseIdentity(prepared, root, rootIdentity, path, databaseName, durableMarker);
-            return prepared;
-        }
-        catch (error) {
-            let closeError;
-            try {
-                if (database?.isOpen)
-                    database.close();
-            }
-            catch (cause) {
-                closeError = cause;
-            }
-            if (aliasLinked) {
-                try {
-                    unlinkSync(aliasPath);
-                }
-                catch (cause) {
-                    closeError = closeError === undefined ? cause : { close: closeError, unlink: cause };
-                }
-            }
-            if (closeError !== undefined)
-                throw new Error("scope lock database setup and cleanup failed", { cause: { error, closeError } });
-            throw error;
-        }
-    }
-}
-async function closeDatabase(prepared) {
-    let closeError;
+/**
+ * Open the scope database and take the write lock. The lock itself is the
+ * held BEGIN IMMEDIATE transaction; first-use schema setup runs under the
+ * same transaction so concurrent creators serialize on the database. No
+ * sidecar marker, claim, or alias files exist to drift across mounts or
+ * strand a later process — a killed holder's transaction is released by the
+ * OS and the next acquirer proceeds after the busy window.
+ */
+function openLockedDatabase(path) {
+    const database = new DatabaseSync(path, {
+        allowExtension: false,
+        defensive: true,
+        enableDoubleQuotedStringLiterals: false,
+        enableForeignKeyConstraints: true,
+        readOnly: false,
+        timeout: 0,
+    });
     try {
-        if (prepared.database.isOpen)
-            prepared.database.close();
+        const stats = lstatSync(path);
+        if (!stats.isFile() || stats.isSymbolicLink())
+            throw new Error("scope lock database is not a regular file");
+        chmodSync(path, LOCAL_LOCK_DATABASE_MODE);
+        if (process.platform !== "win32" && (lstatSync(path).mode & 0o777) !== LOCAL_LOCK_DATABASE_MODE) {
+            throw new Error("scope lock database is not private");
+        }
+        database.exec("PRAGMA journal_mode = DELETE; PRAGMA locking_mode = NORMAL; PRAGMA foreign_keys = ON; PRAGMA trusted_schema = OFF;");
+        database.exec("BEGIN IMMEDIATE");
+        createProtocolSchema(database);
+        validateProtocolSchema(database);
+        const journal = database.prepare("PRAGMA journal_mode").get();
+        if (journal?.journal_mode !== "delete")
+            throw new Error("scope lock database is not using rollback journal mode");
+        return database;
     }
     catch (error) {
-        closeError = error;
-    }
-    finally {
         try {
-            unlinkSync(prepared.aliasPath);
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                closeError = closeError === undefined ? error : { close: closeError, unlink: error };
-            }
+            database.close();
         }
+        catch { /* preserve primary failure */ }
+        throw error;
     }
-    if (closeError !== undefined)
-        throw closeError;
 }
 async function waitForRetry(delayMs, signal) {
     throwIfAborted(signal);
@@ -612,39 +169,19 @@ async function waitForRetry(delayMs, signal) {
     });
 }
 class SqliteScopeLockLease {
-    prepared;
-    root;
-    rootIdentity;
-    path;
-    databaseName;
-    marker;
+    database;
     scope;
     status = "held";
-    constructor(scope, prepared, root, rootIdentity, path, databaseName, marker) {
-        this.prepared = prepared;
-        this.root = root;
-        this.rootIdentity = rootIdentity;
-        this.path = path;
-        this.databaseName = databaseName;
-        this.marker = marker;
+    constructor(scope, database) {
+        this.database = database;
         this.scope = scope;
     }
     async assertOwned(signal) {
         assertSignal(signal);
         throwIfAborted(signal);
-        if (this.status !== "held" || !this.prepared.database.isOpen || !this.prepared.database.isTransaction) {
+        if (this.status !== "held" || !this.database.isOpen || !this.database.isTransaction) {
             throw adapterFailure("scope-lock.assert-owned", new Error("scope lock is no longer held"));
         }
-        try {
-            const marker = readDatabaseIdentityMarker(this.path);
-            if (marker === undefined || !sameDatabaseMarker(marker, this.marker)) {
-                throw new Error("scope lock database identity marker changed during ownership");
-            }
-            validateOpenedDatabaseIdentity(this.prepared, this.root, this.rootIdentity, this.path, this.databaseName, marker);
-        }
-        catch (error) {
-            throw adapterFailure("scope-lock.assert-owned", error);
-        }
     }
     async release() {
         if (this.status === "released")
@@ -652,21 +189,22 @@ class SqliteScopeLockLease {
         let rollbackError;
         let closeError;
         try {
-            if (this.prepared.database.isOpen && this.prepared.database.isTransaction)
-                this.prepared.database.exec("ROLLBACK");
+            if (this.database.isOpen && this.database.isTransaction)
+                this.database.exec("ROLLBACK");
         }
         catch (error) {
             rollbackError = error;
         }
         finally {
             try {
-                await closeDatabase(this.prepared);
+                if (this.database.isOpen)
+                    this.database.close();
             }
             catch (error) {
                 closeError = error;
             }
         }
-        if (!this.prepared.database.isOpen && closeError === undefined)
+        if (!this.database.isOpen && closeError === undefined)
             this.status = "released";
         else
             this.status = "uncertain";
@@ -677,43 +215,31 @@ class SqliteScopeLockLease {
 }
 class SqliteScopeLockManager {
     root;
-    rootIdentity;
     retryDelayMs;
     random;
-    initializationMarkerRead;
-    constructor(root, rootIdentity, retryDelayMs, random, initializationMarkerRead) {
+    constructor(root, retryDelayMs, random) {
         this.root = root;
-        this.rootIdentity = rootIdentity;
         this.retryDelayMs = retryDelayMs;
         this.random = random;
-        this.initializationMarkerRead = initializationMarkerRead;
     }
     async acquire(input, signal) {
         assertSignal(signal);
         const scope = ScopeReferenceSchema.parse(input);
         const path = databasePath(this.root, scope);
-        let retryingMissingMarkerDatabase = false;
         for (;;) {
             throwIfAborted(signal);
-            let prepared;
+            let database;
             try {
-                const databaseName = scopeDatabaseName(scope);
-                prepared = await prepareDatabase(this.root, this.rootIdentity, path, databaseName, retryingMissingMarkerDatabase, this.initializationMarkerRead);
-                prepared.database.exec("BEGIN IMMEDIATE");
-                if (signal.aborted) {
-                    await closeDatabase(prepared);
+                database = openLockedDatabase(path);
+                if (signal.aborted)
                     throw signal.reason;
-                }
-                const marker = readDatabaseIdentityMarker(path);
-                if (marker === undefined)
-                    throw new Error("scope lock database identity marker disappeared");
-                validateOpenedDatabaseIdentity(prepared, this.root, this.rootIdentity, path, databaseName, marker);
-                return new SqliteScopeLockLease(scope, prepared, this.root, this.rootIdentity, path, databaseName, marker);
+                return new SqliteScopeLockLease(scope, database);
             }
             catch (error) {
-                if (prepared !== undefined) {
+                if (database !== undefined) {
                     try {
-                        await closeDatabase(prepared);
+                        if (database.isOpen)
+                            database.close();
                     }
                     catch (closeError) {
                         throw adapterFailure("scope-lock.acquire", cleanupCause(error, closeError));
@@ -721,17 +247,6 @@ class SqliteScopeLockManager {
                 }
                 if (signal.aborted)
                     throw signal.reason;
-                if (error instanceof DatabaseInitializationInProgress) {
-                    const delay = await this.retryDelay();
-                    await waitForRetry(delay, signal);
-                    continue;
-                }
-                if (error instanceof DatabaseInitializationSnapshotChanged) {
-                    retryingMissingMarkerDatabase = true;
-                    const delay = await this.retryDelay();
-                    await waitForRetry(delay, signal);
-                    continue;
-                }
                 if (!isBusy(error))
                     throw adapterFailure("scope-lock.acquire", error);
                 const delay = await this.retryDelay();
@@ -753,54 +268,7 @@ class SqliteScopeLockManager {
         return Math.floor(this.retryDelayMs.minimum + value * (this.retryDelayMs.maximum - this.retryDelayMs.minimum));
     }
 }
-async function probeExclusion(root, rootIdentity) {
-    const probeDirectory = await mkdtemp(join(root, ".scope-lock-probe-"));
-    const path = join(probeDirectory, "probe.sqlite");
-    let holder;
-    let contender;
-    let released;
-    try {
-        holder = await prepareDatabase(root, rootIdentity, path, "probe.sqlite");
-        holder.database.exec("BEGIN IMMEDIATE");
-        try {
-            contender = await prepareDatabase(root, rootIdentity, path, "probe.sqlite");
-            contender.database.exec("BEGIN IMMEDIATE");
-            throw new Error("SQLite did not exclude a second writer");
-        }
-        catch (error) {
-            if (!isBusy(error))
-                throw error;
-        }
-        if (contender !== undefined)
-            await closeDatabase(contender);
-        contender = undefined;
-        holder.database.exec("ROLLBACK");
-        await closeDatabase(holder);
-        holder = undefined;
-        released = await prepareDatabase(root, rootIdentity, path, "probe.sqlite");
-        released.database.exec("BEGIN IMMEDIATE");
-        released.database.exec("ROLLBACK");
-        await closeDatabase(released);
-        released = undefined;
-    }
-    finally {
-        for (const prepared of [contender, holder, released]) {
-            if (prepared !== undefined) {
-                try {
-                    await closeDatabase(prepared);
-                }
-                catch {
-                    // The probe is failing anyway; cleanup must not expose a native error.
-                }
-            }
-        }
-        await rm(probeDirectory, { recursive: true, force: true });
-    }
-}
-/**
- * Create a scope lock manager after proving the configured root has the
- * capabilities this safety boundary needs. No process-local fallback exists.
- */
+/** Create a scope lock manager rooted at a private, local-filesystem directory. */
 export async function createSqliteScopeLockManager(options) {
     if (options === null || typeof options !== "object")
         throw new TypeError("scope lock options are required");
@@ -811,10 +279,8 @@ export async function createSqliteScopeLockManager(options) {
         throw adapterFailure("scope-lock.initialize", error);
     });
     try {
-        const rootIdentity = ensureRootIdentityMarker(root);
         await (options.verifyLocalFilesystem ?? verifyLocalFilesystemCapability)(root);
-        await probeExclusion(root, rootIdentity);
-        return new SqliteScopeLockManager(root, rootIdentity, retryDelayMs, random, options.initializationMarkerRead);
+        return new SqliteScopeLockManager(root, retryDelayMs, random);
     }
     catch (error) {
         if (error instanceof BoundaryError)