@git.zone/tsrust 1.8.0 → 1.9.0

package/dist_ts/mod_artifact/classes.artifactassembler.js

@@ -0,0 +1,842 @@
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { captureGitSnapshot, getHostIdentity, isLocalProcessRunning, PROVENANCE_SIDECAR_SUFFIX, ProvenanceStore, } from '../mod_provenance/index.js';
+const TRANSACTION_FORMAT = 'tsrust.artifact-assembly.v1';
+const LOCK_FORMAT = 'tsrust.artifact-assembly-lock.v1';
+const RECOVERY_CLAIM_FORMAT = 'tsrust.artifact-assembly-recovery.v1';
+const TRANSACTION_DIRECTORY = 'tsrust-assembly';
+const activeOwnerTokens = new Set();
+const processOwnerTokens = new Set();
+function isSameOrWithin(parentArg, candidateArg) {
+    const relative = path.relative(parentArg, candidateArg);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+async function lstatOptional(filePathArg) {
+    try {
+        return await fs.promises.lstat(filePathArg);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+async function syncFile(filePathArg) {
+    const handle = await fs.promises.open(filePathArg, 'r');
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function syncDirectory(directoryPathArg) {
+    const handle = await fs.promises.open(directoryPathArg, 'r');
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+function assertArtifactName(nameArg, labelArg) {
+    if (!nameArg || nameArg.length > 255 || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(nameArg)) {
+        throw new Error(`Invalid ${labelArg}: ${JSON.stringify(nameArg)}`);
+    }
+}
+function isProvenanceTemporaryFile(nameArg) {
+    return /\.tsrust-build\.json\.[a-f0-9]{64}\.\d+\.[a-f0-9-]{36}\.tmp$/.test(nameArg);
+}
+function isTransactionState(valueArg) {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg))
+        return false;
+    const value = valueArg;
+    return (value.format === TRANSACTION_FORMAT &&
+        typeof value.pid === 'number' &&
+        typeof value.hostname === 'string' &&
+        typeof value.hostIdentity === 'string' &&
+        /^[a-f0-9]{64}$/.test(value.hostIdentity) &&
+        typeof value.ownerToken === 'string' &&
+        /^[a-f0-9-]{36}$/.test(value.ownerToken) &&
+        typeof value.startedAt === 'string' &&
+        [
+            'preparing',
+            'prepared',
+            'movingOld',
+            'oldMoved',
+            'publishing',
+            'published',
+            'committing',
+            'committed',
+        ].includes(String(value.phase)) &&
+        typeof value.hadExistingOutput === 'boolean');
+}
+function isLockOwner(valueArg) {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg))
+        return false;
+    const value = valueArg;
+    return (value.format === LOCK_FORMAT &&
+        typeof value.pid === 'number' &&
+        typeof value.hostname === 'string' &&
+        typeof value.hostIdentity === 'string' &&
+        /^[a-f0-9]{64}$/.test(value.hostIdentity) &&
+        typeof value.ownerToken === 'string' &&
+        /^[a-f0-9-]{36}$/.test(value.ownerToken) &&
+        typeof value.startedAt === 'string');
+}
+function isRecoveryClaim(valueArg) {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg))
+        return false;
+    const value = valueArg;
+    return (value.format === RECOVERY_CLAIM_FORMAT &&
+        typeof value.pid === 'number' &&
+        typeof value.hostname === 'string' &&
+        typeof value.hostIdentity === 'string' &&
+        /^[a-f0-9]{64}$/.test(value.hostIdentity) &&
+        typeof value.ownerToken === 'string' &&
+        /^[a-f0-9-]{36}$/.test(value.ownerToken) &&
+        typeof value.startedAt === 'string' &&
+        typeof value.targetOwnerToken === 'string' &&
+        /^[a-f0-9-]{36}$/.test(value.targetOwnerToken));
+}
+export class ArtifactAssembler {
+    options;
+    constructor(optionsArg) {
+        this.options = optionsArg;
+    }
+    async assemble() {
+        const ownerToken = crypto.randomUUID();
+        const paths = this.createPaths(ownerToken);
+        const sourceDirectories = this.options.sourceDirectories.map((sourceDirectory) => path.resolve(paths.workspace, sourceDirectory));
+        this.validateOptions(paths, sourceDirectories);
+        let state = {
+            format: TRANSACTION_FORMAT,
+            pid: process.pid,
+            hostname: os.hostname(),
+            hostIdentity: getHostIdentity(),
+            ownerToken,
+            startedAt: new Date().toISOString(),
+            phase: 'preparing',
+            hadExistingOutput: false,
+        };
+        await this.ensureTransactionParent(paths);
+        processOwnerTokens.add(ownerToken);
+        try {
+            await this.acquireTransaction(paths, state);
+        }
+        catch (error) {
+            try {
+                const lockOwner = await this.readLock(paths);
+                if (lockOwner?.ownerToken !== ownerToken)
+                    processOwnerTokens.delete(ownerToken);
+            }
+            catch {
+                // Retain the token only when lock ownership cannot be determined safely.
+            }
+            throw error;
+        }
+        let commitReached = false;
+        let retainOwnerToken = false;
+        activeOwnerTokens.add(ownerToken);
+        try {
+            const output = await lstatOptional(paths.outputDirectory);
+            if (output && (!output.isDirectory() || output.isSymbolicLink())) {
+                throw new Error(`Assembly output is not a regular directory: ${paths.outputDirectory}`);
+            }
+            state.hadExistingOutput = !!output;
+            await this.writeState(paths, state);
+            const candidates = await this.collectCandidates(sourceDirectories);
+            await fs.promises.mkdir(paths.stagingDirectory, { mode: 0o700 });
+            for (const candidate of candidates) {
+                const destinationBinary = path.join(paths.stagingDirectory, candidate.destinationName);
+                const destinationSidecar = ProvenanceStore.sidecarPath(destinationBinary);
+                await fs.promises.copyFile(candidate.binaryPath, destinationBinary, fs.constants.COPYFILE_EXCL);
+                await fs.promises.copyFile(candidate.sidecarPath, destinationSidecar, fs.constants.COPYFILE_EXCL);
+                await syncFile(destinationBinary);
+                await syncFile(destinationSidecar);
+                const copiedBuildInfo = await ProvenanceStore.readSidecar(destinationBinary);
+                if (JSON.stringify(copiedBuildInfo) !== JSON.stringify(candidate.buildInfo)) {
+                    throw new Error(`Artifact provenance changed while copying ${candidate.binaryPath}`);
+                }
+            }
+            await fs.promises.chmod(paths.stagingDirectory, 0o755);
+            await syncDirectory(paths.stagingDirectory);
+            state = { ...state, phase: 'prepared' };
+            await this.writeState(paths, state);
+            await this.assertAssemblySourceUnchanged(paths.workspace);
+            if (state.hadExistingOutput) {
+                state = { ...state, phase: 'movingOld' };
+                await this.writeState(paths, state);
+                await fs.promises.rename(paths.outputDirectory, paths.backupDirectory);
+                await syncDirectory(paths.workspace);
+                state = { ...state, phase: 'oldMoved' };
+                await this.writeState(paths, state);
+            }
+            state = { ...state, phase: 'publishing' };
+            await this.writeState(paths, state);
+            state = { ...state, phase: 'committing' };
+            try {
+                await this.writeState(paths, state);
+                commitReached = true;
+            }
+            catch (error) {
+                let persistedState;
+                try {
+                    persistedState = await this.readState(paths);
+                }
+                catch (stateError) {
+                    commitReached = true;
+                    throw new AggregateError([error, stateError], `Artifact commit state is unreadable in ${paths.transactionDirectory}`);
+                }
+                if (persistedState?.ownerToken === ownerToken &&
+                    persistedState.phase === 'publishing') {
+                    state = persistedState;
+                }
+                else {
+                    // Recovery follows whichever commit phase reached state.json; do not
+                    // make a second, potentially contradictory decision here.
+                    commitReached = true;
+                }
+                throw new Error(commitReached
+                    ? `Artifact commit intent is pending in ${paths.transactionDirectory}`
+                    : 'Failed to persist artifact commit intent', { cause: error });
+            }
+            const cleanupPending = await this.completeCommittedTransaction(paths, state);
+            retainOwnerToken = cleanupPending;
+            return {
+                outputDirectory: paths.outputDirectory,
+                artifactCount: candidates.length,
+                binaries: [...this.options.expectedBinaries].sort(),
+                targets: this.options.expectedTargets.map((target) => target.friendly).sort(),
+                cleanupPending,
+            };
+        }
+        catch (error) {
+            if (!commitReached) {
+                try {
+                    await this.rollbackTransaction(paths, state);
+                }
+                catch (rollbackError) {
+                    retainOwnerToken = true;
+                    throw new AggregateError([error, rollbackError], `Artifact assembly failed and rollback is pending in ${paths.transactionDirectory}`);
+                }
+            }
+            else {
+                retainOwnerToken = true;
+            }
+            throw error;
+        }
+        finally {
+            activeOwnerTokens.delete(ownerToken);
+            if (!retainOwnerToken) {
+                processOwnerTokens.delete(ownerToken);
+            }
+            else {
+                try {
+                    if (!(await lstatOptional(paths.lockPath))) {
+                        processOwnerTokens.delete(ownerToken);
+                    }
+                }
+                catch {
+                    // Keep the token so a same-process retry can recover the transaction.
+                }
+            }
+        }
+    }
+    createPaths(ownerTokenArg) {
+        const workspace = path.resolve(this.options.workspace);
+        const transactionParent = path.join(workspace, '.nogit');
+        const transactionDirectory = path.join(transactionParent, TRANSACTION_DIRECTORY);
+        return {
+            workspace,
+            outputDirectory: path.join(workspace, 'dist_rust'),
+            transactionParent,
+            transactionDirectory,
+            lockPath: path.join(transactionParent, 'tsrust-assembly.lock'),
+            lockSourcePath: path.join(transactionParent, `.tsrust-assembly-owner.${ownerTokenArg}.tmp`),
+            recoveryClaimPath: path.join(transactionParent, 'tsrust-assembly.recovery.lock'),
+            statePath: path.join(transactionDirectory, 'state.json'),
+            stateTemporaryPath: path.join(transactionDirectory, 'state.json.tmp'),
+            stagingDirectory: path.join(transactionDirectory, 'staging'),
+            backupDirectory: path.join(transactionDirectory, 'backup'),
+            failedDirectory: path.join(transactionDirectory, 'failed'),
+        };
+    }
+    validateOptions(pathsArg, sourceDirectoriesArg) {
+        if (sourceDirectoriesArg.length === 0) {
+            throw new Error('Artifact assembly requires at least one source directory');
+        }
+        if (new Set(sourceDirectoriesArg).size !== sourceDirectoriesArg.length) {
+            throw new Error('Artifact assembly source directories must be unique');
+        }
+        if (this.options.expectedTargets.length === 0) {
+            throw new Error('Artifact assembly requires at least one expected target');
+        }
+        if (this.options.expectedBinaries.length === 0) {
+            throw new Error('Artifact assembly requires at least one expected binary');
+        }
+        for (const binary of this.options.expectedBinaries) {
+            assertArtifactName(binary, 'binary name');
+        }
+        if (new Set(this.options.expectedBinaries).size !== this.options.expectedBinaries.length) {
+            throw new Error('Expected artifact binary names must be unique');
+        }
+        const targetNames = this.options.expectedTargets.map((target) => target.friendly);
+        const targetTriples = this.options.expectedTargets.map((target) => target.triple);
+        if (new Set(targetNames).size !== targetNames.length ||
+            new Set(targetTriples).size !== targetTriples.length) {
+            throw new Error('Expected artifact targets must be unique');
+        }
+        if (!/^[a-f0-9]{40}([a-f0-9]{24})?$/.test(this.options.expectedGitCommit)) {
+            throw new Error('Artifact assembly requires an exact Git commit');
+        }
+        for (const target of this.options.expectedTargets) {
+            assertArtifactName(target.friendly, 'target name');
+            assertArtifactName(target.triple, 'target triple');
+        }
+        for (const sourceDirectory of sourceDirectoriesArg) {
+            if (isSameOrWithin(sourceDirectory, pathsArg.outputDirectory) ||
+                isSameOrWithin(pathsArg.outputDirectory, sourceDirectory) ||
+                isSameOrWithin(sourceDirectory, pathsArg.transactionDirectory) ||
+                isSameOrWithin(pathsArg.transactionDirectory, sourceDirectory)) {
+                throw new Error(`Artifact source overlaps tsrust-owned output: ${sourceDirectory}`);
+            }
+        }
+    }
+    async ensureTransactionParent(pathsArg) {
+        const existing = await lstatOptional(pathsArg.transactionParent);
+        if (existing) {
+            if (!existing.isDirectory() || existing.isSymbolicLink()) {
+                throw new Error(`tsrust state path is not a regular directory: ${pathsArg.transactionParent}`);
+            }
+        }
+        else {
+            await fs.promises.mkdir(pathsArg.transactionParent, { mode: 0o700 });
+        }
+        const workspace = await fs.promises.stat(pathsArg.workspace);
+        const transactionParent = await fs.promises.stat(pathsArg.transactionParent);
+        if (workspace.dev !== transactionParent.dev) {
+            throw new Error('tsrust assembly state and dist_rust must be on the same filesystem');
+        }
+    }
+    async acquireTransaction(pathsArg, stateArg) {
+        await this.cleanupAbandonedLockSources(pathsArg);
+        if ((await lstatOptional(pathsArg.transactionDirectory)) &&
+            !(await lstatOptional(pathsArg.lockPath))) {
+            throw new Error(`Assembly data exists without its owner lock: ${pathsArg.transactionDirectory}`);
+        }
+        const owner = this.lockOwnerFromState(stateArg);
+        await this.writeLockSource(pathsArg, owner);
+        let ownsLock = false;
+        let transactionCreated = false;
+        try {
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                await this.clearAbandonedRecoveryClaim(pathsArg);
+                try {
+                    await fs.promises.link(pathsArg.lockSourcePath, pathsArg.lockPath);
+                    ownsLock = true;
+                    await syncDirectory(pathsArg.transactionParent);
+                    break;
+                }
+                catch (error) {
+                    if (error.code !== 'EEXIST')
+                        throw error;
+                    if (attempt > 0) {
+                        throw new Error(`Unable to clear stale assembly lock: ${pathsArg.lockPath}`);
+                    }
+                    await this.recoverExistingTransaction(pathsArg);
+                }
+            }
+            await fs.promises.unlink(pathsArg.lockSourcePath);
+            await fs.promises.mkdir(pathsArg.transactionDirectory, { mode: 0o700 });
+            transactionCreated = true;
+            await syncDirectory(pathsArg.transactionParent);
+            await this.writeState(pathsArg, stateArg);
+        }
+        catch (error) {
+            if (transactionCreated) {
+                await fs.promises.rm(pathsArg.transactionDirectory, { recursive: true, force: true });
+            }
+            if (ownsLock) {
+                await this.releaseLock(pathsArg, owner.ownerToken);
+            }
+            throw error;
+        }
+        finally {
+            await Promise.allSettled([fs.promises.rm(pathsArg.lockSourcePath, { force: true })]);
+        }
+    }
+    lockOwnerFromState(stateArg) {
+        return {
+            format: LOCK_FORMAT,
+            pid: stateArg.pid,
+            hostname: stateArg.hostname,
+            hostIdentity: stateArg.hostIdentity,
+            ownerToken: stateArg.ownerToken,
+            startedAt: stateArg.startedAt,
+        };
+    }
+    async writeLockSource(pathsArg, ownerArg) {
+        const lockSource = await fs.promises.open(pathsArg.lockSourcePath, 'wx', 0o600);
+        try {
+            await lockSource.writeFile(`${JSON.stringify(ownerArg, null, 2)}\n`, 'utf8');
+            await lockSource.sync();
+        }
+        finally {
+            await lockSource.close();
+        }
+    }
+    async cleanupAbandonedLockSources(pathsArg) {
+        const entries = await fs.promises.readdir(pathsArg.transactionParent, {
+            withFileTypes: true,
+        });
+        for (const entry of entries) {
+            if (!entry.isFile() ||
+                (!entry.name.startsWith('.tsrust-assembly-owner.') &&
+                    !entry.name.startsWith('.tsrust-assembly-recovery.')) ||
+                !entry.name.endsWith('.tmp')) {
+                continue;
+            }
+            const filePath = path.join(pathsArg.transactionParent, entry.name);
+            let owner;
+            try {
+                const parsed = JSON.parse(await fs.promises.readFile(filePath, 'utf8'));
+                if (isLockOwner(parsed) || isRecoveryClaim(parsed)) {
+                    owner = parsed;
+                }
+                else {
+                    continue;
+                }
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                continue;
+            }
+            if (activeOwnerTokens.has(owner.ownerToken) ||
+                processOwnerTokens.has(owner.ownerToken) ||
+                owner.hostIdentity !== getHostIdentity() ||
+                isLocalProcessRunning(owner.pid)) {
+                continue;
+            }
+            await fs.promises.rm(filePath, { force: true });
+        }
+    }
+    async readLock(pathsArg) {
+        const lock = await lstatOptional(pathsArg.lockPath);
+        if (!lock)
+            return undefined;
+        if (!lock.isFile() || lock.isSymbolicLink()) {
+            throw new Error(`Assembly lock is not a regular file: ${pathsArg.lockPath}`);
+        }
+        try {
+            const parsed = JSON.parse(await fs.promises.readFile(pathsArg.lockPath, 'utf8'));
+            if (!isLockOwner(parsed)) {
+                throw new Error(`Assembly lock has an invalid shape: ${pathsArg.lockPath}`);
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`Assembly lock is invalid JSON: ${pathsArg.lockPath}`);
+            }
+            throw error;
+        }
+    }
+    async readRecoveryClaim(pathsArg) {
+        const claim = await lstatOptional(pathsArg.recoveryClaimPath);
+        if (!claim)
+            return undefined;
+        if (!claim.isFile() || claim.isSymbolicLink()) {
+            throw new Error(`Assembly recovery claim is not a regular file: ${pathsArg.recoveryClaimPath}`);
+        }
+        try {
+            const parsed = JSON.parse(await fs.promises.readFile(pathsArg.recoveryClaimPath, 'utf8'));
+            if (!isRecoveryClaim(parsed)) {
+                throw new Error(`Assembly recovery claim has an invalid shape: ${pathsArg.recoveryClaimPath}`);
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`Assembly recovery claim is invalid JSON: ${pathsArg.recoveryClaimPath}`);
+            }
+            throw error;
+        }
+    }
+    async clearAbandonedRecoveryClaim(pathsArg) {
+        const claim = await this.readRecoveryClaim(pathsArg);
+        if (!claim)
+            return;
+        const targetOwner = await this.readLock(pathsArg);
+        if (targetOwner?.ownerToken === claim.targetOwnerToken) {
+            this.assertOwnerCanRecover(claim);
+        }
+        await this.releaseRecoveryClaim(pathsArg, claim.ownerToken);
+        processOwnerTokens.delete(claim.ownerToken);
+    }
+    async acquireRecoveryClaim(pathsArg, targetOwnerArg) {
+        const claim = {
+            format: RECOVERY_CLAIM_FORMAT,
+            pid: process.pid,
+            hostname: os.hostname(),
+            hostIdentity: getHostIdentity(),
+            ownerToken: crypto.randomUUID(),
+            startedAt: new Date().toISOString(),
+            targetOwnerToken: targetOwnerArg.ownerToken,
+        };
+        const sourcePath = path.join(pathsArg.transactionParent, `.tsrust-assembly-recovery.${claim.ownerToken}.tmp`);
+        let source;
+        let claimAcquired = false;
+        try {
+            source = await fs.promises.open(sourcePath, 'wx', 0o600);
+            await source.writeFile(`${JSON.stringify(claim, null, 2)}\n`, 'utf8');
+            await source.sync();
+            await source.close();
+            source = undefined;
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                try {
+                    await fs.promises.link(sourcePath, pathsArg.recoveryClaimPath);
+                    claimAcquired = true;
+                    processOwnerTokens.add(claim.ownerToken);
+                    activeOwnerTokens.add(claim.ownerToken);
+                    await syncDirectory(pathsArg.transactionParent);
+                    break;
+                }
+                catch (error) {
+                    if (error.code !== 'EEXIST')
+                        throw error;
+                    if (attempt > 0) {
+                        throw new Error(`Unable to acquire assembly recovery claim: ${pathsArg.recoveryClaimPath}`);
+                    }
+                    await this.clearAbandonedRecoveryClaim(pathsArg);
+                }
+            }
+            const currentOwner = await this.readLock(pathsArg);
+            if (currentOwner?.ownerToken !== targetOwnerArg.ownerToken) {
+                await this.releaseRecoveryClaim(pathsArg, claim.ownerToken);
+                claimAcquired = false;
+                activeOwnerTokens.delete(claim.ownerToken);
+                processOwnerTokens.delete(claim.ownerToken);
+                throw new Error('Assembly owner changed while recovery was being claimed');
+            }
+            return claim;
+        }
+        catch (error) {
+            if (claimAcquired) {
+                try {
+                    await this.releaseRecoveryClaim(pathsArg, claim.ownerToken);
+                }
+                finally {
+                    activeOwnerTokens.delete(claim.ownerToken);
+                    if (!(await lstatOptional(pathsArg.recoveryClaimPath))) {
+                        processOwnerTokens.delete(claim.ownerToken);
+                    }
+                }
+            }
+            throw error;
+        }
+        finally {
+            await Promise.allSettled([
+                source?.close() || Promise.resolve(),
+                fs.promises.rm(sourcePath, { force: true }),
+            ]);
+        }
+    }
+    async releaseRecoveryClaim(pathsArg, ownerTokenArg) {
+        const claim = await this.readRecoveryClaim(pathsArg);
+        if (!claim)
+            return;
+        if (claim.ownerToken !== ownerTokenArg) {
+            throw new Error('Assembly recovery claim ownership changed before release');
+        }
+        await fs.promises.unlink(pathsArg.recoveryClaimPath);
+        await syncDirectory(pathsArg.transactionParent);
+    }
+    assertOwnerCanRecover(ownerArg) {
+        if (activeOwnerTokens.has(ownerArg.ownerToken)) {
+            throw new Error(`Artifact assembly is already active on ${ownerArg.hostname} with pid ${ownerArg.pid}`);
+        }
+        if (processOwnerTokens.has(ownerArg.ownerToken))
+            return;
+        if (ownerArg.hostIdentity !== getHostIdentity()) {
+            throw new Error(`Assembly transaction belongs to another host (${ownerArg.hostname}); refusing automatic recovery`);
+        }
+        if (isLocalProcessRunning(ownerArg.pid)) {
+            throw new Error(`Artifact assembly owner is still running on ${ownerArg.hostname} with pid ${ownerArg.pid}`);
+        }
+    }
+    async recoverExistingTransaction(pathsArg) {
+        const owner = await this.readLock(pathsArg);
+        if (!owner)
+            return;
+        this.assertOwnerCanRecover(owner);
+        const claim = await this.acquireRecoveryClaim(pathsArg, owner);
+        try {
+            const currentOwner = await this.readLock(pathsArg);
+            if (currentOwner?.ownerToken !== owner.ownerToken) {
+                throw new Error('Assembly owner changed after recovery was claimed');
+            }
+            const transaction = await lstatOptional(pathsArg.transactionDirectory);
+            if (!transaction) {
+                await this.releaseLock(pathsArg, owner.ownerToken);
+                processOwnerTokens.delete(owner.ownerToken);
+                return;
+            }
+            if (!transaction.isDirectory() || transaction.isSymbolicLink()) {
+                throw new Error(`Assembly transaction path is not a regular directory: ${pathsArg.transactionDirectory}`);
+            }
+            const state = await this.readState(pathsArg);
+            if (!state) {
+                await fs.promises.rm(pathsArg.transactionDirectory, { recursive: true });
+                await this.releaseLock(pathsArg, owner.ownerToken);
+                processOwnerTokens.delete(owner.ownerToken);
+                return;
+            }
+            if (state.ownerToken !== owner.ownerToken ||
+                state.hostIdentity !== owner.hostIdentity ||
+                state.pid !== owner.pid) {
+                throw new Error('Assembly lock and transaction state have different owners');
+            }
+            if (state.phase === 'committing' ||
+                state.phase === 'published' ||
+                state.phase === 'committed') {
+                const cleanupPending = await this.completeCommittedTransaction(pathsArg, state);
+                if (cleanupPending) {
+                    throw new Error(`Unable to clean committed assembly state: ${pathsArg.transactionDirectory}`);
+                }
+                processOwnerTokens.delete(state.ownerToken);
+                return;
+            }
+            await this.rollbackTransaction(pathsArg, state);
+            processOwnerTokens.delete(state.ownerToken);
+        }
+        finally {
+            activeOwnerTokens.delete(claim.ownerToken);
+            try {
+                await this.releaseRecoveryClaim(pathsArg, claim.ownerToken);
+            }
+            finally {
+                if (!(await lstatOptional(pathsArg.recoveryClaimPath))) {
+                    processOwnerTokens.delete(claim.ownerToken);
+                }
+            }
+        }
+    }
+    async releaseLock(pathsArg, ownerTokenArg) {
+        const owner = await this.readLock(pathsArg);
+        if (!owner)
+            return;
+        if (owner.ownerToken !== ownerTokenArg) {
+            throw new Error('Assembly lock ownership changed before release');
+        }
+        await fs.promises.unlink(pathsArg.lockPath);
+        await syncDirectory(pathsArg.transactionParent);
+    }
+    async readState(pathsArg) {
+        const state = await lstatOptional(pathsArg.statePath);
+        if (!state)
+            return undefined;
+        if (!state.isFile() || state.isSymbolicLink()) {
+            throw new Error(`Assembly state is not a regular file: ${pathsArg.statePath}`);
+        }
+        try {
+            const parsed = JSON.parse(await fs.promises.readFile(pathsArg.statePath, 'utf8'));
+            if (!isTransactionState(parsed)) {
+                throw new Error(`Assembly state has an invalid shape: ${pathsArg.statePath}`);
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error(`Assembly state is invalid JSON: ${pathsArg.statePath}`);
+            }
+            throw error;
+        }
+    }
+    async writeState(pathsArg, stateArg) {
+        const temporary = await fs.promises.open(pathsArg.stateTemporaryPath, 'w', 0o600);
+        try {
+            await temporary.writeFile(`${JSON.stringify(stateArg, null, 2)}\n`, 'utf8');
+            await temporary.sync();
+        }
+        finally {
+            await temporary.close();
+        }
+        await fs.promises.rename(pathsArg.stateTemporaryPath, pathsArg.statePath);
+        await syncDirectory(pathsArg.transactionDirectory);
+    }
+    async assertAssemblySourceUnchanged(workspaceArg) {
+        const snapshot = await captureGitSnapshot(workspaceArg);
+        if (!snapshot.available ||
+            snapshot.commit !== this.options.expectedGitCommit ||
+            snapshot.status.length > 0) {
+            throw new Error('Git source state changed before artifact publication');
+        }
+        let projectName = 'unknown';
+        let projectVersion = 'unknown';
+        try {
+            const packageJson = JSON.parse(await fs.promises.readFile(path.join(workspaceArg, 'package.json'), 'utf8'));
+            projectName = packageJson.name || projectName;
+            projectVersion = packageJson.version || projectVersion;
+        }
+        catch {
+            // package.json is optional for pure Rust workspaces.
+        }
+        if (projectName !== this.options.expectedProjectName ||
+            projectVersion !== this.options.expectedProjectVersion) {
+            throw new Error('Project package identity changed before artifact publication');
+        }
+    }
+    async rollbackTransaction(pathsArg, stateArg) {
+        const backup = await lstatOptional(pathsArg.backupDirectory);
+        if (backup) {
+            if (!backup.isDirectory() || backup.isSymbolicLink()) {
+                throw new Error(`Assembly backup is not a regular directory: ${pathsArg.backupDirectory}`);
+            }
+            const output = await lstatOptional(pathsArg.outputDirectory);
+            if (output) {
+                await fs.promises.rm(pathsArg.failedDirectory, { recursive: true, force: true });
+                await fs.promises.rename(pathsArg.outputDirectory, pathsArg.failedDirectory);
+            }
+            await fs.promises.rename(pathsArg.backupDirectory, pathsArg.outputDirectory);
+            await syncDirectory(pathsArg.workspace);
+            await fs.promises.rm(pathsArg.failedDirectory, { recursive: true, force: true });
+        }
+        else if (!stateArg.hadExistingOutput &&
+            (stateArg.phase === 'publishing' ||
+                stateArg.phase === 'published' ||
+                stateArg.phase === 'committing')) {
+            await fs.promises.rm(pathsArg.outputDirectory, { recursive: true, force: true });
+            await syncDirectory(pathsArg.workspace);
+        }
+        await fs.promises.rm(pathsArg.stagingDirectory, { recursive: true, force: true });
+        await fs.promises.rm(pathsArg.stateTemporaryPath, { force: true });
+        await fs.promises.rm(pathsArg.transactionDirectory, { recursive: true });
+        await this.releaseLock(pathsArg, stateArg.ownerToken);
+    }
+    async completeCommittedTransaction(pathsArg, stateArg) {
+        const output = await lstatOptional(pathsArg.outputDirectory);
+        const staging = await lstatOptional(pathsArg.stagingDirectory);
+        if (!output) {
+            if (!staging || !staging.isDirectory() || staging.isSymbolicLink()) {
+                throw new Error(`Committed artifact publication is incomplete: ${pathsArg.transactionDirectory}`);
+            }
+            await fs.promises.rename(pathsArg.stagingDirectory, pathsArg.outputDirectory);
+            await syncDirectory(pathsArg.workspace);
+        }
+        else {
+            if (!output.isDirectory() || output.isSymbolicLink()) {
+                throw new Error(`Committed assembly output is not a regular directory: ${pathsArg.outputDirectory}`);
+            }
+            if (staging) {
+                throw new Error(`Committed assembly has both staging and output directories: ${pathsArg.transactionDirectory}`);
+            }
+        }
+        return this.cleanupCommittedTransaction(pathsArg, { ...stateArg, phase: 'published' });
+    }
+    async cleanupCommittedTransaction(pathsArg, stateArg) {
+        try {
+            const output = await fs.promises.lstat(pathsArg.outputDirectory);
+            if (!output.isDirectory() || output.isSymbolicLink()) {
+                throw new Error(`Committed assembly output is not a regular directory: ${pathsArg.outputDirectory}`);
+            }
+            await fs.promises.rm(pathsArg.backupDirectory, { recursive: true, force: true });
+            await fs.promises.rm(pathsArg.stagingDirectory, { recursive: true, force: true });
+            await fs.promises.rm(pathsArg.failedDirectory, { recursive: true, force: true });
+            await this.writeState(pathsArg, { ...stateArg, phase: 'committed' });
+            await fs.promises.rm(pathsArg.transactionDirectory, { recursive: true });
+            await this.releaseLock(pathsArg, stateArg.ownerToken);
+            return false;
+        }
+        catch {
+            return true;
+        }
+    }
+    async collectCandidates(sourceDirectoriesArg) {
+        const expectedTargets = new Map(this.options.expectedTargets.map((target) => [target.friendly, target]));
+        const expectedBinaries = new Set(this.options.expectedBinaries);
+        const candidates = new Map();
+        for (const sourceDirectory of sourceDirectoriesArg) {
+            const source = await fs.promises.lstat(sourceDirectory);
+            if (!source.isDirectory() || source.isSymbolicLink()) {
+                throw new Error(`Artifact source is not a regular directory: ${sourceDirectory}`);
+            }
+            const entries = await fs.promises.readdir(sourceDirectory, { withFileTypes: true });
+            const entryNames = new Set(entries.map((entry) => entry.name));
+            const usedSidecars = new Set();
+            for (const entry of entries) {
+                const entryPath = path.join(sourceDirectory, entry.name);
+                if (entry.isSymbolicLink() || !entry.isFile()) {
+                    throw new Error(`Artifact source contains a non-regular entry: ${entryPath}`);
+                }
+                if (isProvenanceTemporaryFile(entry.name))
+                    continue;
+                if (entry.name.endsWith(PROVENANCE_SIDECAR_SUFFIX))
+                    continue;
+                const sidecarName = `${entry.name}${PROVENANCE_SIDECAR_SUFFIX}`;
+                if (!entryNames.has(sidecarName)) {
+                    throw new Error(`Artifact is missing its provenance sidecar: ${entryPath}`);
+                }
+                const binary = await fs.promises.lstat(entryPath);
+                if ((binary.mode & 0o111) === 0) {
+                    throw new Error(`Artifact is not executable: ${entryPath}`);
+                }
+                const buildInfo = await ProvenanceStore.readSidecar(entryPath);
+                assertArtifactName(buildInfo.binary, 'provenance binary name');
+                assertArtifactName(buildInfo.target, 'provenance target name');
+                if (buildInfo.gitDirty !== false) {
+                    throw new Error(`Artifact was not built from a clean Git worktree: ${entryPath}`);
+                }
+                if (buildInfo.projectName !== this.options.expectedProjectName ||
+                    buildInfo.projectVersion !== this.options.expectedProjectVersion ||
+                    buildInfo.gitCommit !== this.options.expectedGitCommit) {
+                    throw new Error(`Artifact provenance does not match the assembly source: ${entryPath}`);
+                }
+                if (buildInfo.tsrustVersion !== this.options.expectedTsrustVersion) {
+                    throw new Error(`Artifact was built with a different tsrust version: ${entryPath}`);
+                }
+                const target = expectedTargets.get(buildInfo.target);
+                if (!target) {
+                    throw new Error(`Artifact has an unexpected target ${buildInfo.target}: ${entryPath}`);
+                }
+                if (!expectedBinaries.has(buildInfo.binary)) {
+                    throw new Error(`Artifact has an unexpected binary ${buildInfo.binary}: ${entryPath}`);
+                }
+                const destinationName = `${buildInfo.binary}_${target.friendly}`;
+                if (entry.name !== destinationName) {
+                    throw new Error(`Artifact filename ${entry.name} does not match provenance name ${destinationName}`);
+                }
+                const key = `${buildInfo.binary}\u0000${target.friendly}`;
+                if (candidates.has(key)) {
+                    throw new Error(`Artifact inputs contain a duplicate ${destinationName}`);
+                }
+                const sidecarPath = path.join(sourceDirectory, sidecarName);
+                candidates.set(key, {
+                    binaryPath: entryPath,
+                    sidecarPath,
+                    destinationName,
+                    buildInfo,
+                });
+                usedSidecars.add(sidecarName);
+            }
+            for (const entry of entries) {
+                if (entry.name.endsWith(PROVENANCE_SIDECAR_SUFFIX) && !usedSidecars.has(entry.name)) {
+                    throw new Error(`Artifact source contains an orphan provenance sidecar: ${entry.name}`);
+                }
+            }
+        }
+        for (const binary of expectedBinaries) {
+            for (const target of expectedTargets.keys()) {
+                const key = `${binary}\u0000${target}`;
+                if (!candidates.has(key)) {
+                    throw new Error(`Artifact assembly is missing ${binary}_${target}`);
+                }
+            }
+        }
+        return [...candidates.values()].sort((a, b) => a.destinationName.localeCompare(b.destinationName));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.artifactassembler.js","sourceRoot":"","sources":["../../ts/mod_artifact/classes.artifactassembler.ts"],"names":[],"mappings":"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"}