agl 1.0.17 → 21.0.2

package/dist_ts_migration/v2_controllerdataroot.js

@@ -0,0 +1,1887 @@
+import * as plugins from '../dist_ts/plugins.js';
+import { readControllerProcessIdentity, } from '../dist_ts/classes.processinspection.js';
+import { embeddedDatabaseSocketPath, isSocketListening as defaultIsSocketListening, } from '../dist_ts/functions.embeddeddb.js';
+import { EmbeddedDatabaseLocationMigration, rebaseCompletedEmbeddedDatabaseLocationMigration, } from './v1_embeddeddatabaselocation.js';
+import { flexProviderCredentialStoreId } from './v16_flexprovidercredentials.js';
+const migrationVersion = 2;
+const journalFileName = '.hcon-controller-data-root-migration.json';
+const lockFileName = '.hcon-controller-data-root-migration.lock';
+const markerFileName = '.hcon-controller-data-root-marker.json';
+const embeddedDatabaseJournalFileName = '.smartdb-location-migration.json';
+const maximumJournalBytes = 512 * 1024;
+const maximumLockBytes = 16 * 1024;
+const maximumMarkerBytes = 4 * 1024;
+const maximumSmartDbRelocationReceiptBytes = 16 * 1024;
+const maximumRootEntries = 2_048;
+const maximumCredentialStores = 512;
+const maximumMigrationTemporaryFiles = 32;
+const maximumControllerLogs = 256;
+const maximumUpgradeLogs = 64;
+const maximumLockArtifacts = 64;
+const maximumLockAttempts = 200;
+const lockWaitMilliseconds = 50;
+const credentialHashPattern = /^[a-f0-9]{64}$/;
+const digestPattern = /^[a-f0-9]{64}$/;
+const noncePattern = /^[a-f0-9]{64}$/;
+const decimalPattern = /^(0|[1-9][0-9]*)$/;
+const controllerLogPattern = /^controller-([1-9][0-9]{0,4})\.log(?:\.old)?$/;
+const upgradeLogPattern = /^upgrade-[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{6}\.[0-9]{3}Z-[A-Za-z0-9_-]{10}\.log$/;
+const embeddedDatabaseJournalTemporaryPattern = /^\.smartdb-location-migration\.json\.[1-9][0-9]*-[a-f0-9]{16}\.tmp$/;
+const currentUid = () => {
+    if (typeof process.getuid !== 'function') {
+        throw new Error('Controller data-root migration requires a POSIX user identity.');
+    }
+    return process.getuid();
+};
+const isMissingError = (errorArg) => errorArg.code === 'ENOENT';
+const pathIdentity = (statsArg) => ({
+    device: statsArg.dev.toString(10),
+    inode: statsArg.ino.toString(10),
+});
+const identitiesEqual = (leftArg, rightArg) => leftArg.device === rightArg.device && leftArg.inode === rightArg.inode;
+const assertAbsoluteNormalizedPath = (pathArg, labelArg) => {
+    if (typeof pathArg !== 'string'
+        || !plugins.path.isAbsolute(pathArg)
+        || plugins.path.resolve(pathArg) !== pathArg
+        || pathArg === plugins.path.parse(pathArg).root) {
+        throw new Error(`${labelArg} must be a normalized absolute non-root path.`);
+    }
+    return pathArg;
+};
+const assertPlainRecord = (valueArg, labelArg) => {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg)) {
+        throw new Error(`${labelArg} is malformed.`);
+    }
+    const prototype = Object.getPrototypeOf(valueArg);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new Error(`${labelArg} is malformed.`);
+    }
+    return valueArg;
+};
+const assertExactKeys = (valueArg, expectedArg, labelArg) => {
+    const actual = Object.keys(valueArg).sort();
+    const expected = [...expectedArg].sort();
+    if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+        throw new Error(`${labelArg} has unexpected fields.`);
+    }
+};
+const requireString = (valueArg, labelArg, maximumBytesArg = 16 * 1024) => {
+    if (typeof valueArg !== 'string'
+        || valueArg.length === 0
+        || Buffer.byteLength(valueArg, 'utf8') > maximumBytesArg)
+        throw new Error(`${labelArg} is invalid.`);
+    return valueArg;
+};
+const requireNullableString = (valueArg, labelArg) => valueArg === null ? null : requireString(valueArg, labelArg);
+const requireNullableDecimal = (valueArg, labelArg) => {
+    const value = requireNullableString(valueArg, labelArg);
+    if (value !== null && !decimalPattern.test(value))
+        throw new Error(`${labelArg} is invalid.`);
+    return value;
+};
+const assertNullableIdentityPair = (deviceArg, inodeArg, labelArg) => {
+    if ((deviceArg === null) !== (inodeArg === null)) {
+        throw new Error(`${labelArg} identity is incomplete.`);
+    }
+};
+const parseCredentialTuple = (valueArg) => {
+    const value = assertPlainRecord(valueArg, 'Controller credential migration tuple');
+    assertExactKeys(value, [
+        'controllerHash',
+        'service',
+        'storeId',
+        'sourceDirectory',
+        'destinationDirectory',
+        'complete',
+    ], 'Controller credential migration tuple');
+    const controllerHash = requireString(value.controllerHash, 'Controller credential hash', 64);
+    if (!credentialHashPattern.test(controllerHash)) {
+        throw new Error('Controller credential hash is invalid.');
+    }
+    if (typeof value.complete !== 'boolean') {
+        throw new Error('Controller credential completion state is invalid.');
+    }
+    return {
+        controllerHash,
+        service: requireString(value.service, 'Controller credential service', 200),
+        storeId: requireString(value.storeId, 'Controller credential store ID', 200),
+        sourceDirectory: requireString(value.sourceDirectory, 'Controller credential source path'),
+        destinationDirectory: requireString(value.destinationDirectory, 'Controller credential destination path'),
+        complete: value.complete,
+    };
+};
+const parseDatabaseJournal = (valueArg) => {
+    const value = assertPlainRecord(valueArg, 'Controller database root migration journal');
+    assertExactKeys(value, [
+        'mode',
+        'strategy',
+        'phase',
+        'configurationDigestSha256',
+        'oldDirectory',
+        'targetDirectory',
+        'historicalDirectory',
+        'sourcePath',
+        'sourceDevice',
+        'sourceInode',
+        'destinationDevice',
+        'destinationInode',
+        'contentDigestSha256',
+        'v1JournalLocation',
+    ], 'Controller database root migration journal');
+    if (value.mode !== 'external' && value.mode !== 'override' && value.mode !== 'default') {
+        throw new Error('Controller database migration mode is invalid.');
+    }
+    if (value.strategy !== 'unchanged'
+        && value.strategy !== 'fresh'
+        && value.strategy !== 'historical-direct'
+        && value.strategy !== 'old-relocation')
+        throw new Error('Controller database migration strategy is invalid.');
+    if (value.phase !== 'pending'
+        && value.phase !== 'prepared'
+        && value.phase !== 'moved'
+        && value.phase !== 'verified')
+        throw new Error('Controller database migration phase is invalid.');
+    if (value.v1JournalLocation !== 'none'
+        && value.v1JournalLocation !== 'legacy'
+        && value.v1JournalLocation !== 'target')
+        throw new Error('Controller database v1 journal location is invalid.');
+    const configurationDigestSha256 = requireString(value.configurationDigestSha256, 'Controller database configuration digest', 64);
+    if (!digestPattern.test(configurationDigestSha256)) {
+        throw new Error('Controller database configuration digest is invalid.');
+    }
+    const sourceDevice = requireNullableDecimal(value.sourceDevice, 'Controller database source device');
+    const sourceInode = requireNullableDecimal(value.sourceInode, 'Controller database source inode');
+    const destinationDevice = requireNullableDecimal(value.destinationDevice, 'Controller database destination device');
+    const destinationInode = requireNullableDecimal(value.destinationInode, 'Controller database destination inode');
+    assertNullableIdentityPair(sourceDevice, sourceInode, 'Controller database source');
+    assertNullableIdentityPair(destinationDevice, destinationInode, 'Controller database destination');
+    const contentDigestSha256 = requireNullableString(value.contentDigestSha256, 'Controller database content digest');
+    if (contentDigestSha256 !== null && !digestPattern.test(contentDigestSha256)) {
+        throw new Error('Controller database content digest is invalid.');
+    }
+    return {
+        mode: value.mode,
+        strategy: value.strategy,
+        phase: value.phase,
+        configurationDigestSha256,
+        oldDirectory: requireNullableString(value.oldDirectory, 'Controller old database path'),
+        targetDirectory: requireNullableString(value.targetDirectory, 'Controller target database path'),
+        historicalDirectory: requireNullableString(value.historicalDirectory, 'Controller historical database path'),
+        sourcePath: requireNullableString(value.sourcePath, 'Controller database source path'),
+        sourceDevice,
+        sourceInode,
+        destinationDevice,
+        destinationInode,
+        contentDigestSha256,
+        v1JournalLocation: value.v1JournalLocation,
+    };
+};
+const parseJournal = (valueArg) => {
+    const value = assertPlainRecord(valueArg, 'Controller data-root migration journal');
+    assertExactKeys(value, [
+        'version',
+        'phase',
+        'sourcePath',
+        'sourceDevice',
+        'sourceInode',
+        'destinationPath',
+        'destinationDevice',
+        'destinationInode',
+        'targetCreationNonce',
+        'database',
+        'credentials',
+    ], 'Controller data-root migration journal');
+    if (value.version !== migrationVersion) {
+        throw new Error('Controller data-root migration journal version is unsupported.');
+    }
+    if (value.phase !== 'legacy-authoritative'
+        && value.phase !== 'target-staged'
+        && value.phase !== 'target-committed')
+        throw new Error('Controller data-root migration journal phase is invalid.');
+    const sourceDevice = requireNullableDecimal(value.sourceDevice, 'Controller source root device');
+    const sourceInode = requireNullableDecimal(value.sourceInode, 'Controller source root inode');
+    const destinationDevice = requireNullableDecimal(value.destinationDevice, 'Controller destination root device');
+    const destinationInode = requireNullableDecimal(value.destinationInode, 'Controller destination root inode');
+    assertNullableIdentityPair(sourceDevice, sourceInode, 'Controller source root');
+    assertNullableIdentityPair(destinationDevice, destinationInode, 'Controller destination root');
+    const targetCreationNonce = requireString(value.targetCreationNonce, 'Controller target creation nonce', 64);
+    if (!noncePattern.test(targetCreationNonce)) {
+        throw new Error('Controller target creation nonce is invalid.');
+    }
+    if (!Array.isArray(value.credentials) || value.credentials.length > maximumCredentialStores) {
+        throw new Error('Controller credential migration tuple list is invalid.');
+    }
+    const credentials = value.credentials.map(parseCredentialTuple);
+    return {
+        version: migrationVersion,
+        phase: value.phase,
+        sourcePath: requireString(value.sourcePath, 'Controller source root path'),
+        sourceDevice,
+        sourceInode,
+        destinationPath: requireString(value.destinationPath, 'Controller destination root path'),
+        destinationDevice,
+        destinationInode,
+        targetCreationNonce,
+        database: parseDatabaseJournal(value.database),
+        credentials,
+    };
+};
+const parseMarker = (valueArg) => {
+    const value = assertPlainRecord(valueArg, 'Controller target marker');
+    assertExactKeys(value, ['version', 'targetCreationNonce'], 'Controller target marker');
+    if (value.version !== migrationVersion)
+        throw new Error('Controller target marker version is invalid.');
+    const targetCreationNonce = requireString(value.targetCreationNonce, 'Controller target marker nonce', 64);
+    if (!noncePattern.test(targetCreationNonce))
+        throw new Error('Controller target marker nonce is invalid.');
+    return { version: migrationVersion, targetCreationNonce };
+};
+const parseLockOwner = (valueArg) => {
+    const value = assertPlainRecord(valueArg, 'Controller data-root migration lock owner');
+    assertExactKeys(value, [
+        'version',
+        'uid',
+        'pid',
+        'processFingerprint',
+        'nonce',
+    ], 'Controller data-root migration lock owner');
+    if (value.version !== 1)
+        throw new Error('Controller data-root migration lock version is invalid.');
+    if (!Number.isSafeInteger(value.uid) || value.uid < 0) {
+        throw new Error('Controller data-root migration lock UID is invalid.');
+    }
+    if (!Number.isSafeInteger(value.pid) || value.pid < 2) {
+        throw new Error('Controller data-root migration lock PID is invalid.');
+    }
+    const processFingerprint = requireString(value.processFingerprint, 'Controller data-root migration lock process fingerprint', 4 * 1024);
+    const nonce = requireString(value.nonce, 'Controller data-root migration lock nonce', 64);
+    if (!noncePattern.test(nonce))
+        throw new Error('Controller data-root migration lock nonce is invalid.');
+    return {
+        version: 1,
+        uid: value.uid,
+        pid: value.pid,
+        processFingerprint,
+        nonce,
+    };
+};
+const syncDirectory = async (directoryArg) => {
+    const handle = await plugins.fs.promises.open(directoryArg, plugins.fs.constants.O_RDONLY | plugins.fs.constants.O_DIRECTORY);
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+};
+const readDirectoryIdentity = async (directoryArg, labelArg, exactModeArg) => {
+    let handle;
+    try {
+        handle = await plugins.fs.promises.open(directoryArg, plugins.fs.constants.O_RDONLY
+            | plugins.fs.constants.O_DIRECTORY
+            | plugins.fs.constants.O_NOFOLLOW);
+    }
+    catch (errorArg) {
+        if (isMissingError(errorArg))
+            return undefined;
+        throw new Error(`${labelArg} must be a real private directory: ${directoryArg}`, {
+            cause: errorArg,
+        });
+    }
+    try {
+        const stats = await handle.stat({ bigint: true });
+        const mode = Number(stats.mode & 511n);
+        if (!stats.isDirectory()
+            || stats.uid !== BigInt(currentUid())
+            || (exactModeArg === undefined ? (mode & 0o077) !== 0 : mode !== exactModeArg)) {
+            throw new Error(`${labelArg} must be a real private directory: ${directoryArg}`);
+        }
+        return pathIdentity(stats);
+    }
+    finally {
+        await handle.close();
+    }
+};
+const inspectPrivateNode = async (pathArg, kindArg, labelArg, exactModeArg) => {
+    let stats;
+    try {
+        stats = await plugins.fs.promises.lstat(pathArg, { bigint: true });
+    }
+    catch (errorArg) {
+        if (isMissingError(errorArg))
+            return undefined;
+        throw errorArg;
+    }
+    const mode = Number(stats.mode & 511n);
+    const expectedKind = kindArg === 'file' ? stats.isFile() : stats.isDirectory();
+    if (!expectedKind
+        || stats.isSymbolicLink()
+        || stats.uid !== BigInt(currentUid())
+        || (exactModeArg === undefined ? (mode & 0o077) !== 0 : mode !== exactModeArg))
+        throw new Error(`${labelArg} is unsafe: ${pathArg}`);
+    return pathIdentity(stats);
+};
+const readPrivateJson = async (pathArg, maximumBytesArg, parserArg, labelArg, exactModeArg = 0o600) => {
+    let handle;
+    try {
+        handle = await plugins.fs.promises.open(pathArg, plugins.fs.constants.O_RDONLY | plugins.fs.constants.O_NOFOLLOW);
+    }
+    catch (errorArg) {
+        if (isMissingError(errorArg))
+            return undefined;
+        throw new Error(`${labelArg} is not a safe regular file.`, { cause: errorArg });
+    }
+    try {
+        const stats = await handle.stat({ bigint: true });
+        if (!stats.isFile()
+            || stats.uid !== BigInt(currentUid())
+            || Number(stats.mode & 511n) !== exactModeArg
+            || stats.size < 2n
+            || stats.size > BigInt(maximumBytesArg))
+            throw new Error(`${labelArg} is not a bounded mode-${exactModeArg.toString(8)} regular file.`);
+        let parsed;
+        try {
+            parsed = JSON.parse(await handle.readFile('utf8'));
+        }
+        catch (errorArg) {
+            throw new Error(`${labelArg} contains malformed JSON.`, { cause: errorArg });
+        }
+        return { value: parserArg(parsed), identity: pathIdentity(stats) };
+    }
+    finally {
+        await handle.close();
+    }
+};
+const unlinkExactPath = async (pathArg, identityArg) => {
+    let current;
+    try {
+        current = await plugins.fs.promises.lstat(pathArg, { bigint: true });
+    }
+    catch (errorArg) {
+        if (isMissingError(errorArg))
+            return;
+        throw errorArg;
+    }
+    if (!identitiesEqual(pathIdentity(current), identityArg)) {
+        throw new Error(`Refusing to remove a replaced migration artifact: ${pathArg}`);
+    }
+    await plugins.fs.promises.unlink(pathArg);
+};
+const writePrivateJsonAtomic = async (targetPathArg, valueArg, maximumBytesArg) => {
+    const serialized = `${JSON.stringify(valueArg)}\n`;
+    if (Buffer.byteLength(serialized, 'utf8') > maximumBytesArg) {
+        throw new Error('Controller migration record exceeds its size limit.');
+    }
+    const parent = plugins.path.dirname(targetPathArg);
+    const temporaryPath = `${targetPathArg}.tmp-${process.pid}-${plugins.crypto.randomBytes(8).toString('hex')}`;
+    let handle;
+    let temporaryIdentity;
+    try {
+        handle = await plugins.fs.promises.open(temporaryPath, plugins.fs.constants.O_WRONLY
+            | plugins.fs.constants.O_CREAT
+            | plugins.fs.constants.O_EXCL
+            | plugins.fs.constants.O_NOFOLLOW, 0o600);
+        await handle.chmod(0o600);
+        await handle.writeFile(serialized, 'utf8');
+        await handle.sync();
+        temporaryIdentity = pathIdentity(await handle.stat({ bigint: true }));
+        await handle.close();
+        handle = undefined;
+        await plugins.fs.promises.rename(temporaryPath, targetPathArg);
+        temporaryIdentity = undefined;
+        await syncDirectory(parent);
+    }
+    catch (errorArg) {
+        if (handle)
+            await handle.close().catch(() => undefined);
+        if (temporaryIdentity)
+            await unlinkExactPath(temporaryPath, temporaryIdentity).catch(() => undefined);
+        throw errorArg;
+    }
+};
+const delay = async (millisecondsArg, signalArg) => {
+    signalArg?.throwIfAborted();
+    const signal = signalArg;
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, millisecondsArg);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            reject(signal?.reason ?? new Error('Controller data-root migration was aborted.'));
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+};
+const databaseConfigurationDigest = (valueArg) => plugins.crypto
+    .createHash('sha256')
+    .update(JSON.stringify(valueArg), 'utf8')
+    .digest('hex');
+const aggregateDatabaseDigests = (digestsArg) => {
+    const hash = plugins.crypto.createHash('sha256');
+    for (const [databaseName, digest] of [...digestsArg.entries()].sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))) {
+        hash.update(databaseName, 'utf8');
+        hash.update('\0');
+        hash.update(digest.sha256, 'ascii');
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+};
+const inspectDatabaseContentDigest = async (directoryArg) => {
+    const database = new plugins.smartdb.LocalSmartDb({ folderPath: directoryArg });
+    retainedMigratedLocalSmartDbs.add(database);
+    let operationError;
+    let result;
+    try {
+        await database.start();
+        const server = database.getServer();
+        const names = [...new Set((await server.getCollections()).map((entry) => entry.db))].sort();
+        const digests = new Map();
+        for (const name of names) {
+            digests.set(name, await server.getDatabaseContentDigest({ databaseName: name }));
+        }
+        result = aggregateDatabaseDigests(digests);
+    }
+    catch (errorArg) {
+        operationError = errorArg;
+    }
+    try {
+        await stopLocalSmartDbConfirmed(database, 'Controller database inspection SmartDB');
+        retainedMigratedLocalSmartDbs.delete(database);
+    }
+    catch (errorArg) {
+        operationError = operationError
+            ? new AggregateError([operationError, errorArg], 'Controller database inspection and cleanup both failed.', { cause: operationError })
+            : errorArg;
+    }
+    if (operationError)
+        throw operationError;
+    return result;
+};
+const closeKernelStoreConfirmed = async (kernelStoreArg) => {
+    const errors = [];
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            await kernelStoreArg.close();
+            return;
+        }
+        catch (errorArg) {
+            errors.push(errorArg);
+        }
+    }
+    throw new AggregateError(errors, 'SmartSecret kernel-store closure could not be confirmed.');
+};
+const retainedEmbeddedDatabaseMigrations = new Set();
+const retainedMigratedLocalSmartDbs = new Set();
+const stopLocalSmartDbConfirmed = async (localDbArg, labelArg) => {
+    const errors = [];
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            await localDbArg.stop();
+            return;
+        }
+        catch (errorArg) {
+            errors.push(errorArg);
+        }
+    }
+    throw new AggregateError(errors, `${labelArg} could not be stopped cleanly.`);
+};
+const drainRetainedEmbeddedDatabaseMigrationResources = async () => {
+    for (const retainedLocalDb of retainedMigratedLocalSmartDbs) {
+        await stopLocalSmartDbConfirmed(retainedLocalDb, 'Retained controller migration SmartDB');
+        retainedMigratedLocalSmartDbs.delete(retainedLocalDb);
+    }
+    for (const retainedMigration of retainedEmbeddedDatabaseMigrations) {
+        const cleanupErrors = [];
+        for (let attempt = 0; attempt < 2 && retainedMigration.hasOwnedResources; attempt += 1) {
+            try {
+                await retainedMigration.stop();
+            }
+            catch (errorArg) {
+                cleanupErrors.push(errorArg);
+            }
+        }
+        if (retainedMigration.hasOwnedResources) {
+            throw new AggregateError(cleanupErrors, 'A retained embedded database migration still owns resources.');
+        }
+        retainedEmbeddedDatabaseMigrations.delete(retainedMigration);
+    }
+};
+const runEmbeddedDatabaseLocationMigration = async (migrationArg) => {
+    await drainRetainedEmbeddedDatabaseMigrationResources();
+    retainedEmbeddedDatabaseMigrations.add(migrationArg);
+    let operationError;
+    let result = undefined;
+    try {
+        result = await migrationArg.run();
+    }
+    catch (errorArg) {
+        operationError = errorArg;
+    }
+    if (result) {
+        retainedMigratedLocalSmartDbs.add(result.localDb);
+        try {
+            await stopLocalSmartDbConfirmed(result.localDb, 'Migrated controller SmartDB');
+            retainedMigratedLocalSmartDbs.delete(result.localDb);
+        }
+        catch (errorArg) {
+            operationError = operationError
+                ? new AggregateError([operationError, errorArg], 'Embedded database migration and transferred-engine cleanup both failed.', { cause: operationError })
+                : errorArg;
+        }
+    }
+    if (migrationArg.hasOwnedResources) {
+        const cleanupErrors = [];
+        for (let attempt = 0; attempt < 2 && migrationArg.hasOwnedResources; attempt += 1) {
+            try {
+                await migrationArg.stop();
+            }
+            catch (errorArg) {
+                cleanupErrors.push(errorArg);
+            }
+        }
+        if (migrationArg.hasOwnedResources) {
+            const cleanupError = new AggregateError(cleanupErrors, 'Embedded database migration retained resources after cleanup retries.');
+            operationError = operationError
+                ? new AggregateError([operationError, cleanupError], 'Embedded database migration and owned-resource cleanup both failed.', { cause: operationError })
+                : cleanupError;
+        }
+    }
+    if (!migrationArg.hasOwnedResources)
+        retainedEmbeddedDatabaseMigrations.delete(migrationArg);
+    if (operationError)
+        throw operationError;
+};
+const defaultRelocateCredentialStore = async (intentArg, signalArg) => {
+    signalArg?.throwIfAborted();
+    let kernelStore;
+    let sealedStore;
+    let operationError;
+    try {
+        kernelStore = await plugins.smartsecret.SmartSecretKernelStore.create({
+            service: intentArg.service,
+        });
+        signalArg?.throwIfAborted();
+        sealedStore = await plugins.smartsecret.SmartSecretSealedFileStore.relocate({
+            kernelStore,
+            storeId: intentArg.storeId,
+            sourceDirectoryPath: intentArg.sourceDirectory,
+            destinationDirectoryPath: intentArg.destinationDirectory,
+        });
+        await sealedStore.close();
+        sealedStore = undefined;
+    }
+    catch (errorArg) {
+        operationError = errorArg;
+    }
+    if (sealedStore) {
+        try {
+            await sealedStore.close();
+        }
+        catch (errorArg) {
+            operationError = operationError
+                ? new AggregateError([operationError, errorArg], 'SmartSecret relocation and sealed-store cleanup both failed.', { cause: operationError })
+                : errorArg;
+        }
+    }
+    if (kernelStore) {
+        try {
+            await closeKernelStoreConfirmed(kernelStore);
+        }
+        catch (errorArg) {
+            operationError = operationError
+                ? new AggregateError([operationError, errorArg], 'SmartSecret relocation and kernel-store cleanup both failed.', { cause: operationError })
+                : errorArg;
+        }
+    }
+    if (operationError)
+        throw operationError;
+};
+export class ControllerDataRootMigrationRunner {
+    options;
+    oldRoot;
+    newRoot;
+    commonParent;
+    journalPath;
+    lockPath;
+    markerPath;
+    databaseConfiguration;
+    isSocketListening;
+    relocateCredentialStore;
+    relocateStoppedDatabaseRoot;
+    constructor(options) {
+        this.options = options;
+        this.oldRoot = assertAbsoluteNormalizedPath(options.oldRoot, 'Old controller root');
+        this.newRoot = assertAbsoluteNormalizedPath(options.newRoot, 'New controller root');
+        if (this.oldRoot === this.newRoot)
+            throw new Error('Controller roots must be different.');
+        if (plugins.path.dirname(this.oldRoot) !== plugins.path.dirname(this.newRoot)) {
+            throw new Error('Controller roots must be siblings under one common parent.');
+        }
+        this.commonParent = plugins.path.dirname(this.oldRoot);
+        this.journalPath = plugins.path.join(this.commonParent, journalFileName);
+        this.lockPath = plugins.path.join(this.commonParent, lockFileName);
+        this.markerPath = plugins.path.join(this.newRoot, markerFileName);
+        assertAbsoluteNormalizedPath(options.oldEmbeddedSocketPath, 'Old embedded database socket path');
+        assertAbsoluteNormalizedPath(options.newEmbeddedSocketPath, 'New embedded database socket path');
+        if (!Number.isSafeInteger(options.invokerPid) || options.invokerPid < 2) {
+            throw new Error('Controller data-root migration invoker PID is invalid.');
+        }
+        if (typeof options.listDataWriterProcesses !== 'function') {
+            throw new Error('Controller data-root migration requires a data-writer process callback.');
+        }
+        this.databaseConfiguration = this.normalizeDatabaseConfiguration(options.databaseConfig);
+        this.isSocketListening = options.isSocketListening ?? defaultIsSocketListening;
+        this.relocateCredentialStore = options.relocateCredentialStore
+            ?? defaultRelocateCredentialStore;
+        this.relocateStoppedDatabaseRoot = options.relocateStoppedDatabaseRoot
+            ?? (async (inputArg, signalArg) => await plugins.smartdb.LocalSmartDb.relocateStoppedStorageRoot({ ...inputArg }, signalArg ? { signal: signalArg } : undefined));
+    }
+    async prepareStartup() {
+        const parentExists = await this.validateCommonParent(false);
+        if (!parentExists) {
+            return { directoryPath: this.newRoot, createDirectory: true };
+        }
+        const journal = await this.readJournal();
+        if (journal) {
+            if (journal.phase === 'target-committed') {
+                this.assertJournalRootBinding(journal);
+                await this.assertTargetIdentity(journal);
+                await this.assertTargetMarker(journal.targetCreationNonce);
+                return { directoryPath: journal.destinationPath, createDirectory: false };
+            }
+            this.assertJournalMatches(journal);
+            await this.assertSourceIdentity(journal);
+            return { directoryPath: journal.sourcePath, createDirectory: false };
+        }
+        const sourceIdentity = await readDirectoryIdentity(this.oldRoot, 'Legacy controller root');
+        if (sourceIdentity)
+            return { directoryPath: this.oldRoot, createDirectory: false };
+        await readDirectoryIdentity(this.newRoot, 'Target controller root', 0o700);
+        return { directoryPath: this.newRoot, createDirectory: true };
+    }
+    async run() {
+        this.options.signal?.throwIfAborted();
+        if (this.options.invokerPid !== process.pid) {
+            throw new Error('Controller data-root migration invoker PID is not the current process.');
+        }
+        const invokerIdentity = await readControllerProcessIdentity(this.options.invokerPid);
+        if (!invokerIdentity || invokerIdentity.pid !== this.options.invokerPid) {
+            throw new Error('Controller data-root migration invoker identity cannot be verified.');
+        }
+        await this.ensureCommonParent();
+        const lease = await this.acquireLock(invokerIdentity);
+        let operationError;
+        let result;
+        try {
+            result = await this.runLocked(invokerIdentity);
+        }
+        catch (errorArg) {
+            operationError = errorArg;
+        }
+        try {
+            await this.releaseLock(lease);
+        }
+        catch (errorArg) {
+            operationError = operationError
+                ? new AggregateError([operationError, errorArg], 'Controller data-root migration and lock release both failed.', { cause: operationError })
+                : errorArg;
+        }
+        if (operationError)
+            throw operationError;
+        return result;
+    }
+    normalizeDatabaseConfiguration(configArg) {
+        const value = assertPlainRecord(configArg, 'Controller database configuration');
+        const allowedKeys = new Set([
+            'mongoDbUrl',
+            'mongoDbName',
+            'embeddedDataDirectory',
+            'legacyEmbeddedDataDirectory',
+        ]);
+        if (Object.keys(value).some((key) => !allowedKeys.has(key))) {
+            throw new Error('Controller database configuration has unexpected fields.');
+        }
+        const mongoDbName = requireString(value.mongoDbName, 'Controller MongoDB database name', 256);
+        const oldDirectory = plugins.path.join(this.oldRoot, 'smartdb');
+        const targetDirectory = plugins.path.join(this.newRoot, 'smartdb');
+        if (value.mongoDbUrl !== undefined) {
+            const mongoDbUrl = requireString(value.mongoDbUrl, 'Controller MongoDB URL');
+            if (value.embeddedDataDirectory !== undefined || value.legacyEmbeddedDataDirectory !== undefined) {
+                throw new Error('External MongoDB configuration must not include embedded database paths.');
+            }
+            return {
+                mode: 'external',
+                configurationDigestSha256: databaseConfigurationDigest({
+                    mode: 'external',
+                    mongoDbUrl,
+                    mongoDbName,
+                }),
+                oldDirectory: null,
+                targetDirectory: null,
+                historicalDirectory: null,
+                effectiveConfig: { mongoDbUrl, mongoDbName },
+            };
+        }
+        const embeddedDataDirectory = assertAbsoluteNormalizedPath(requireString(value.embeddedDataDirectory, 'Controller embedded database path'), 'Controller embedded database path');
+        const historicalDirectory = value.legacyEmbeddedDataDirectory === undefined
+            ? null
+            : assertAbsoluteNormalizedPath(requireString(value.legacyEmbeddedDataDirectory, 'Historical embedded database path'), 'Historical embedded database path');
+        if (embeddedDataDirectory !== oldDirectory && embeddedDataDirectory !== targetDirectory) {
+            if (historicalDirectory !== null) {
+                throw new Error('An explicit embedded database override must not include a historical path.');
+            }
+            return {
+                mode: 'override',
+                configurationDigestSha256: databaseConfigurationDigest({
+                    mode: 'override',
+                    mongoDbName,
+                    embeddedDataDirectory,
+                }),
+                oldDirectory: null,
+                targetDirectory: null,
+                historicalDirectory: null,
+                effectiveConfig: { mongoDbName, embeddedDataDirectory },
+            };
+        }
+        if (historicalDirectory === oldDirectory || historicalDirectory === targetDirectory) {
+            throw new Error('Historical embedded database path must be outside both product roots.');
+        }
+        return {
+            mode: 'default',
+            configurationDigestSha256: databaseConfigurationDigest({
+                mode: 'default',
+                mongoDbName,
+                historicalDirectory,
+            }),
+            oldDirectory,
+            targetDirectory,
+            historicalDirectory,
+            effectiveConfig: { mongoDbName, embeddedDataDirectory: targetDirectory },
+        };
+    }
+    async validateCommonParent(requiredArg) {
+        let stats;
+        try {
+            stats = await plugins.fs.promises.lstat(this.commonParent, { bigint: true });
+        }
+        catch (errorArg) {
+            if (!requiredArg && isMissingError(errorArg))
+                return false;
+            throw errorArg;
+        }
+        if (!stats.isDirectory()
+            || stats.isSymbolicLink()
+            || stats.uid !== BigInt(currentUid())
+            || (Number(stats.mode & 511n) & 0o022) !== 0)
+            throw new Error(`Controller roots require a private real common parent: ${this.commonParent}`);
+        if (await plugins.fs.promises.realpath(this.commonParent) !== this.commonParent) {
+            throw new Error('Controller root common parent must not traverse symbolic links.');
+        }
+        return true;
+    }
+    async ensureCommonParent() {
+        await plugins.fs.promises.mkdir(this.commonParent, { recursive: true, mode: 0o700 });
+        if (!await this.validateCommonParent(true)) {
+            throw new Error('Controller root common parent could not be created.');
+        }
+    }
+    async readJournal() {
+        return (await readPrivateJson(this.journalPath, maximumJournalBytes, parseJournal, 'Controller data-root migration journal'))?.value;
+    }
+    async writeJournal(journalArg) {
+        await this.cleanupJournalTemporaryFiles();
+        await writePrivateJsonAtomic(this.journalPath, journalArg, maximumJournalBytes);
+        const persisted = await this.readJournal();
+        if (!persisted || JSON.stringify(persisted) !== JSON.stringify(journalArg)) {
+            throw new Error('Controller data-root migration journal was not persisted exactly.');
+        }
+    }
+    async cleanupJournalTemporaryFiles() {
+        const prefix = `${plugins.path.basename(this.journalPath)}.tmp-`;
+        const entries = await plugins.fs.promises.readdir(this.commonParent, { withFileTypes: true });
+        const temporaryNames = entries
+            .map((entry) => entry.name)
+            .filter((name) => name.startsWith(prefix));
+        if (temporaryNames.length > maximumMigrationTemporaryFiles) {
+            throw new Error('Too many controller migration journal artifacts exist.');
+        }
+        for (const name of temporaryNames) {
+            if (!new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[1-9][0-9]*-[a-f0-9]{16}$`).test(name)) {
+                throw new Error(`Unknown controller migration journal artifact: ${name}`);
+            }
+            const path = plugins.path.join(this.commonParent, name);
+            const identity = await inspectPrivateNode(path, 'file', 'Controller migration journal artifact', 0o600);
+            if (identity)
+                await unlinkExactPath(path, identity);
+        }
+        if (temporaryNames.length > 0)
+            await syncDirectory(this.commonParent);
+    }
+    assertJournalMatches(journalArg) {
+        this.assertJournalRootBinding(journalArg);
+        if (journalArg.database.configurationDigestSha256
+            !== this.databaseConfiguration.configurationDigestSha256) {
+            throw new Error('Controller database configuration changed during root migration.');
+        }
+        const database = journalArg.database;
+        if (database.mode !== this.databaseConfiguration.mode
+            || database.oldDirectory !== this.databaseConfiguration.oldDirectory
+            || database.targetDirectory !== this.databaseConfiguration.targetDirectory
+            || database.historicalDirectory !== this.databaseConfiguration.historicalDirectory)
+            throw new Error('Controller database migration journal paths do not match current inputs.');
+        if (database.mode !== 'default') {
+            if (database.strategy !== 'unchanged'
+                || database.phase !== 'verified'
+                || database.v1JournalLocation !== 'none'
+                || database.sourceDevice !== null
+                || database.destinationDevice !== null
+                || database.contentDigestSha256 !== null)
+                throw new Error('Unchanged controller database journal state is invalid.');
+        }
+        else if (database.strategy === 'fresh') {
+            if (database.phase !== 'verified'
+                || database.sourcePath !== null
+                || database.sourceDevice !== null
+                || database.destinationDevice !== null
+                || database.contentDigestSha256 !== null
+                || database.v1JournalLocation !== 'none')
+                throw new Error('Fresh controller database journal state is invalid.');
+        }
+        else if (database.strategy === 'historical-direct') {
+            if (database.sourcePath !== database.historicalDirectory
+                || database.v1JournalLocation !== 'target'
+                || database.phase === 'prepared'
+                || database.phase === 'moved')
+                throw new Error('Historical controller database journal state is invalid.');
+        }
+        else if (database.strategy === 'old-relocation') {
+            if (database.sourcePath !== database.oldDirectory
+                || database.v1JournalLocation === 'target')
+                throw new Error('Old controller database relocation journal state is invalid.');
+        }
+        else {
+            throw new Error('Default controller database migration strategy is invalid.');
+        }
+        if (database.phase === 'pending' && database.strategy === 'old-relocation') {
+            if (database.sourceDevice !== null
+                || database.destinationDevice !== null
+                || database.contentDigestSha256 !== null)
+                throw new Error('Pending controller database relocation state is invalid.');
+        }
+        if (database.phase === 'prepared') {
+            if (database.sourceDevice === null
+                || database.destinationDevice !== null
+                || database.contentDigestSha256 === null)
+                throw new Error('Prepared controller database relocation state is invalid.');
+        }
+        if (database.phase === 'moved' || (database.phase === 'verified'
+            && (database.strategy === 'historical-direct' || database.strategy === 'old-relocation'))) {
+            if (database.destinationDevice === null || database.contentDigestSha256 === null) {
+                throw new Error('Moved controller database relocation state is invalid.');
+            }
+        }
+        const seenHashes = new Set();
+        for (let index = 0; index < journalArg.credentials.length; index += 1) {
+            const tuple = journalArg.credentials[index];
+            if (seenHashes.has(tuple.controllerHash)) {
+                throw new Error('Controller credential migration journal contains duplicate hashes.');
+            }
+            seenHashes.add(tuple.controllerHash);
+            if ((index > 0 && journalArg.credentials[index - 1].controllerHash > tuple.controllerHash)
+                || tuple.service !== `modelprofile.flexharness.${tuple.controllerHash.slice(0, 32)}`
+                || tuple.storeId !== flexProviderCredentialStoreId
+                || tuple.sourceDirectory !== plugins.path.join(this.oldRoot, 'flex-provider-credentials', tuple.controllerHash)
+                || tuple.destinationDirectory !== plugins.path.join(this.newRoot, 'flex-provider-credentials', tuple.controllerHash))
+                throw new Error('Controller credential migration tuple does not match its roots.');
+        }
+    }
+    assertJournalRootBinding(journalArg) {
+        if (journalArg.sourcePath !== this.oldRoot || journalArg.destinationPath !== this.newRoot) {
+            throw new Error('Controller data-root migration journal belongs to different roots.');
+        }
+        const destinationIdentityPresent = journalArg.destinationDevice !== null;
+        if ((journalArg.phase === 'legacy-authoritative') === destinationIdentityPresent) {
+            throw new Error('Controller data-root migration destination identity conflicts with its phase.');
+        }
+    }
+    async assertSourceIdentity(journalArg) {
+        const identity = await readDirectoryIdentity(this.oldRoot, 'Legacy controller root');
+        if (journalArg.sourceDevice === null) {
+            if (identity)
+                throw new Error('Legacy controller root appeared after migration preparation.');
+            return;
+        }
+        if (!identity || !identitiesEqual(identity, {
+            device: journalArg.sourceDevice,
+            inode: journalArg.sourceInode,
+        }))
+            throw new Error('Legacy controller root identity changed during migration.');
+    }
+    async assertTargetIdentity(journalArg) {
+        if (journalArg.destinationDevice === null) {
+            throw new Error('Controller target root identity was not recorded.');
+        }
+        const identity = await readDirectoryIdentity(this.newRoot, 'Target controller root', 0o700);
+        if (!identity || !identitiesEqual(identity, {
+            device: journalArg.destinationDevice,
+            inode: journalArg.destinationInode,
+        }))
+            throw new Error('Controller target root identity changed during migration.');
+    }
+    async assertTargetMarker(nonceArg) {
+        const marker = await readPrivateJson(this.markerPath, maximumMarkerBytes, parseMarker, 'Controller target marker');
+        if (!marker || marker.value.targetCreationNonce !== nonceArg) {
+            throw new Error('Controller target marker is missing or belongs to another migration.');
+        }
+    }
+    async runLocked(invokerIdentityArg) {
+        let journal = await this.readJournal();
+        if (journal?.phase === 'target-committed') {
+            this.assertJournalRootBinding(journal);
+            await this.assertTargetIdentity(journal);
+            await this.assertTargetMarker(journal.targetCreationNonce);
+            return this.result();
+        }
+        if (journal)
+            this.assertJournalMatches(journal);
+        await this.assertNoConflictingWriters(invokerIdentityArg);
+        await drainRetainedEmbeddedDatabaseMigrationResources();
+        await this.cleanupJournalTemporaryFiles();
+        journal = await this.readJournal();
+        if (journal)
+            this.assertJournalMatches(journal);
+        if (!journal)
+            journal = await this.createInitialJournal();
+        await this.assertSourceIdentity(journal);
+        await this.inspectLegacyRootInventory(journal);
+        await this.validateCredentialLocations(journal, false);
+        if (journal.database.mode === 'default')
+            await this.assertDefaultDatabaseSocketsIdle();
+        if (journal.database.strategy === 'old-relocation'
+            && journal.database.phase === 'pending')
+            journal = await this.prepareOldDatabaseRelocation(journal);
+        journal = await this.ensureTargetStaged(journal);
+        journal = await this.performDatabaseMigration(journal);
+        journal = await this.performCredentialMigrations(journal);
+        if (journal.database.phase !== 'verified') {
+            throw new Error('Controller database migration is not verified.');
+        }
+        if (journal.credentials.some((tuple) => !tuple.complete)) {
+            throw new Error('Controller credential migration is not complete.');
+        }
+        await this.validateCredentialLocations(journal, true);
+        await this.inspectTargetStagingInventory(journal);
+        await this.assertTargetIdentity(journal);
+        const committed = {
+            ...journal,
+            phase: 'target-committed',
+        };
+        await this.writeJournal(committed);
+        return this.result();
+    }
+    result() {
+        return {
+            directoryPath: this.newRoot,
+            databaseConfig: { ...this.databaseConfiguration.effectiveConfig },
+        };
+    }
+    async assertNoConflictingWriters(invokerIdentityArg) {
+        const records = await this.options.listDataWriterProcesses();
+        if (!Array.isArray(records) || records.length > 1_024) {
+            throw new Error('Controller data-writer process inventory is invalid.');
+        }
+        for (const record of records) {
+            if (!record
+                || (record.kind !== 'controller'
+                    && record.kind !== 'temp-password'
+                    && record.kind !== 'flex-child')
+                || !Number.isSafeInteger(record.identity?.pid)
+                || record.identity.pid < 2
+                || typeof record.identity.fingerprint !== 'string'
+                || record.identity.fingerprint.length === 0)
+                throw new Error('Controller data-writer process record is invalid.');
+            if (record.identity.pid === invokerIdentityArg.pid
+                && record.identity.fingerprint === invokerIdentityArg.fingerprint)
+                continue;
+            throw new Error(`Controller data-root migration is blocked by ${record.kind} writer PID ${record.identity.pid}.`);
+        }
+    }
+    async createInitialJournal() {
+        const sourceIdentity = await readDirectoryIdentity(this.oldRoot, 'Legacy controller root');
+        const targetIdentity = await readDirectoryIdentity(this.newRoot, 'Target controller root', 0o700);
+        if (sourceIdentity && targetIdentity) {
+            throw new Error('Both unjournaled controller product roots exist; refusing to choose authority.');
+        }
+        if (sourceIdentity)
+            await this.inspectLegacyRootInventory();
+        if (targetIdentity) {
+            const entries = await this.readBoundedDirectory(this.newRoot, 'Target controller root');
+            if (entries.length !== 0) {
+                throw new Error('An unjournaled target controller root is not empty.');
+            }
+        }
+        const credentials = await this.initialCredentialTuples(sourceIdentity !== undefined);
+        const database = await this.initialDatabaseJournal();
+        const journal = {
+            version: migrationVersion,
+            phase: 'legacy-authoritative',
+            sourcePath: this.oldRoot,
+            sourceDevice: sourceIdentity?.device ?? null,
+            sourceInode: sourceIdentity?.inode ?? null,
+            destinationPath: this.newRoot,
+            destinationDevice: null,
+            destinationInode: null,
+            targetCreationNonce: plugins.crypto.randomBytes(32).toString('hex'),
+            database,
+            credentials,
+        };
+        this.assertJournalMatches(journal);
+        await this.writeJournal(journal);
+        return journal;
+    }
+    async readBoundedDirectory(directoryArg, labelArg) {
+        const entries = await plugins.fs.promises.readdir(directoryArg, { withFileTypes: true });
+        if (entries.length > maximumRootEntries)
+            throw new Error(`${labelArg} has too many entries.`);
+        return entries.map((entry) => entry.name).sort();
+    }
+    async inspectLegacyRootInventory(journalArg) {
+        const identity = await readDirectoryIdentity(this.oldRoot, 'Legacy controller root');
+        if (!identity)
+            return;
+        const names = await this.readBoundedDirectory(this.oldRoot, 'Legacy controller root');
+        let migrationTemporaryFiles = 0;
+        let controllerLogs = 0;
+        let upgradeLogs = 0;
+        for (const name of names) {
+            const path = plugins.path.join(this.oldRoot, name);
+            if (name === 'smartdb') {
+                const databaseMayBeRelocated = journalArg?.database.strategy === 'old-relocation'
+                    && journalArg.database.phase !== 'pending';
+                if (databaseMayBeRelocated) {
+                    const stats = await plugins.fs.promises.lstat(path);
+                    if (stats.isFile()) {
+                        await this.requirePrivateNode(path, 'file', 'Legacy controller smartdb receipt', 0o600);
+                    }
+                    else {
+                        await this.requirePrivateNode(path, 'directory', 'Legacy controller smartdb');
+                    }
+                }
+                else {
+                    await this.requirePrivateNode(path, 'directory', 'Legacy controller smartdb');
+                }
+                continue;
+            }
+            if (name === 'browser-runtime') {
+                await this.requirePrivateNode(path, 'directory', `Legacy controller ${name}`);
+                continue;
+            }
+            if (name === 'flex-provider-credentials') {
+                await this.requirePrivateNode(path, 'directory', 'Legacy Flex credential root', 0o700);
+                continue;
+            }
+            if (name === embeddedDatabaseJournalFileName) {
+                await this.requirePrivateNode(path, 'file', 'Legacy embedded database journal');
+                continue;
+            }
+            if (embeddedDatabaseJournalTemporaryPattern.test(name)) {
+                migrationTemporaryFiles += 1;
+                await this.requirePrivateNode(path, 'file', 'Legacy embedded database journal artifact');
+                continue;
+            }
+            const controllerLogMatch = controllerLogPattern.exec(name);
+            if (controllerLogMatch && Number(controllerLogMatch[1]) <= 65_535) {
+                controllerLogs += 1;
+                await this.requirePrivateNode(path, 'file', 'Legacy controller log');
+                continue;
+            }
+            if (upgradeLogPattern.test(name)) {
+                upgradeLogs += 1;
+                await this.requirePrivateNode(path, 'file', 'Legacy controller upgrade log');
+                continue;
+            }
+            throw new Error(`Unknown authoritative entry in legacy controller root: ${name}`);
+        }
+        if (migrationTemporaryFiles > maximumMigrationTemporaryFiles
+            || controllerLogs > maximumControllerLogs
+            || upgradeLogs > maximumUpgradeLogs)
+            throw new Error('Legacy controller root contains too many bounded migration assets.');
+        if (journalArg)
+            await this.assertSourceIdentity(journalArg);
+    }
+    async requirePrivateNode(pathArg, kindArg, labelArg, exactModeArg) {
+        const identity = await inspectPrivateNode(pathArg, kindArg, labelArg, exactModeArg);
+        if (!identity)
+            throw new Error(`${labelArg} disappeared during inspection.`);
+        return identity;
+    }
+    async initialCredentialTuples(sourceRootExistsArg) {
+        if (!sourceRootExistsArg)
+            return [];
+        const credentialRoot = plugins.path.join(this.oldRoot, 'flex-provider-credentials');
+        const identity = await readDirectoryIdentity(credentialRoot, 'Legacy Flex credential root', 0o700);
+        if (!identity)
+            return [];
+        const hashes = await this.readCredentialHashes(credentialRoot, 'Legacy Flex credential root');
+        return hashes.map((controllerHash) => ({
+            controllerHash,
+            service: `modelprofile.flexharness.${controllerHash.slice(0, 32)}`,
+            storeId: flexProviderCredentialStoreId,
+            sourceDirectory: plugins.path.join(credentialRoot, controllerHash),
+            destinationDirectory: plugins.path.join(this.newRoot, 'flex-provider-credentials', controllerHash),
+            complete: false,
+        }));
+    }
+    async readCredentialHashes(directoryArg, labelArg) {
+        const entries = await plugins.fs.promises.readdir(directoryArg, { withFileTypes: true });
+        if (entries.length > maximumCredentialStores) {
+            throw new Error(`${labelArg} contains too many credential stores.`);
+        }
+        const hashes = entries.map((entry) => entry.name).sort();
+        for (const hash of hashes) {
+            if (!credentialHashPattern.test(hash)) {
+                throw new Error(`${labelArg} contains an unexpected entry: ${hash}`);
+            }
+            await this.requirePrivateNode(plugins.path.join(directoryArg, hash), 'directory', 'Flex credential store directory', 0o700);
+        }
+        return hashes;
+    }
+    async initialDatabaseJournal() {
+        const configuration = this.databaseConfiguration;
+        if (configuration.mode !== 'default') {
+            return {
+                mode: configuration.mode,
+                strategy: 'unchanged',
+                phase: 'verified',
+                configurationDigestSha256: configuration.configurationDigestSha256,
+                oldDirectory: null,
+                targetDirectory: null,
+                historicalDirectory: null,
+                sourcePath: configuration.mode === 'override'
+                    ? configuration.effectiveConfig.embeddedDataDirectory
+                    : null,
+                sourceDevice: null,
+                sourceInode: null,
+                destinationDevice: null,
+                destinationInode: null,
+                contentDigestSha256: null,
+                v1JournalLocation: 'none',
+            };
+        }
+        const oldDirectory = configuration.oldDirectory;
+        const targetDirectory = configuration.targetDirectory;
+        const historicalDirectory = configuration.historicalDirectory;
+        const oldIdentity = await readDirectoryIdentity(oldDirectory, 'Legacy config-root database');
+        const historicalIdentity = historicalDirectory
+            ? await readDirectoryIdentity(historicalDirectory, 'Historical state-root database')
+            : undefined;
+        const oldV1JournalPath = plugins.path.join(this.oldRoot, embeddedDatabaseJournalFileName);
+        const oldV1Journal = await inspectPrivateNode(oldV1JournalPath, 'file', 'Legacy embedded database journal');
+        if (oldV1Journal && !historicalDirectory) {
+            throw new Error('Legacy embedded database journal has no configured historical source path.');
+        }
+        if (historicalIdentity && oldIdentity && !oldV1Journal) {
+            throw new Error('Historical and config-root controller databases collide without a matching v1 journal.');
+        }
+        if (oldV1Journal || oldIdentity) {
+            return {
+                mode: 'default',
+                strategy: 'old-relocation',
+                phase: 'pending',
+                configurationDigestSha256: configuration.configurationDigestSha256,
+                oldDirectory,
+                targetDirectory,
+                historicalDirectory,
+                sourcePath: oldDirectory,
+                sourceDevice: null,
+                sourceInode: null,
+                destinationDevice: null,
+                destinationInode: null,
+                contentDigestSha256: null,
+                v1JournalLocation: oldV1Journal ? 'legacy' : 'none',
+            };
+        }
+        if (historicalIdentity) {
+            return {
+                mode: 'default',
+                strategy: 'historical-direct',
+                phase: 'pending',
+                configurationDigestSha256: configuration.configurationDigestSha256,
+                oldDirectory,
+                targetDirectory,
+                historicalDirectory,
+                sourcePath: historicalDirectory,
+                sourceDevice: historicalIdentity.device,
+                sourceInode: historicalIdentity.inode,
+                destinationDevice: null,
+                destinationInode: null,
+                contentDigestSha256: null,
+                v1JournalLocation: 'target',
+            };
+        }
+        return {
+            mode: 'default',
+            strategy: 'fresh',
+            phase: 'verified',
+            configurationDigestSha256: configuration.configurationDigestSha256,
+            oldDirectory,
+            targetDirectory,
+            historicalDirectory,
+            sourcePath: null,
+            sourceDevice: null,
+            sourceInode: null,
+            destinationDevice: null,
+            destinationInode: null,
+            contentDigestSha256: null,
+            v1JournalLocation: 'none',
+        };
+    }
+    async assertDefaultDatabaseSocketsIdle() {
+        for (const socketPath of [
+            this.options.oldEmbeddedSocketPath,
+            this.options.newEmbeddedSocketPath,
+        ]) {
+            this.options.signal?.throwIfAborted();
+            if (await this.isSocketListening(socketPath)) {
+                throw new Error(`Controller embedded database socket is still active: ${socketPath}`);
+            }
+        }
+    }
+    async prepareOldDatabaseRelocation(journalArg) {
+        const database = journalArg.database;
+        if (database.strategy !== 'old-relocation' || database.phase !== 'pending')
+            return journalArg;
+        if (database.v1JournalLocation === 'legacy') {
+            if (!database.historicalDirectory || !database.oldDirectory) {
+                throw new Error('Legacy database migration journal paths are incomplete.');
+            }
+            const migration = new EmbeddedDatabaseLocationMigration({
+                sourceDirectory: database.historicalDirectory,
+                destinationDirectory: database.oldDirectory,
+                sourceSocketPath: embeddedDatabaseSocketPath(database.historicalDirectory),
+                destinationSocketPath: this.options.oldEmbeddedSocketPath,
+            });
+            await runEmbeddedDatabaseLocationMigration(migration);
+        }
+        const sourceIdentity = await readDirectoryIdentity(database.oldDirectory, 'Legacy config-root database');
+        if (!sourceIdentity)
+            throw new Error('Legacy config-root database is missing before relocation.');
+        this.options.signal?.throwIfAborted();
+        const contentDigestSha256 = await inspectDatabaseContentDigest(database.oldDirectory);
+        const prepared = {
+            ...journalArg,
+            database: {
+                ...database,
+                phase: 'prepared',
+                sourceDevice: sourceIdentity.device,
+                sourceInode: sourceIdentity.inode,
+                contentDigestSha256,
+            },
+        };
+        await this.writeJournal(prepared);
+        return prepared;
+    }
+    async ensureTargetStaged(journalArg) {
+        if (journalArg.phase !== 'legacy-authoritative') {
+            await this.assertTargetIdentity(journalArg);
+            await this.assertTargetMarker(journalArg.targetCreationNonce);
+            await this.inspectTargetStagingInventory(journalArg);
+            return journalArg;
+        }
+        let targetIdentity = await readDirectoryIdentity(this.newRoot, 'Target controller root', 0o700);
+        if (!targetIdentity) {
+            await plugins.fs.promises.mkdir(this.newRoot, { mode: 0o700 });
+            await syncDirectory(this.commonParent);
+            targetIdentity = await readDirectoryIdentity(this.newRoot, 'Target controller root', 0o700);
+            if (!targetIdentity)
+                throw new Error('Target controller root was not created.');
+        }
+        const entries = await this.readBoundedDirectory(this.newRoot, 'Target controller root');
+        if (entries.length > 1
+            || (entries.length === 1 && entries[0] !== markerFileName)) {
+            throw new Error('Legacy-authoritative retry found an unexpected staged target entry.');
+        }
+        await this.ensureTargetMarker(journalArg.targetCreationNonce);
+        await syncDirectory(this.newRoot);
+        const stagedIdentity = await readDirectoryIdentity(this.newRoot, 'Target controller root', 0o700);
+        if (!stagedIdentity || !identitiesEqual(stagedIdentity, targetIdentity)) {
+            throw new Error('Target controller root identity changed while it was staged.');
+        }
+        const staged = {
+            ...journalArg,
+            phase: 'target-staged',
+            destinationDevice: stagedIdentity.device,
+            destinationInode: stagedIdentity.inode,
+        };
+        await this.writeJournal(staged);
+        return staged;
+    }
+    async ensureTargetMarker(nonceArg) {
+        const existing = await readPrivateJson(this.markerPath, maximumMarkerBytes, parseMarker, 'Controller target marker');
+        if (existing) {
+            if (existing.value.targetCreationNonce !== nonceArg) {
+                throw new Error('Controller target marker belongs to another migration.');
+            }
+            return;
+        }
+        const temporaryPath = plugins.path.join(this.commonParent, `${markerFileName}.tmp-${nonceArg}`);
+        let temporary = await readPrivateJson(temporaryPath, maximumMarkerBytes, parseMarker, 'Controller target marker artifact');
+        if (!temporary) {
+            const marker = { version: migrationVersion, targetCreationNonce: nonceArg };
+            const serialized = `${JSON.stringify(marker)}\n`;
+            let handle;
+            let temporaryIdentity;
+            try {
+                handle = await plugins.fs.promises.open(temporaryPath, plugins.fs.constants.O_WRONLY
+                    | plugins.fs.constants.O_CREAT
+                    | plugins.fs.constants.O_EXCL
+                    | plugins.fs.constants.O_NOFOLLOW, 0o600);
+                temporaryIdentity = pathIdentity(await handle.stat({ bigint: true }));
+                await handle.chmod(0o600);
+                await handle.writeFile(serialized, 'utf8');
+                await handle.sync();
+                await handle.close();
+                handle = undefined;
+                await syncDirectory(this.commonParent);
+                temporary = await readPrivateJson(temporaryPath, maximumMarkerBytes, parseMarker, 'Controller target marker artifact');
+                temporaryIdentity = undefined;
+            }
+            catch (errorArg) {
+                const cleanupErrors = [];
+                if (handle) {
+                    try {
+                        await handle.close();
+                    }
+                    catch (cleanupErrorArg) {
+                        cleanupErrors.push(cleanupErrorArg);
+                    }
+                }
+                if (temporaryIdentity) {
+                    try {
+                        await unlinkExactPath(temporaryPath, temporaryIdentity);
+                        await syncDirectory(this.commonParent);
+                    }
+                    catch (cleanupErrorArg) {
+                        cleanupErrors.push(cleanupErrorArg);
+                    }
+                }
+                if (cleanupErrors.length > 0) {
+                    throw new AggregateError([errorArg, ...cleanupErrors], 'Controller target marker publication failed and cleanup was incomplete.', { cause: errorArg });
+                }
+                throw errorArg;
+            }
+        }
+        if (!temporary || temporary.value.targetCreationNonce !== nonceArg) {
+            throw new Error('Controller target marker artifact belongs to another migration.');
+        }
+        await plugins.fs.promises.rename(temporaryPath, this.markerPath);
+        await syncDirectory(this.newRoot);
+        await syncDirectory(this.commonParent);
+        await this.assertTargetMarker(nonceArg);
+    }
+    async inspectTargetStagingInventory(journalArg) {
+        await this.assertTargetIdentity(journalArg);
+        await this.assertTargetMarker(journalArg.targetCreationNonce);
+        const names = await this.readBoundedDirectory(this.newRoot, 'Staged target controller root');
+        let migrationTemporaryFiles = 0;
+        for (const name of names) {
+            const path = plugins.path.join(this.newRoot, name);
+            if (name === markerFileName)
+                continue;
+            if (name === 'smartdb') {
+                await this.requirePrivateNode(path, 'directory', 'Staged target controller database');
+                continue;
+            }
+            if (name === 'flex-provider-credentials') {
+                await this.requirePrivateNode(path, 'directory', 'Staged target Flex credential root', 0o700);
+                continue;
+            }
+            if (name === embeddedDatabaseJournalFileName) {
+                await this.requirePrivateNode(path, 'file', 'Staged target embedded database journal');
+                continue;
+            }
+            if (embeddedDatabaseJournalTemporaryPattern.test(name)) {
+                migrationTemporaryFiles += 1;
+                await this.requirePrivateNode(path, 'file', 'Staged embedded database journal artifact');
+                continue;
+            }
+            throw new Error(`Unexpected entry in staged target controller root: ${name}`);
+        }
+        if (migrationTemporaryFiles > maximumMigrationTemporaryFiles) {
+            throw new Error('Staged target has too many embedded database journal artifacts.');
+        }
+    }
+    async performDatabaseMigration(journalArg) {
+        if (journalArg.database.phase === 'verified') {
+            if (journalArg.database.strategy === 'old-relocation') {
+                await this.confirmOldDatabaseRelocation(journalArg);
+                await this.assertRelocatedDatabaseDigest(journalArg);
+            }
+            return journalArg;
+        }
+        if (journalArg.database.strategy === 'historical-direct') {
+            return await this.performDirectHistoricalDatabaseMigration(journalArg);
+        }
+        if (journalArg.database.strategy !== 'old-relocation') {
+            throw new Error('Controller database migration journal is not actionable.');
+        }
+        let journal = journalArg;
+        if (journal.database.phase === 'prepared')
+            journal = await this.moveOldDatabase(journal);
+        if (journal.database.phase !== 'moved') {
+            throw new Error('Controller database relocation did not reach its moved phase.');
+        }
+        await this.confirmOldDatabaseRelocation(journal);
+        const database = journal.database;
+        await this.assertRelocatedDatabaseDigest(journal);
+        if (database.v1JournalLocation === 'legacy') {
+            await rebaseCompletedEmbeddedDatabaseLocationMigration({
+                sourceDirectory: database.historicalDirectory,
+                previousDestinationDirectory: database.oldDirectory,
+                destinationDirectory: database.targetDirectory,
+            });
+        }
+        const verified = {
+            ...journal,
+            database: { ...database, phase: 'verified' },
+        };
+        await this.writeJournal(verified);
+        return verified;
+    }
+    async moveOldDatabase(journalArg) {
+        const database = journalArg.database;
+        const destinationIdentity = await this.confirmOldDatabaseRelocation(journalArg);
+        const moved = {
+            ...journalArg,
+            database: {
+                ...database,
+                phase: 'moved',
+                destinationDevice: destinationIdentity.device,
+                destinationInode: destinationIdentity.inode,
+            },
+        };
+        await this.writeJournal(moved);
+        return moved;
+    }
+    async confirmOldDatabaseRelocation(journalArg) {
+        const database = journalArg.database;
+        if (database.strategy !== 'old-relocation'
+            || database.phase === 'pending'
+            || !database.oldDirectory
+            || !database.targetDirectory
+            || !database.sourceDevice
+            || !database.sourceInode)
+            throw new Error('Controller database relocation is not prepared for replay.');
+        const input = {
+            sourceFolderPath: database.oldDirectory,
+            destinationFolderPath: database.targetDirectory,
+            relocationId: `hcon-controller-data-root-v2:${journalArg.targetCreationNonce}:smartdb`,
+        };
+        this.options.signal?.throwIfAborted();
+        const receipt = await this.relocateStoppedDatabaseRoot(input, this.options.signal);
+        const receiptRecord = assertPlainRecord(receipt, 'Controller SmartDB relocation receipt');
+        const receiptKeys = [
+            'format',
+            'version',
+            'relocationId',
+            'sourceFolderPath',
+            'destinationFolderPath',
+            'providerRootId',
+            'storageRootDevice',
+            'storageRootInode',
+            'receiptSha256',
+            'sourceReceiptRetained',
+        ];
+        assertExactKeys(receiptRecord, receiptKeys, 'Controller SmartDB relocation receipt');
+        if (receipt.format !== 'smartdb.storage-root-relocation.receipt.v1'
+            || receipt.version !== 1
+            || receipt.relocationId !== input.relocationId
+            || receipt.sourceFolderPath !== input.sourceFolderPath
+            || receipt.destinationFolderPath !== input.destinationFolderPath
+            || !digestPattern.test(receipt.providerRootId)
+            || !digestPattern.test(receipt.receiptSha256)
+            || receipt.storageRootDevice !== database.sourceDevice
+            || receipt.storageRootInode !== database.sourceInode
+            || (database.phase !== 'prepared' && (receipt.storageRootDevice !== database.destinationDevice
+                || receipt.storageRootInode !== database.destinationInode))
+            || receipt.sourceReceiptRetained !== true)
+            throw new Error('Controller SmartDB relocation receipt does not match its prepared source.');
+        const retainedReceipt = await readPrivateJson(database.oldDirectory, maximumSmartDbRelocationReceiptBytes, (valueArg) => {
+            const value = assertPlainRecord(valueArg, 'Retained controller SmartDB relocation receipt');
+            assertExactKeys(value, receiptKeys, 'Retained controller SmartDB relocation receipt');
+            return value;
+        }, 'Retained controller SmartDB relocation receipt');
+        if (!retainedReceipt
+            || receiptKeys.some((key) => retainedReceipt.value[key] !== receiptRecord[key]))
+            throw new Error('Retained controller SmartDB relocation receipt does not match the API receipt.');
+        const destinationIdentity = await readDirectoryIdentity(database.targetDirectory, 'Target controller database');
+        const receiptIdentity = {
+            device: receipt.storageRootDevice,
+            inode: receipt.storageRootInode,
+        };
+        if (!destinationIdentity || !identitiesEqual(destinationIdentity, receiptIdentity)) {
+            throw new Error('Controller database relocation identity could not be confirmed.');
+        }
+        return destinationIdentity;
+    }
+    async assertRelocatedDatabaseDigest(journalArg) {
+        const database = journalArg.database;
+        const digest = await inspectDatabaseContentDigest(database.targetDirectory);
+        if (digest !== database.contentDigestSha256) {
+            throw new Error('Relocated controller database content digest does not match its source.');
+        }
+    }
+    async performDirectHistoricalDatabaseMigration(journalArg) {
+        const database = journalArg.database;
+        if (database.phase !== 'pending' || !database.historicalDirectory) {
+            throw new Error('Direct historical database migration state is invalid.');
+        }
+        const sourceIdentity = await readDirectoryIdentity(database.historicalDirectory, 'Historical state-root database');
+        if (!sourceIdentity || !identitiesEqual(sourceIdentity, {
+            device: database.sourceDevice,
+            inode: database.sourceInode,
+        }))
+            throw new Error('Historical controller database identity changed before migration.');
+        const migration = new EmbeddedDatabaseLocationMigration({
+            sourceDirectory: database.historicalDirectory,
+            destinationDirectory: database.targetDirectory,
+            sourceSocketPath: embeddedDatabaseSocketPath(database.historicalDirectory),
+            destinationSocketPath: this.options.newEmbeddedSocketPath,
+        });
+        await runEmbeddedDatabaseLocationMigration(migration);
+        const destinationIdentity = await readDirectoryIdentity(database.targetDirectory, 'Target controller database');
+        if (!destinationIdentity)
+            throw new Error('Directly migrated controller database is missing.');
+        const contentDigestSha256 = await inspectDatabaseContentDigest(database.targetDirectory);
+        const verified = {
+            ...journalArg,
+            database: {
+                ...database,
+                phase: 'verified',
+                destinationDevice: destinationIdentity.device,
+                destinationInode: destinationIdentity.inode,
+                contentDigestSha256,
+            },
+        };
+        await this.writeJournal(verified);
+        return verified;
+    }
+    async performCredentialMigrations(journalArg) {
+        let journal = journalArg;
+        if (journal.credentials.length === 0)
+            return journal;
+        const destinationRoot = plugins.path.join(this.newRoot, 'flex-provider-credentials');
+        const existingDestinationRoot = await readDirectoryIdentity(destinationRoot, 'Target Flex credential root', 0o700);
+        if (!existingDestinationRoot) {
+            await plugins.fs.promises.mkdir(destinationRoot, { mode: 0o700 });
+            await syncDirectory(this.newRoot);
+        }
+        await readDirectoryIdentity(destinationRoot, 'Target Flex credential root', 0o700);
+        for (let index = 0; index < journal.credentials.length; index += 1) {
+            const tuple = journal.credentials[index];
+            if (tuple.complete)
+                continue;
+            this.options.signal?.throwIfAborted();
+            await this.relocateCredentialStore({
+                controllerHash: tuple.controllerHash,
+                service: tuple.service,
+                storeId: tuple.storeId,
+                sourceDirectory: tuple.sourceDirectory,
+                destinationDirectory: tuple.destinationDirectory,
+            }, this.options.signal);
+            const sourceIdentity = await readDirectoryIdentity(tuple.sourceDirectory, 'Relocated Flex credential source', 0o700);
+            const destinationIdentity = await readDirectoryIdentity(tuple.destinationDirectory, 'Relocated Flex credential destination', 0o700);
+            if (sourceIdentity || !destinationIdentity) {
+                throw new Error(`Flex credential relocation was not confirmed: ${tuple.controllerHash}`);
+            }
+            const credentials = journal.credentials.map((entry, entryIndex) => entryIndex === index
+                ? { ...entry, complete: true }
+                : entry);
+            journal = { ...journal, credentials };
+            await this.writeJournal(journal);
+        }
+        return journal;
+    }
+    async validateCredentialLocations(journalArg, requireCompleteArg) {
+        if (journalArg.credentials.length === 0)
+            return;
+        const sourceRoot = plugins.path.join(this.oldRoot, 'flex-provider-credentials');
+        const destinationRoot = plugins.path.join(this.newRoot, 'flex-provider-credentials');
+        const sourceRootIdentity = await readDirectoryIdentity(sourceRoot, 'Legacy Flex credential root', 0o700);
+        if (!sourceRootIdentity)
+            throw new Error('Legacy Flex credential root disappeared during migration.');
+        const destinationRootIdentity = await readDirectoryIdentity(destinationRoot, 'Target Flex credential root', 0o700);
+        if (journalArg.phase !== 'legacy-authoritative' && !destinationRootIdentity) {
+            const hasDestinationStore = journalArg.credentials.some((tuple) => tuple.complete);
+            if (hasDestinationStore)
+                throw new Error('Target Flex credential root is missing.');
+        }
+        const sourceHashes = new Set(await this.readCredentialHashes(sourceRoot, 'Legacy Flex credential root'));
+        const destinationHashes = destinationRootIdentity
+            ? new Set(await this.readCredentialHashes(destinationRoot, 'Target Flex credential root'))
+            : new Set();
+        const expectedHashes = new Set(journalArg.credentials.map((tuple) => tuple.controllerHash));
+        for (const hash of [...sourceHashes, ...destinationHashes]) {
+            if (!expectedHashes.has(hash)) {
+                throw new Error(`Unexpected Flex credential store appeared during migration: ${hash}`);
+            }
+        }
+        for (const tuple of journalArg.credentials) {
+            const sourcePresent = sourceHashes.has(tuple.controllerHash);
+            const destinationPresent = destinationHashes.has(tuple.controllerHash);
+            if (sourcePresent === destinationPresent) {
+                throw new Error(`Flex credential store has ambiguous location: ${tuple.controllerHash}`);
+            }
+            if ((tuple.complete || requireCompleteArg) && !destinationPresent) {
+                throw new Error(`Completed Flex credential store is not at its target: ${tuple.controllerHash}`);
+            }
+        }
+    }
+    async acquireLock(invokerIdentityArg) {
+        await this.cleanupStaleLockTemporaries();
+        const owner = {
+            version: 1,
+            uid: currentUid(),
+            pid: invokerIdentityArg.pid,
+            processFingerprint: invokerIdentityArg.fingerprint,
+            nonce: plugins.crypto.randomBytes(32).toString('hex'),
+        };
+        const temporaryPath = `${this.lockPath}.tmp-${owner.uid}-${owner.pid}-${owner.nonce}`;
+        const serialized = `${JSON.stringify(owner)}\n`;
+        let temporaryHandle;
+        let temporaryIdentity;
+        let publishedLockIdentity;
+        try {
+            temporaryHandle = await plugins.fs.promises.open(temporaryPath, plugins.fs.constants.O_WRONLY
+                | plugins.fs.constants.O_CREAT
+                | plugins.fs.constants.O_EXCL
+                | plugins.fs.constants.O_NOFOLLOW, 0o600);
+            temporaryIdentity = pathIdentity(await temporaryHandle.stat({ bigint: true }));
+            await temporaryHandle.chmod(0o600);
+            await temporaryHandle.writeFile(serialized, 'utf8');
+            await temporaryHandle.sync();
+            await temporaryHandle.close();
+            temporaryHandle = undefined;
+            const publishedTemporaryIdentity = temporaryIdentity;
+            for (let attempt = 0; attempt < maximumLockAttempts; attempt += 1) {
+                this.options.signal?.throwIfAborted();
+                if ((await this.listLockArtifacts()).guards.length > 0) {
+                    await this.cleanupStaleLockTemporaries();
+                    await delay(lockWaitMilliseconds, this.options.signal);
+                    continue;
+                }
+                try {
+                    await plugins.fs.promises.link(temporaryPath, this.lockPath);
+                    publishedLockIdentity = publishedTemporaryIdentity;
+                    await syncDirectory(this.commonParent);
+                    const published = await this.readLockSnapshot(this.lockPath);
+                    if (!published
+                        || !identitiesEqual(published.identity, publishedTemporaryIdentity)
+                        || JSON.stringify(published.owner) !== JSON.stringify(owner))
+                        throw new Error('Published controller migration lock does not match its owner record.');
+                    await unlinkExactPath(temporaryPath, publishedTemporaryIdentity);
+                    temporaryIdentity = undefined;
+                    await syncDirectory(this.commonParent);
+                    publishedLockIdentity = undefined;
+                    return { owner, identity: published.identity };
+                }
+                catch (errorArg) {
+                    if (errorArg.code !== 'EEXIST')
+                        throw errorArg;
+                }
+                const existing = await this.readLockSnapshot(this.lockPath);
+                if (!existing)
+                    continue;
+                if (existing.owner.uid !== currentUid()) {
+                    throw new Error('Controller data-root migration lock belongs to another user.');
+                }
+                if (await this.lockOwnerIsLive(existing.owner)) {
+                    await delay(lockWaitMilliseconds, this.options.signal);
+                    continue;
+                }
+                await this.reclaimStaleLock(existing);
+            }
+            throw new Error('Timed out waiting for the controller data-root migration lock.');
+        }
+        catch (errorArg) {
+            const cleanupErrors = [];
+            let directoryChanged = false;
+            if (temporaryHandle) {
+                try {
+                    await temporaryHandle.close();
+                    temporaryHandle = undefined;
+                }
+                catch (cleanupErrorArg) {
+                    cleanupErrors.push(cleanupErrorArg);
+                }
+            }
+            if (publishedLockIdentity) {
+                try {
+                    await unlinkExactPath(this.lockPath, publishedLockIdentity);
+                    directoryChanged = true;
+                }
+                catch (cleanupErrorArg) {
+                    cleanupErrors.push(cleanupErrorArg);
+                }
+            }
+            if (temporaryIdentity) {
+                try {
+                    await unlinkExactPath(temporaryPath, temporaryIdentity);
+                    directoryChanged = true;
+                }
+                catch (cleanupErrorArg) {
+                    cleanupErrors.push(cleanupErrorArg);
+                }
+            }
+            if (directoryChanged) {
+                try {
+                    await syncDirectory(this.commonParent);
+                }
+                catch (cleanupErrorArg) {
+                    cleanupErrors.push(cleanupErrorArg);
+                }
+            }
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([errorArg, ...cleanupErrors], 'Controller migration lock publication failed and cleanup was incomplete.', { cause: errorArg });
+            }
+            throw errorArg;
+        }
+    }
+    async readLockSnapshot(pathArg) {
+        const snapshot = await readPrivateJson(pathArg, maximumLockBytes, parseLockOwner, 'Controller data-root migration lock');
+        return snapshot ? { owner: snapshot.value, identity: snapshot.identity } : undefined;
+    }
+    async lockOwnerIsLive(ownerArg) {
+        const identity = await readControllerProcessIdentity(ownerArg.pid);
+        return identity !== null && identity.fingerprint === ownerArg.processFingerprint;
+    }
+    async reclaimStaleLock(snapshotArg) {
+        const guardPath = `${this.lockPath}.guard-${snapshotArg.owner.nonce}`;
+        let guardCreated = false;
+        let guardIdentity;
+        let operationError;
+        try {
+            try {
+                await plugins.fs.promises.link(this.lockPath, guardPath);
+                guardCreated = true;
+                guardIdentity = snapshotArg.identity;
+            }
+            catch (errorArg) {
+                if (errorArg.code === 'EEXIST')
+                    return;
+                throw errorArg;
+            }
+            await syncDirectory(this.commonParent);
+            const guard = await this.readLockSnapshot(guardPath);
+            const stable = await this.readLockSnapshot(this.lockPath);
+            if (!guard
+                || !stable
+                || !identitiesEqual(guard.identity, snapshotArg.identity)
+                || !identitiesEqual(stable.identity, snapshotArg.identity)
+                || JSON.stringify(guard.owner) !== JSON.stringify(snapshotArg.owner))
+                throw new Error('Controller migration stale-lock guard does not match the guarded owner.');
+            guardIdentity = guard.identity;
+            if (await this.lockOwnerIsLive(guard.owner)) {
+                throw new Error('Controller migration lock owner became live during stale reclaim.');
+            }
+            const stableBeforeUnlink = await this.readLockSnapshot(this.lockPath);
+            if (!stableBeforeUnlink || !identitiesEqual(stableBeforeUnlink.identity, guard.identity)) {
+                throw new Error('Controller migration lock changed during stale reclaim.');
+            }
+            await plugins.fs.promises.unlink(this.lockPath);
+            await syncDirectory(this.commonParent);
+            await unlinkExactPath(guardPath, guard.identity);
+            guardCreated = false;
+            guardIdentity = undefined;
+            await syncDirectory(this.commonParent);
+        }
+        catch (errorArg) {
+            operationError = errorArg;
+        }
+        const cleanupErrors = [];
+        if (guardCreated && guardIdentity) {
+            try {
+                await unlinkExactPath(guardPath, guardIdentity);
+                await syncDirectory(this.commonParent);
+            }
+            catch (cleanupErrorArg) {
+                cleanupErrors.push(cleanupErrorArg);
+            }
+        }
+        if (operationError) {
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([operationError, ...cleanupErrors], 'Controller stale-lock reclaim failed and guard cleanup was incomplete.', { cause: operationError });
+            }
+            throw operationError;
+        }
+        if (cleanupErrors.length > 0) {
+            throw new AggregateError(cleanupErrors, 'Controller stale-lock guard cleanup was incomplete.');
+        }
+    }
+    async releaseLock(leaseArg) {
+        const current = await this.readLockSnapshot(this.lockPath);
+        if (!current
+            || !identitiesEqual(current.identity, leaseArg.identity)
+            || current.owner.nonce !== leaseArg.owner.nonce
+            || JSON.stringify(current.owner) !== JSON.stringify(leaseArg.owner))
+            throw new Error('Controller data-root migration lock release is ambiguous.');
+        await plugins.fs.promises.unlink(this.lockPath);
+        await syncDirectory(this.commonParent);
+    }
+    async listLockArtifacts() {
+        const base = plugins.path.basename(this.lockPath);
+        const entries = await plugins.fs.promises.readdir(this.commonParent, { withFileTypes: true });
+        const related = entries.map((entry) => entry.name).filter((name) => name.startsWith(`${base}.`));
+        if (related.length > maximumLockArtifacts) {
+            throw new Error('Too many controller migration lock artifacts exist.');
+        }
+        const temporaryPattern = new RegExp(`^${base.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.tmp-[0-9]+-[1-9][0-9]*-[a-f0-9]{64}$`);
+        const guardPattern = new RegExp(`^${base.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.guard-[a-f0-9]{64}$`);
+        const temporaries = [];
+        const guards = [];
+        for (const name of related) {
+            if (temporaryPattern.test(name))
+                temporaries.push(name);
+            else if (guardPattern.test(name))
+                guards.push(name);
+            else
+                throw new Error(`Unknown controller migration lock artifact: ${name}`);
+        }
+        return { temporaries: temporaries.sort(), guards: guards.sort() };
+    }
+    async cleanupStaleLockTemporaries() {
+        const artifacts = await this.listLockArtifacts();
+        let directoryChanged = false;
+        for (const name of artifacts.temporaries) {
+            const path = plugins.path.join(this.commonParent, name);
+            const snapshot = await this.readLockSnapshot(path);
+            if (!snapshot || snapshot.owner.uid !== currentUid()) {
+                throw new Error('Controller migration lock temporary artifact is invalid.');
+            }
+            if (!await this.lockOwnerIsLive(snapshot.owner)) {
+                await unlinkExactPath(path, snapshot.identity);
+                directoryChanged = true;
+            }
+        }
+        for (const name of artifacts.guards) {
+            const path = plugins.path.join(this.commonParent, name);
+            const guard = await this.readLockSnapshot(path);
+            if (!guard)
+                throw new Error('Controller migration lock guard disappeared during inspection.');
+            if (guard.owner.uid !== currentUid()) {
+                throw new Error('Controller migration lock guard belongs to another user.');
+            }
+            if (!await this.lockOwnerIsLive(guard.owner)) {
+                await unlinkExactPath(path, guard.identity);
+                directoryChanged = true;
+            }
+        }
+        if (directoryChanged) {
+            await syncDirectory(this.commonParent);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v2_controllerdataroot.js","sourceRoot":"","sources":["../../ts_migration/v2_controllerdataroot.ts"],"names":[],"mappings":"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"}