@modelprofile.com/browser-runtime 3.2.0 → 4.0.0

package/dist_ts/classes.runtimeownership.js

@@ -0,0 +1,1230 @@
+import * as plugins from './plugins.js';
+import { BrowserRuntimeError } from './errors.js';
+import { randomId } from './utils.js';
+const metadataSchema = 1;
+const maximumMetadataBytes = 4096;
+const maximumProcFileBytes = 2 * 1024 * 1024;
+const anchorInitializationAttempts = 200;
+const generationIdPattern = /^[A-Za-z0-9_-]{32}$/u;
+const hashPattern = /^[a-f0-9]{64}$/u;
+const bootIdPattern = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/u;
+const unsignedIntegerPattern = /^(?:0|[1-9][0-9]{0,24})$/u;
+const isMissingError = (errorArg) => (errorArg.code === 'ENOENT'
+    || errorArg.code === 'ESRCH');
+const normalizeOwnershipError = (errorArg) => (errorArg instanceof BrowserRuntimeError
+    ? errorArg
+    : new BrowserRuntimeError('FENCED', 'runtime ownership could not be verified'));
+const statIdentityMatches = (leftArg, rightArg) => leftArg.dev === rightArg.dev && leftArg.ino === rightArg.ino;
+const parseProcessStartTicks = (statTextArg, expectedPidArg) => {
+    if (plugins.Buffer.byteLength(statTextArg, 'utf8') === 0
+        || plugins.Buffer.byteLength(statTextArg, 'utf8') > 16 * 1024
+        || /[\u0000\r]/u.test(statTextArg))
+        throw new BrowserRuntimeError('FENCED', 'process identity is malformed');
+    const statText = statTextArg.endsWith('\n') ? statTextArg.slice(0, -1) : statTextArg;
+    if (statText.includes('\n')) {
+        throw new BrowserRuntimeError('FENCED', 'process identity is malformed');
+    }
+    const commandStart = statText.indexOf(' (');
+    const commandEnd = statText.lastIndexOf(') ');
+    if (commandStart <= 0 || commandEnd < commandStart + 2) {
+        throw new BrowserRuntimeError('FENCED', 'process identity is malformed');
+    }
+    const pidText = statText.slice(0, commandStart);
+    const fieldsAfterCommand = statText.slice(commandEnd + 2).split(' ');
+    const processStartTicks = fieldsAfterCommand[19];
+    if (!/^[1-9][0-9]{0,9}$/u.test(pidText)
+        || fieldsAfterCommand.length < 20
+        || !processStartTicks
+        || !unsignedIntegerPattern.test(processStartTicks))
+        throw new BrowserRuntimeError('FENCED', 'process identity is malformed');
+    if (expectedPidArg !== undefined && Number(pidText) !== expectedPidArg) {
+        throw new BrowserRuntimeError('FENCED', 'process identity is malformed');
+    }
+    return processStartTicks;
+};
+export class BrowserRuntimeOwnership {
+    runtimeDirectory;
+    lockPath;
+    anchorDirectory;
+    generationsRoot;
+    legacyProfileRoot;
+    legacyArtifactRoot;
+    uid;
+    procRoot;
+    now;
+    beforeMetadataPublication;
+    beforeGenerationRemoval;
+    onOwnershipLost;
+    directoryHandle;
+    directoryIdentity;
+    anchorDirectoryHandle;
+    anchorDirectoryIdentity;
+    anchorIdentity;
+    namedMutex;
+    namedMutexLease;
+    lockHandle;
+    lockIdentity;
+    createdLock = false;
+    leaseLost = false;
+    metadata;
+    generation;
+    acquirePromise;
+    releasePromise;
+    constructor(optionsArg) {
+        this.runtimeDirectory = plugins.path.resolve(optionsArg.runtimeDirectory);
+        this.lockPath = plugins.path.join(this.runtimeDirectory, 'runtime.lock');
+        this.anchorDirectory = plugins.path.join(this.runtimeDirectory, 'runtime.mutex');
+        this.generationsRoot = plugins.path.join(this.runtimeDirectory, 'generations');
+        this.legacyProfileRoot = plugins.path.join(this.runtimeDirectory, 'profiles');
+        this.legacyArtifactRoot = plugins.path.join(this.runtimeDirectory, 'artifacts');
+        this.uid = optionsArg.uid;
+        this.procRoot = optionsArg.testing?.procRoot ?? '/proc';
+        this.now = optionsArg.testing?.now ?? Date.now;
+        this.beforeMetadataPublication = optionsArg.testing?.beforeMetadataPublication;
+        this.beforeGenerationRemoval = optionsArg.testing?.beforeGenerationRemoval;
+        this.onOwnershipLost = optionsArg.onOwnershipLost;
+    }
+    get owned() {
+        return Boolean(this.metadata?.state === 'active'
+            && this.generation
+            && this.namedMutexLease?.state === 'active'
+            && !this.leaseLost);
+    }
+    get cleanupPending() {
+        return Boolean(this.lockHandle
+            || this.anchorDirectoryHandle
+            || this.directoryHandle
+            || (this.namedMutexLease && this.namedMutexLease.state !== 'released'));
+    }
+    acquire() {
+        if (this.owned)
+            return Promise.resolve({ ...this.generation });
+        if (this.acquirePromise)
+            return this.acquirePromise;
+        if (this.releasePromise)
+            return this.releasePromise.then(() => this.acquire());
+        const operation = this.acquireInternal().finally(() => {
+            if (this.acquirePromise === operation)
+                this.acquirePromise = undefined;
+        });
+        this.acquirePromise = operation;
+        return operation;
+    }
+    release(reasonArg = 'stop') {
+        if (this.releasePromise)
+            return this.releasePromise;
+        if (!this.namedMutexLease
+            && !this.lockHandle
+            && !this.anchorDirectoryHandle
+            && !this.directoryHandle)
+            return Promise.resolve();
+        const operation = this.releaseInternal(reasonArg).catch((error) => {
+            throw normalizeOwnershipError(error);
+        }).finally(() => {
+            if (this.releasePromise === operation)
+                this.releasePromise = undefined;
+        });
+        this.releasePromise = operation;
+        return operation;
+    }
+    /** @internal */
+    async assertCurrentOwnership() {
+        if (!this.owned)
+            throw new BrowserRuntimeError('FENCED', 'runtime ownership is unavailable');
+        await this.assertRuntimeDirectoryCurrent();
+        await this.assertNativeAnchorCurrent();
+        await this.assertLockPathCurrent();
+    }
+    async acquireInternal() {
+        try {
+            await this.openAndValidateRuntimeDirectory();
+            await this.openAndValidateAnchorDirectory();
+            await this.acquireNativeLease();
+            const lockKind = await this.openAndClassifyLock();
+            if (lockKind.kind === 'new') {
+                await this.adoptCreatedLockLayout();
+            }
+            else if (lockKind.kind === 'legacy') {
+                await this.adoptLegacyLock();
+            }
+            else {
+                await this.reclaimMetadataGeneration(lockKind.metadata);
+            }
+            const generation = await this.publishGeneration();
+            return { ...generation };
+        }
+        catch (error) {
+            const normalized = normalizeOwnershipError(error);
+            if (this.metadata?.state === 'active' && this.generation) {
+                try {
+                    await this.release('startup-failure');
+                }
+                catch {
+                    throw new BrowserRuntimeError('FENCED', 'runtime startup cleanup is incomplete');
+                }
+            }
+            else {
+                if (this.createdLock) {
+                    let cleanupError;
+                    try {
+                        await this.unlinkCreatedLock();
+                    }
+                    catch (error) {
+                        cleanupError = error;
+                    }
+                    if (cleanupError && this.createdLock) {
+                        throw new BrowserRuntimeError('FENCED', 'runtime startup cleanup is incomplete');
+                    }
+                    if (cleanupError) {
+                        await this.closePassiveHandles().catch(() => {
+                            throw new BrowserRuntimeError('FENCED', 'runtime startup cleanup is incomplete');
+                        });
+                        throw new BrowserRuntimeError('FENCED', 'runtime startup cleanup is incomplete');
+                    }
+                }
+                await this.closePassiveHandles();
+            }
+            throw normalized;
+        }
+    }
+    async openAndValidateRuntimeDirectory() {
+        const createdPath = await plugins.fsPromises.mkdir(this.runtimeDirectory, {
+            recursive: true,
+            mode: 0o700,
+        });
+        let pathStat = await plugins.fsPromises.lstat(this.runtimeDirectory, { bigint: true });
+        if (!pathStat.isDirectory()
+            || pathStat.isSymbolicLink()
+            || pathStat.uid !== BigInt(this.uid))
+            throw new BrowserRuntimeError('FENCED', 'runtime directory is not private');
+        if (createdPath !== undefined) {
+            await plugins.fsPromises.chmod(this.runtimeDirectory, 0o700);
+            pathStat = await plugins.fsPromises.lstat(this.runtimeDirectory, { bigint: true });
+        }
+        if ((pathStat.mode & 511n) !== 448n) {
+            throw new BrowserRuntimeError('FENCED', 'runtime directory is not private');
+        }
+        const realPath = await plugins.fsPromises.realpath(this.runtimeDirectory);
+        if (realPath !== this.runtimeDirectory) {
+            throw new BrowserRuntimeError('FENCED', 'runtime directory path is not canonical');
+        }
+        const handle = await plugins.fsPromises.open(this.runtimeDirectory, plugins.fs.constants.O_RDONLY
+            | plugins.fs.constants.O_DIRECTORY
+            | plugins.fs.constants.O_NOFOLLOW);
+        this.directoryHandle = handle;
+        let handleStat = await handle.stat({ bigint: true });
+        if (createdPath !== undefined) {
+            await handle.chmod(0o700);
+            await plugins.fsPromises.chmod(this.runtimeDirectory, 0o700);
+            [pathStat, handleStat] = await Promise.all([
+                plugins.fsPromises.lstat(this.runtimeDirectory, { bigint: true }),
+                handle.stat({ bigint: true }),
+            ]);
+        }
+        if (!handleStat.isDirectory()
+            || handleStat.uid !== BigInt(this.uid)
+            || (handleStat.mode & 511n) !== 448n
+            || !statIdentityMatches(pathStat, handleStat)) {
+            throw new BrowserRuntimeError('FENCED', 'runtime directory identity changed');
+        }
+        const pathHash = plugins.crypto.createHash('sha256')
+            .update(this.runtimeDirectory, 'utf8')
+            .digest('hex');
+        const device = String(handleStat.dev);
+        const inode = String(handleStat.ino);
+        const hash = plugins.crypto.createHash('sha256')
+            .update(`${this.uid}\0${device}\0${inode}\0${pathHash}`, 'utf8')
+            .digest('hex');
+        this.directoryIdentity = { uid: this.uid, device, inode, hash };
+    }
+    async openAndValidateAnchorDirectory() {
+        await this.ensurePrivateDirectory(this.anchorDirectory, this.runtimeDirectory);
+        const handle = await plugins.fsPromises.open(this.anchorDirectory, plugins.fs.constants.O_RDONLY
+            | plugins.fs.constants.O_DIRECTORY
+            | plugins.fs.constants.O_NOFOLLOW);
+        try {
+            const [pathStat, handleStat] = await Promise.all([
+                plugins.fsPromises.lstat(this.anchorDirectory, { bigint: true }),
+                handle.stat({ bigint: true }),
+            ]);
+            if (!pathStat.isDirectory()
+                || pathStat.isSymbolicLink()
+                || pathStat.uid !== BigInt(this.uid)
+                || (pathStat.mode & 511n) !== 448n
+                || !statIdentityMatches(pathStat, handleStat)
+                || String(handleStat.dev) !== this.directoryIdentity.device)
+                throw new BrowserRuntimeError('FENCED', 'runtime mutex anchor directory is unsafe');
+            this.anchorDirectoryHandle = handle;
+            this.anchorDirectoryIdentity = handleStat;
+        }
+        catch (error) {
+            await handle.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    async acquireNativeLease() {
+        const identity = this.directoryIdentity;
+        let mutex;
+        try {
+            mutex = new plugins.smartipc.NamedMutex(`@modelprofile.com/browser-runtime:v1:${identity.uid}:${identity.device}:${identity.inode}:${identity.hash}`, { directoryPath: this.anchorDirectory });
+        }
+        catch {
+            throw new BrowserRuntimeError('FENCED', 'runtime native ownership backend is unavailable');
+        }
+        await this.ensurePermanentAnchor(mutex.anchorPath);
+        let lease;
+        try {
+            lease = await mutex.tryAcquire();
+        }
+        catch {
+            throw new BrowserRuntimeError('FENCED', 'runtime native ownership could not be verified');
+        }
+        if (!lease)
+            throw new BrowserRuntimeError('LOCKED');
+        this.namedMutex = mutex;
+        this.namedMutexLease = lease;
+        this.leaseLost = false;
+        this.anchorIdentity = await plugins.fsPromises.lstat(mutex.anchorPath, { bigint: true });
+        await this.assertNativeAnchorCurrent();
+    }
+    async ensurePermanentAnchor(anchorPathArg) {
+        if (!this.pathIsWithin(this.anchorDirectory, anchorPathArg)
+            || plugins.path.dirname(anchorPathArg) !== this.anchorDirectory)
+            throw new BrowserRuntimeError('FENCED', 'runtime mutex anchor escaped containment');
+        const anchorName = plugins.path.basename(anchorPathArg);
+        const entries = await plugins.fsPromises.readdir(this.anchorDirectory, { withFileTypes: true });
+        if (entries.some((entry) => entry.name !== anchorName)) {
+            throw new BrowserRuntimeError('FENCED', 'runtime mutex anchor directory is ambiguous');
+        }
+        let handle;
+        try {
+            handle = await plugins.fsPromises.open(anchorPathArg, plugins.fs.constants.O_RDWR
+                | plugins.fs.constants.O_CREAT
+                | plugins.fs.constants.O_EXCL
+                | plugins.fs.constants.O_NOFOLLOW, 0o600);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            for (let attempt = 0; attempt < anchorInitializationAttempts; attempt += 1) {
+                const stat = await plugins.fsPromises.lstat(anchorPathArg, { bigint: true });
+                if (stat.isFile()
+                    && !stat.isSymbolicLink()
+                    && stat.uid === BigInt(this.uid)
+                    && stat.nlink === 1n
+                    && stat.size === 0n
+                    && String(stat.dev) === this.directoryIdentity.device) {
+                    const mode = stat.mode & 511n;
+                    if (mode === 384n)
+                        return;
+                    if ((mode & 127n) !== 0n) {
+                        throw new BrowserRuntimeError('FENCED', 'runtime mutex anchor is unsafe');
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 10));
+                    continue;
+                }
+                throw new BrowserRuntimeError('FENCED', 'runtime mutex anchor is unsafe');
+            }
+            throw new BrowserRuntimeError('FENCED', 'runtime mutex anchor initialization is incomplete');
+        }
+        try {
+            await handle.chmod(0o600);
+            await plugins.fsPromises.chmod(anchorPathArg, 0o600);
+            const [pathStat, handleStat] = await Promise.all([
+                plugins.fsPromises.lstat(anchorPathArg, { bigint: true }),
+                handle.stat({ bigint: true }),
+            ]);
+            this.assertPrivateAnchorStat(pathStat);
+            this.assertPrivateAnchorStat(handleStat);
+            if (!statIdentityMatches(pathStat, handleStat)) {
+                throw new BrowserRuntimeError('FENCED', 'runtime mutex anchor identity changed');
+            }
+            await handle.sync();
+            await this.anchorDirectoryHandle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    assertPrivateAnchorStat(statArg) {
+        if (!statArg.isFile()
+            || statArg.isSymbolicLink()
+            || statArg.uid !== BigInt(this.uid)
+            || (statArg.mode & 511n) !== 384n
+            || statArg.nlink !== 1n
+            || statArg.size !== 0n
+            || String(statArg.dev) !== this.directoryIdentity.device)
+            throw new BrowserRuntimeError('FENCED', 'runtime mutex anchor is unsafe');
+    }
+    async assertNativeAnchorCurrent() {
+        if (!this.namedMutex
+            || !this.namedMutexLease
+            || this.namedMutexLease.state !== 'active'
+            || !this.anchorIdentity
+            || !this.anchorDirectoryHandle
+            || !this.anchorDirectoryIdentity
+            || this.leaseLost)
+            throw new BrowserRuntimeError('FENCED', 'runtime native ownership is unavailable');
+        const [directoryPathStat, directoryHandleStat, anchorStat] = await Promise.all([
+            plugins.fsPromises.lstat(this.anchorDirectory, { bigint: true }),
+            this.anchorDirectoryHandle.stat({ bigint: true }),
+            plugins.fsPromises.lstat(this.namedMutex.anchorPath, { bigint: true }),
+        ]);
+        if (!directoryPathStat.isDirectory()
+            || directoryPathStat.isSymbolicLink()
+            || directoryPathStat.uid !== BigInt(this.uid)
+            || (directoryPathStat.mode & 511n) !== 448n
+            || !statIdentityMatches(this.anchorDirectoryIdentity, directoryPathStat)
+            || !statIdentityMatches(this.anchorDirectoryIdentity, directoryHandleStat)
+            || String(directoryHandleStat.dev) !== this.directoryIdentity.device)
+            throw new BrowserRuntimeError('FENCED', 'runtime mutex anchor directory identity changed');
+        this.assertPrivateAnchorStat(anchorStat);
+        if (!statIdentityMatches(this.anchorIdentity, anchorStat)) {
+            throw new BrowserRuntimeError('FENCED', 'runtime mutex anchor identity changed');
+        }
+    }
+    /** @internal */
+    async forceOwnershipLossForTesting() {
+        if (!this.namedMutexLease || this.leaseLost)
+            return;
+        let releaseError;
+        try {
+            await this.namedMutexLease.release();
+        }
+        catch (error) {
+            releaseError = error;
+        }
+        this.leaseLost = true;
+        this.onOwnershipLost?.();
+        if (releaseError) {
+            throw new BrowserRuntimeError('FENCED', 'runtime native ownership release is uncertain');
+        }
+    }
+    async openAndClassifyLock() {
+        let handle;
+        try {
+            handle = await plugins.fsPromises.open(this.lockPath, plugins.fs.constants.O_RDWR
+                | plugins.fs.constants.O_CREAT
+                | plugins.fs.constants.O_EXCL
+                | plugins.fs.constants.O_NOFOLLOW, 0o600);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const pathStat = await this.readPrivateLockPathStat();
+            handle = await plugins.fsPromises.open(this.lockPath, plugins.fs.constants.O_RDWR | plugins.fs.constants.O_NOFOLLOW);
+            let handleStat;
+            try {
+                handleStat = await this.validateLockHandle(handle);
+            }
+            catch (validationError) {
+                await handle.close().catch(() => undefined);
+                throw validationError;
+            }
+            if (!statIdentityMatches(pathStat, handleStat)) {
+                await handle.close();
+                throw new BrowserRuntimeError('FENCED', 'runtime lock identity changed');
+            }
+            this.lockHandle = handle;
+            this.lockIdentity = handleStat;
+            await this.assertLockPathCurrent();
+            if (handleStat.size === 0n)
+                return { kind: 'legacy' };
+            return { kind: 'metadata', metadata: await this.readMetadata() };
+        }
+        this.lockHandle = handle;
+        this.createdLock = true;
+        await handle.chmod(0o600);
+        const initialHandleStat = await handle.stat({ bigint: true });
+        const initialPathStat = await plugins.fsPromises.lstat(this.lockPath, { bigint: true });
+        if (!initialHandleStat.isFile()
+            || !initialPathStat.isFile()
+            || initialPathStat.isSymbolicLink()
+            || !statIdentityMatches(initialHandleStat, initialPathStat)
+            || initialHandleStat.uid !== BigInt(this.uid)
+            || initialHandleStat.nlink !== 1n
+            || initialHandleStat.size !== 0n)
+            throw new BrowserRuntimeError('FENCED', 'runtime lock is unsafe');
+        this.lockIdentity = initialHandleStat;
+        await plugins.fsPromises.chmod(this.lockPath, 0o600);
+        await handle.chmod(0o600);
+        this.lockIdentity = await this.validateLockHandle(handle);
+        await this.assertLockPathCurrent();
+        await this.directoryHandle.sync();
+        return { kind: 'new' };
+    }
+    async readPrivateLockPathStat() {
+        let stat;
+        try {
+            stat = await plugins.fsPromises.lstat(this.lockPath, { bigint: true });
+        }
+        catch (error) {
+            if (isMissingError(error)) {
+                throw new BrowserRuntimeError('FENCED', 'runtime lock identity changed');
+            }
+            throw error;
+        }
+        this.assertPrivateLockStat(stat);
+        return stat;
+    }
+    async validateLockHandle(handleArg) {
+        const stat = await handleArg.stat({ bigint: true });
+        this.assertPrivateLockStat(stat);
+        return stat;
+    }
+    assertPrivateLockStat(statArg) {
+        if (!statArg.isFile()
+            || statArg.isSymbolicLink()
+            || statArg.uid !== BigInt(this.uid)
+            || (statArg.mode & 511n) !== 384n
+            || statArg.nlink !== 1n
+            || statArg.size > BigInt(maximumMetadataBytes))
+            throw new BrowserRuntimeError('FENCED', 'runtime lock is unsafe');
+    }
+    async assertLockPathCurrent() {
+        if (!this.lockHandle || !this.lockIdentity) {
+            throw new BrowserRuntimeError('FENCED', 'runtime lock is unavailable');
+        }
+        const [pathStat, handleStat] = await Promise.all([
+            this.readPrivateLockPathStat(),
+            this.validateLockHandle(this.lockHandle),
+        ]);
+        if (!statIdentityMatches(this.lockIdentity, pathStat)
+            || !statIdentityMatches(this.lockIdentity, handleStat))
+            throw new BrowserRuntimeError('FENCED', 'runtime lock identity changed');
+    }
+    async adoptCreatedLockLayout() {
+        await this.assertRuntimeEntries(new Set([
+            'runtime.lock',
+            'runtime.mutex',
+            'profiles',
+            'artifacts',
+        ]));
+        await this.validateOptionalPrivateDirectory(this.legacyProfileRoot);
+        await this.validateOptionalPrivateDirectory(this.legacyArtifactRoot);
+        const [profileInspection, profileEntries, artifactEntries] = await Promise.all([
+            this.inspectProfileProcesses([this.legacyProfileRoot]),
+            this.readOptionalDirectoryEntries(this.legacyProfileRoot),
+            this.readOptionalDirectoryEntries(this.legacyArtifactRoot),
+        ]);
+        if (profileInspection === 'held')
+            throw new BrowserRuntimeError('LOCKED');
+        if (profileInspection === 'indeterminate') {
+            throw new BrowserRuntimeError('FENCED', 'legacy runtime process ownership is indeterminate');
+        }
+        if (profileEntries.length > 0 || artifactEntries.length > 0) {
+            throw new BrowserRuntimeError('FENCED', 'legacy runtime roots are not empty');
+        }
+        await this.assertLockPathCurrent();
+        await this.assertNativeAnchorCurrent();
+        await this.assertRuntimeDirectoryCurrent();
+        const [currentProfileEntries, currentArtifactEntries] = await Promise.all([
+            this.readOptionalDirectoryEntries(this.legacyProfileRoot),
+            this.readOptionalDirectoryEntries(this.legacyArtifactRoot),
+        ]);
+        if (currentProfileEntries.length > 0 || currentArtifactEntries.length > 0) {
+            throw new BrowserRuntimeError('FENCED', 'legacy runtime roots changed');
+        }
+        await this.removePrivateDirectory(this.legacyProfileRoot);
+        await this.removePrivateDirectory(this.legacyArtifactRoot);
+        await this.directoryHandle.sync();
+    }
+    async unlinkCreatedLock() {
+        if (!this.createdLock)
+            return;
+        if (!this.lockHandle) {
+            throw new BrowserRuntimeError('FENCED', 'created runtime lock is unavailable');
+        }
+        await this.assertNativeAnchorCurrent();
+        await this.assertRuntimeDirectoryCurrent();
+        const [pathStat, handleStat] = await Promise.all([
+            plugins.fsPromises.lstat(this.lockPath, { bigint: true }),
+            this.lockHandle.stat({ bigint: true }),
+        ]);
+        if (!pathStat.isFile()
+            || pathStat.isSymbolicLink()
+            || !handleStat.isFile()
+            || pathStat.uid !== BigInt(this.uid)
+            || handleStat.uid !== BigInt(this.uid)
+            || pathStat.nlink !== 1n
+            || handleStat.nlink !== 1n
+            || String(pathStat.dev) !== this.directoryIdentity.device
+            || !statIdentityMatches(pathStat, handleStat)
+            || (this.lockIdentity && !statIdentityMatches(this.lockIdentity, handleStat)))
+            throw new BrowserRuntimeError('FENCED', 'created runtime lock identity changed');
+        await plugins.fsPromises.unlink(this.lockPath);
+        this.createdLock = false;
+        await this.directoryHandle.sync();
+    }
+    async adoptLegacyLock() {
+        await this.assertRuntimeEntries(new Set([
+            'runtime.lock',
+            'runtime.mutex',
+            'profiles',
+            'artifacts',
+        ]));
+        await this.validateOptionalPrivateDirectory(this.legacyProfileRoot);
+        await this.validateOptionalPrivateDirectory(this.legacyArtifactRoot);
+        const [descriptorInspection, profileInspection, predatesBoot] = await Promise.all([
+            this.inspectLegacyLockDescriptors(),
+            this.inspectProfileProcesses([this.legacyProfileRoot]),
+            this.legacyLockPredatesCurrentBoot(),
+        ]);
+        if (descriptorInspection === 'held' || profileInspection === 'held') {
+            throw new BrowserRuntimeError('LOCKED');
+        }
+        if (descriptorInspection === 'indeterminate' || profileInspection === 'indeterminate') {
+            throw new BrowserRuntimeError('FENCED', 'legacy runtime ownership is indeterminate');
+        }
+        if (!predatesBoot) {
+            throw new BrowserRuntimeError('FENCED', 'same-boot legacy runtime ownership is unsafe');
+        }
+        await this.assertLockPathCurrent();
+        if (!await this.legacyLockPredatesCurrentBoot()) {
+            throw new BrowserRuntimeError('FENCED', 'legacy runtime lock timestamp changed');
+        }
+        await this.assertNativeAnchorCurrent();
+        await this.assertRuntimeDirectoryCurrent();
+        await this.removePrivateDirectory(this.legacyProfileRoot);
+        await this.removePrivateDirectory(this.legacyArtifactRoot);
+        await this.directoryHandle.sync();
+    }
+    async legacyLockPredatesCurrentBoot() {
+        const bootTimeNs = await this.readBootTimeNs();
+        const [pathStat, handleStat] = await Promise.all([
+            this.readPrivateLockPathStat(),
+            this.validateLockHandle(this.lockHandle),
+        ]);
+        if (!statIdentityMatches(this.lockIdentity, pathStat)
+            || !statIdentityMatches(this.lockIdentity, handleStat))
+            throw new BrowserRuntimeError('FENCED', 'legacy runtime lock identity changed');
+        const pathTimestamps = [pathStat.birthtimeNs, pathStat.ctimeNs, pathStat.mtimeNs];
+        const handleTimestamps = [handleStat.birthtimeNs, handleStat.ctimeNs, handleStat.mtimeNs];
+        if (pathTimestamps.some((timestamp, index) => (timestamp <= 0n || timestamp !== handleTimestamps[index])))
+            throw new BrowserRuntimeError('FENCED', 'legacy runtime lock timestamps are ambiguous');
+        return pathTimestamps.every((timestamp) => timestamp < bootTimeNs);
+    }
+    async readBootTimeNs() {
+        const procStat = await this.readBoundedFile(plugins.path.join(this.procRoot, 'stat'), maximumProcFileBytes);
+        if (/\u0000|\r/u.test(procStat)) {
+            throw new BrowserRuntimeError('FENCED', 'boot timestamp is malformed');
+        }
+        const bootTimeLines = procStat.split('\n').filter((line) => line.startsWith('btime'));
+        if (bootTimeLines.length !== 1) {
+            throw new BrowserRuntimeError('FENCED', 'boot timestamp is malformed');
+        }
+        const match = /^btime ([1-9][0-9]{0,19})$/u.exec(bootTimeLines[0]);
+        if (!match)
+            throw new BrowserRuntimeError('FENCED', 'boot timestamp is malformed');
+        const bootTimeNs = BigInt(match[1]) * 1000000000n;
+        const now = this.now();
+        if (!Number.isSafeInteger(now) || now < 0) {
+            throw new BrowserRuntimeError('FENCED', 'current timestamp is unavailable');
+        }
+        const nowNs = BigInt(now) * 1000000n;
+        if (bootTimeNs > nowNs) {
+            throw new BrowserRuntimeError('FENCED', 'boot timestamp is in the future');
+        }
+        return bootTimeNs;
+    }
+    async reclaimMetadataGeneration(metadataArg) {
+        this.assertMetadataDirectoryIdentity(metadataArg);
+        await this.assertRuntimeEntries(new Set([
+            'runtime.lock',
+            'runtime.mutex',
+            'generations',
+        ]));
+        await this.validateOptionalPrivateDirectory(this.generationsRoot);
+        const generationDirectory = this.generationPath(metadataArg.generationId);
+        const entries = await this.readOptionalDirectoryEntries(this.generationsRoot);
+        if (entries.some((entry) => entry.name !== metadataArg.generationId)) {
+            throw new BrowserRuntimeError('FENCED', 'runtime generation ownership is ambiguous');
+        }
+        await this.validateOptionalGeneration(generationDirectory);
+        const profileInspection = await this.inspectProfileProcesses([
+            plugins.path.join(generationDirectory, 'profiles'),
+        ]);
+        if (profileInspection === 'held')
+            throw new BrowserRuntimeError('LOCKED');
+        if (profileInspection === 'indeterminate') {
+            throw new BrowserRuntimeError('FENCED', 'runtime process ownership is indeterminate');
+        }
+        await this.assertLockPathCurrent();
+        await this.assertNativeAnchorCurrent();
+        await this.assertRuntimeDirectoryCurrent();
+        await this.beforeGenerationRemoval?.('stale');
+        await this.assertLockPathCurrent();
+        await this.assertNativeAnchorCurrent();
+        await this.assertRuntimeDirectoryCurrent();
+        await this.removePrivateDirectory(generationDirectory);
+        await this.syncOptionalDirectory(this.generationsRoot);
+    }
+    async publishGeneration() {
+        const identity = this.directoryIdentity;
+        const generationId = randomId(24);
+        const metadata = {
+            schema: metadataSchema,
+            state: 'active',
+            uid: this.uid,
+            runtimeDirectoryDevice: identity.device,
+            runtimeDirectoryInode: identity.inode,
+            runtimeDirectoryHash: identity.hash,
+            bootId: await this.readBootId(),
+            pid: process.pid,
+            processStartTicks: parseProcessStartTicks(await this.readBoundedFile(plugins.path.join(this.procRoot, 'self', 'stat'), 16 * 1024), process.pid),
+            generationId,
+            nonce: randomId(24),
+        };
+        const generationDirectory = this.generationPath(generationId);
+        const generation = {
+            generationId,
+            generationDirectory,
+            profileRoot: plugins.path.join(generationDirectory, 'profiles'),
+            artifactRoot: plugins.path.join(generationDirectory, 'artifacts'),
+        };
+        await this.beforeMetadataPublication?.();
+        await this.writeMetadata(metadata);
+        this.metadata = metadata;
+        this.generation = generation;
+        await this.ensurePrivateDirectory(this.generationsRoot, this.runtimeDirectory);
+        const entries = await this.readOptionalDirectoryEntries(this.generationsRoot);
+        if (entries.length > 0) {
+            throw new BrowserRuntimeError('FENCED', 'runtime generation root is not empty');
+        }
+        await this.ensurePrivateDirectory(generationDirectory, this.generationsRoot);
+        await this.syncOptionalDirectory(this.generationsRoot);
+        return generation;
+    }
+    async releaseInternal(reasonArg) {
+        if (this.leaseLost) {
+            await this.closePassiveHandles().catch(() => undefined);
+            throw new BrowserRuntimeError('FENCED', 'runtime ownership was lost');
+        }
+        if (this.createdLock) {
+            await this.unlinkCreatedLock();
+            await this.closeOwnershipHandles();
+            this.metadata = undefined;
+            this.generation = undefined;
+            return;
+        }
+        const metadata = this.metadata;
+        const generation = this.generation;
+        if (metadata?.state === 'active' && generation) {
+            await this.assertLockPathCurrent();
+            await this.assertNativeAnchorCurrent();
+            await this.validateOptionalGeneration(generation.generationDirectory);
+            await this.assertLockPathCurrent();
+            await this.assertNativeAnchorCurrent();
+            await this.assertRuntimeDirectoryCurrent();
+            await this.beforeGenerationRemoval?.(reasonArg);
+            await this.assertLockPathCurrent();
+            await this.assertNativeAnchorCurrent();
+            await this.assertRuntimeDirectoryCurrent();
+            await this.removePrivateDirectory(generation.generationDirectory);
+            await this.syncOptionalDirectory(this.generationsRoot);
+            const relinquished = { ...metadata, state: 'relinquished' };
+            await this.writeMetadata(relinquished);
+            this.metadata = relinquished;
+        }
+        await this.closeOwnershipHandles();
+        this.metadata = undefined;
+        this.generation = undefined;
+    }
+    async closePassiveHandles() {
+        try {
+            await this.closeOwnershipHandles();
+        }
+        finally {
+            this.metadata = undefined;
+            this.generation = undefined;
+        }
+    }
+    async closeOwnershipHandles() {
+        const errors = [];
+        if (this.lockHandle) {
+            await this.lockHandle.close().then(() => {
+                this.lockHandle = undefined;
+                this.lockIdentity = undefined;
+            }, (error) => errors.push(error));
+        }
+        if (this.anchorDirectoryHandle) {
+            await this.anchorDirectoryHandle.close().then(() => {
+                this.anchorDirectoryHandle = undefined;
+                this.anchorDirectoryIdentity = undefined;
+            }, (error) => errors.push(error));
+        }
+        if (this.directoryHandle) {
+            await this.directoryHandle.close().then(() => {
+                this.directoryHandle = undefined;
+                this.directoryIdentity = undefined;
+            }, (error) => errors.push(error));
+        }
+        if (this.namedMutexLease) {
+            await this.namedMutexLease.release().then(() => {
+                this.namedMutexLease = undefined;
+                this.namedMutex = undefined;
+                this.anchorIdentity = undefined;
+                this.leaseLost = false;
+            }, (error) => errors.push(error));
+        }
+        if (errors.length > 0) {
+            throw new BrowserRuntimeError('FENCED', 'runtime ownership handles could not be closed');
+        }
+    }
+    async readMetadata() {
+        const stat = await this.lockHandle.stat({ bigint: true });
+        if (stat.size <= 0n || stat.size > BigInt(maximumMetadataBytes)) {
+            throw new BrowserRuntimeError('FENCED', 'runtime lock metadata is malformed');
+        }
+        const bytes = plugins.Buffer.alloc(Number(stat.size));
+        let bytesRead = 0;
+        while (bytesRead < bytes.byteLength) {
+            const result = await this.lockHandle.read(bytes, bytesRead, bytes.byteLength - bytesRead, bytesRead);
+            if (result.bytesRead <= 0) {
+                throw new BrowserRuntimeError('FENCED', 'runtime lock metadata is unreadable');
+            }
+            bytesRead += result.bytesRead;
+        }
+        let text;
+        try {
+            text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        }
+        catch {
+            throw new BrowserRuntimeError('FENCED', 'runtime lock metadata is malformed');
+        }
+        if (!text.endsWith('\n') || text.slice(0, -1).includes('\n')) {
+            throw new BrowserRuntimeError('FENCED', 'runtime lock metadata is malformed');
+        }
+        const serialized = text.slice(0, -1);
+        let parsed;
+        try {
+            parsed = JSON.parse(serialized);
+        }
+        catch {
+            throw new BrowserRuntimeError('FENCED', 'runtime lock metadata is malformed');
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new BrowserRuntimeError('FENCED', 'runtime lock metadata is malformed');
+        }
+        const record = parsed;
+        const expectedKeys = [
+            'schema',
+            'state',
+            'uid',
+            'runtimeDirectoryDevice',
+            'runtimeDirectoryInode',
+            'runtimeDirectoryHash',
+            'bootId',
+            'pid',
+            'processStartTicks',
+            'generationId',
+            'nonce',
+        ];
+        if (Object.keys(record).length !== expectedKeys.length
+            || expectedKeys.some((key) => !(key in record))
+            || record.schema !== metadataSchema
+            || (record.state !== 'active' && record.state !== 'relinquished')
+            || !Number.isSafeInteger(record.uid)
+            || record.uid < 1
+            || typeof record.runtimeDirectoryDevice !== 'string'
+            || !unsignedIntegerPattern.test(record.runtimeDirectoryDevice)
+            || typeof record.runtimeDirectoryInode !== 'string'
+            || !unsignedIntegerPattern.test(record.runtimeDirectoryInode)
+            || typeof record.runtimeDirectoryHash !== 'string'
+            || !hashPattern.test(record.runtimeDirectoryHash)
+            || typeof record.bootId !== 'string'
+            || !bootIdPattern.test(record.bootId)
+            || !Number.isSafeInteger(record.pid)
+            || record.pid < 1
+            || typeof record.processStartTicks !== 'string'
+            || !unsignedIntegerPattern.test(record.processStartTicks)
+            || typeof record.generationId !== 'string'
+            || !generationIdPattern.test(record.generationId)
+            || typeof record.nonce !== 'string'
+            || !generationIdPattern.test(record.nonce)
+            || JSON.stringify(record) !== serialized)
+            throw new BrowserRuntimeError('FENCED', 'runtime lock metadata is malformed');
+        return record;
+    }
+    async writeMetadata(metadataArg) {
+        await this.assertLockPathCurrent();
+        await this.assertNativeAnchorCurrent();
+        const bytes = plugins.Buffer.from(`${JSON.stringify(metadataArg)}\n`, 'utf8');
+        if (bytes.byteLength > maximumMetadataBytes) {
+            throw new BrowserRuntimeError('FENCED', 'runtime lock metadata exceeds its bound');
+        }
+        let written = 0;
+        while (written < bytes.byteLength) {
+            const result = await this.lockHandle.write(bytes, written, bytes.byteLength - written, written);
+            if (result.bytesWritten <= 0) {
+                throw new BrowserRuntimeError('FENCED', 'runtime lock metadata write was incomplete');
+            }
+            written += result.bytesWritten;
+        }
+        await this.lockHandle.truncate(bytes.byteLength);
+        await this.lockHandle.sync();
+        this.createdLock = false;
+        await this.assertLockPathCurrent();
+        await this.assertNativeAnchorCurrent();
+    }
+    assertMetadataDirectoryIdentity(metadataArg) {
+        const identity = this.directoryIdentity;
+        if (metadataArg.uid !== identity.uid
+            || metadataArg.runtimeDirectoryDevice !== identity.device
+            || metadataArg.runtimeDirectoryInode !== identity.inode
+            || metadataArg.runtimeDirectoryHash !== identity.hash)
+            throw new BrowserRuntimeError('FENCED', 'runtime metadata belongs to another directory');
+    }
+    async inspectLegacyLockDescriptors() {
+        const lockIdentity = this.lockIdentity;
+        let indeterminate = false;
+        for (const pid of await this.listOwnedProcessIds()) {
+            let descriptorNames;
+            try {
+                descriptorNames = await plugins.fsPromises.readdir(plugins.path.join(this.procRoot, String(pid), 'fd'));
+            }
+            catch {
+                const uidState = await this.processStillExists(pid);
+                if (uidState === 'missing' || uidState === 'other')
+                    continue;
+                indeterminate = true;
+                continue;
+            }
+            for (const descriptorName of descriptorNames) {
+                if (!/^(?:0|[1-9][0-9]*)$/u.test(descriptorName)) {
+                    indeterminate = true;
+                    continue;
+                }
+                const descriptor = Number(descriptorName);
+                if (pid === process.pid && descriptor === this.lockHandle.fd)
+                    continue;
+                try {
+                    const stat = await plugins.fsPromises.stat(plugins.path.join(this.procRoot, String(pid), 'fd', descriptorName), { bigint: true });
+                    if (stat.dev === lockIdentity.dev && stat.ino === lockIdentity.ino)
+                        return 'held';
+                }
+                catch (error) {
+                    if (isMissingError(error))
+                        continue;
+                    indeterminate = true;
+                }
+            }
+        }
+        return indeterminate ? 'indeterminate' : 'clear';
+    }
+    async inspectProfileProcesses(profileRootsArg) {
+        const roots = profileRootsArg.map((root) => plugins.path.resolve(root));
+        let indeterminate = false;
+        for (const pid of await this.listOwnedProcessIds()) {
+            let cmdline;
+            try {
+                cmdline = await this.readBoundedBuffer(plugins.path.join(this.procRoot, String(pid), 'cmdline'), maximumProcFileBytes);
+            }
+            catch {
+                const uidState = await this.processStillExists(pid);
+                if (uidState === 'missing' || uidState === 'other')
+                    continue;
+                indeterminate = true;
+                continue;
+            }
+            if (cmdline.byteLength === 0) {
+                if (!await this.processIsZombie(pid))
+                    indeterminate = true;
+                continue;
+            }
+            let cmdlineText;
+            try {
+                cmdlineText = new TextDecoder('utf-8', { fatal: true }).decode(cmdline);
+            }
+            catch {
+                indeterminate = true;
+                continue;
+            }
+            const argumentsList = cmdlineText.split('\0');
+            if (argumentsList.at(-1) === '')
+                argumentsList.pop();
+            for (let index = 0; index < argumentsList.length; index += 1) {
+                const argument = argumentsList[index];
+                let profilePath;
+                if (argument === '--user-data-dir') {
+                    profilePath = argumentsList[index + 1];
+                }
+                else if (argument.startsWith('--user-data-dir=')) {
+                    profilePath = argument.slice('--user-data-dir='.length);
+                }
+                if (!profilePath || !plugins.path.isAbsolute(profilePath))
+                    continue;
+                const resolved = plugins.path.resolve(profilePath);
+                if (roots.some((root) => resolved === root || this.pathIsWithin(root, resolved))) {
+                    return 'held';
+                }
+            }
+        }
+        return indeterminate ? 'indeterminate' : 'clear';
+    }
+    async listOwnedProcessIds() {
+        let entries;
+        try {
+            entries = await plugins.fsPromises.readdir(this.procRoot, { withFileTypes: true });
+        }
+        catch {
+            throw new BrowserRuntimeError('FENCED', 'process inspection is unavailable');
+        }
+        const processIds = [];
+        let indeterminate = false;
+        for (const entry of entries) {
+            if (!/^[1-9][0-9]{0,9}$/u.test(entry.name))
+                continue;
+            const pid = Number(entry.name);
+            try {
+                const stat = await plugins.fsPromises.lstat(plugins.path.join(this.procRoot, entry.name), { bigint: true });
+                if (!stat.isDirectory() || stat.isSymbolicLink()) {
+                    indeterminate = true;
+                    continue;
+                }
+            }
+            catch (error) {
+                if (isMissingError(error))
+                    continue;
+                indeterminate = true;
+                continue;
+            }
+            const uidState = await this.processStillExists(pid);
+            if (uidState === 'same')
+                processIds.push(pid);
+            else if (uidState === 'indeterminate')
+                indeterminate = true;
+        }
+        if (indeterminate) {
+            throw new BrowserRuntimeError('FENCED', 'process inspection is indeterminate');
+        }
+        return processIds.sort((left, right) => {
+            if (left === process.pid)
+                return -1;
+            if (right === process.pid)
+                return 1;
+            return left - right;
+        });
+    }
+    async processStillExists(pidArg) {
+        const processPath = plugins.path.join(this.procRoot, String(pidArg));
+        try {
+            const status = await this.readBoundedFile(plugins.path.join(processPath, 'status'), 64 * 1024);
+            return this.parseProcessUidState(status);
+        }
+        catch (error) {
+            if (!isMissingError(error))
+                return 'indeterminate';
+            try {
+                await plugins.fsPromises.lstat(processPath, { bigint: true });
+                return 'indeterminate';
+            }
+            catch (statError) {
+                return isMissingError(statError) ? 'missing' : 'indeterminate';
+            }
+        }
+    }
+    parseProcessUidState(statusArg) {
+        if (/\u0000|\r/u.test(statusArg))
+            return 'indeterminate';
+        const uidLines = statusArg.split('\n').filter((line) => line.startsWith('Uid:'));
+        if (uidLines.length !== 1)
+            return 'indeterminate';
+        const match = /^Uid:\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s*$/u.exec(uidLines[0]);
+        if (!match)
+            return 'indeterminate';
+        const ids = match.slice(1).map(Number);
+        if (ids.some((id) => !Number.isSafeInteger(id) || id < 0 || id > 0xffff_ffff)) {
+            return 'indeterminate';
+        }
+        if (ids.every((id) => id === this.uid))
+            return 'same';
+        if (ids.every((id) => id !== this.uid))
+            return 'other';
+        return 'indeterminate';
+    }
+    async processIsZombie(pidArg) {
+        try {
+            const status = await this.readBoundedFile(plugins.path.join(this.procRoot, String(pidArg), 'status'), 64 * 1024);
+            return /^State:\s+Z(?:\s|$)/mu.test(status);
+        }
+        catch {
+            return false;
+        }
+    }
+    async readBootId() {
+        const rawBootId = await this.readBoundedFile(plugins.path.join(this.procRoot, 'sys', 'kernel', 'random', 'boot_id'), 64);
+        const bootId = rawBootId.endsWith('\n') ? rawBootId.slice(0, -1) : rawBootId;
+        if (bootId.includes('\n') || bootId.includes('\r') || !bootIdPattern.test(bootId)) {
+            throw new BrowserRuntimeError('FENCED', 'boot identity is malformed');
+        }
+        return bootId;
+    }
+    async readBoundedFile(pathArg, maximumBytesArg) {
+        const bytes = await this.readBoundedBuffer(pathArg, maximumBytesArg);
+        try {
+            return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        }
+        catch {
+            throw new BrowserRuntimeError('FENCED', 'process metadata is malformed');
+        }
+    }
+    async readBoundedBuffer(pathArg, maximumBytesArg) {
+        const bytes = await plugins.fsPromises.readFile(pathArg);
+        if (bytes.byteLength > maximumBytesArg) {
+            throw new BrowserRuntimeError('FENCED', 'process metadata exceeds its bound');
+        }
+        return bytes;
+    }
+    generationPath(generationIdArg) {
+        if (!generationIdPattern.test(generationIdArg)) {
+            throw new BrowserRuntimeError('FENCED', 'runtime generation identity is malformed');
+        }
+        const generationPath = plugins.path.join(this.generationsRoot, generationIdArg);
+        if (!this.pathIsWithin(this.generationsRoot, generationPath)) {
+            throw new BrowserRuntimeError('FENCED', 'runtime generation escaped containment');
+        }
+        return generationPath;
+    }
+    pathIsWithin(rootArg, candidateArg) {
+        const relative = plugins.path.relative(rootArg, candidateArg);
+        return relative.length > 0 && relative !== '..'
+            && !relative.startsWith(`..${plugins.path.sep}`)
+            && !plugins.path.isAbsolute(relative);
+    }
+    async assertRuntimeEntries(allowedNamesArg) {
+        await this.assertRuntimeDirectoryCurrent();
+        const entries = await plugins.fsPromises.readdir(this.runtimeDirectory, { withFileTypes: true });
+        if (entries.some((entry) => !allowedNamesArg.has(entry.name))) {
+            throw new BrowserRuntimeError('FENCED', 'runtime directory contains unknown state');
+        }
+    }
+    async assertRuntimeDirectoryCurrent() {
+        if (!this.directoryHandle || !this.directoryIdentity) {
+            throw new BrowserRuntimeError('FENCED', 'runtime directory is unavailable');
+        }
+        const [pathStat, handleStat] = await Promise.all([
+            plugins.fsPromises.lstat(this.runtimeDirectory, { bigint: true }),
+            this.directoryHandle.stat({ bigint: true }),
+        ]);
+        if (!pathStat.isDirectory()
+            || pathStat.isSymbolicLink()
+            || pathStat.uid !== BigInt(this.uid)
+            || (pathStat.mode & 511n) !== 448n
+            || !statIdentityMatches(pathStat, handleStat)
+            || String(handleStat.dev) !== this.directoryIdentity.device
+            || String(handleStat.ino) !== this.directoryIdentity.inode)
+            throw new BrowserRuntimeError('FENCED', 'runtime directory identity changed');
+    }
+    async ensurePrivateDirectory(pathArg, parentArg) {
+        if (!this.pathIsWithin(parentArg, pathArg)) {
+            throw new BrowserRuntimeError('FENCED', 'runtime path escaped containment');
+        }
+        let created = false;
+        try {
+            await plugins.fsPromises.mkdir(pathArg, { recursive: false, mode: 0o700 });
+            created = true;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        if (created) {
+            await plugins.fsPromises.chmod(pathArg, 0o700);
+            const handle = await plugins.fsPromises.open(pathArg, plugins.fs.constants.O_RDONLY
+                | plugins.fs.constants.O_DIRECTORY
+                | plugins.fs.constants.O_NOFOLLOW);
+            try {
+                await handle.chmod(0o700);
+                await plugins.fsPromises.chmod(pathArg, 0o700);
+                const [pathStat, handleStat] = await Promise.all([
+                    plugins.fsPromises.lstat(pathArg, { bigint: true }),
+                    handle.stat({ bigint: true }),
+                ]);
+                if (!pathStat.isDirectory()
+                    || pathStat.isSymbolicLink()
+                    || pathStat.uid !== BigInt(this.uid)
+                    || (pathStat.mode & 511n) !== 448n
+                    || !statIdentityMatches(pathStat, handleStat))
+                    throw new BrowserRuntimeError('FENCED', 'runtime directory state is unsafe');
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await this.syncDirectory(parentArg);
+        }
+        await this.validateOptionalPrivateDirectory(pathArg, false);
+    }
+    async validateOptionalPrivateDirectory(pathArg, allowMissingArg = true) {
+        let stat;
+        try {
+            stat = await plugins.fsPromises.lstat(pathArg, { bigint: true });
+        }
+        catch (error) {
+            if (allowMissingArg && isMissingError(error))
+                return false;
+            throw error;
+        }
+        if (!stat.isDirectory()
+            || stat.isSymbolicLink()
+            || stat.uid !== BigInt(this.uid)
+            || (stat.mode & 511n) !== 448n)
+            throw new BrowserRuntimeError('FENCED', 'runtime directory state is unsafe');
+        return true;
+    }
+    async validateOptionalGeneration(generationDirectoryArg) {
+        if (!await this.validateOptionalPrivateDirectory(generationDirectoryArg))
+            return;
+        const entries = await plugins.fsPromises.readdir(generationDirectoryArg, { withFileTypes: true });
+        if (entries.some((entry) => entry.name !== 'profiles' && entry.name !== 'artifacts')) {
+            throw new BrowserRuntimeError('FENCED', 'runtime generation contains unknown state');
+        }
+        await this.validateOptionalPrivateDirectory(plugins.path.join(generationDirectoryArg, 'profiles'));
+        await this.validateOptionalPrivateDirectory(plugins.path.join(generationDirectoryArg, 'artifacts'));
+    }
+    async removePrivateDirectory(pathArg) {
+        if (!this.pathIsWithin(this.runtimeDirectory, pathArg)) {
+            throw new BrowserRuntimeError('FENCED', 'runtime cleanup escaped containment');
+        }
+        if (!await this.validateOptionalPrivateDirectory(pathArg))
+            return;
+        await plugins.fsPromises.rm(pathArg, {
+            recursive: true,
+            force: false,
+            maxRetries: 3,
+            retryDelay: 50,
+        });
+    }
+    async readOptionalDirectoryEntries(pathArg) {
+        try {
+            return await plugins.fsPromises.readdir(pathArg, { withFileTypes: true });
+        }
+        catch (error) {
+            if (isMissingError(error))
+                return [];
+            throw error;
+        }
+    }
+    async syncOptionalDirectory(pathArg) {
+        try {
+            await this.syncDirectory(pathArg);
+        }
+        catch (error) {
+            if (!isMissingError(error))
+                throw error;
+        }
+    }
+    async syncDirectory(pathArg) {
+        const handle = await plugins.fsPromises.open(pathArg, plugins.fs.constants.O_RDONLY
+            | plugins.fs.constants.O_DIRECTORY
+            | plugins.fs.constants.O_NOFOLLOW);
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.runtimeownership.js","sourceRoot":"","sources":["../ts/classes.runtimeownership.ts"],"names":[],"mappings":"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"}