@git.zone/tsbundle 2.11.4 → 2.13.0

package/dist_ts/mod_output/artifactpublisher.js

@@ -0,0 +1,925 @@
+import * as plugins from './plugins.js';
+const artifactOwner = '@git.zone/tsbundle';
+const chunkManifestKind = 'chunk-namespace';
+const chunkManifestSchemaVersion = 1;
+const buildStageKind = 'build-stage';
+const buildStageSchemaVersion = 1;
+const lockKind = 'artifact-publication-lock';
+const lockSchemaVersion = 1;
+const lockWaitTimeoutMs = 60_000;
+const lockLeaseTimeoutMs = 60 * 60 * 1000;
+const ownershipHeartbeatIntervalMs = 30_000;
+const staleStageThresholdMs = 24 * 60 * 60 * 1000;
+const buildStageHeartbeats = new Map();
+export const chunkManifestFile = '.tsbundle-artifacts.json';
+const hasErrorCode = (errorArg) => (typeof errorArg === 'object' && errorArg !== null && 'code' in errorArg);
+const createToken = () => plugins.crypto.randomBytes(16).toString('hex');
+const isProcessAlive = (processIdArg) => {
+    try {
+        process.kill(processIdArg, 0);
+        return true;
+    }
+    catch (error) {
+        return hasErrorCode(error) && error.code === 'EPERM';
+    }
+};
+export const getProcessIdentity = (processIdArg) => {
+    if (process.platform !== 'linux') {
+        return undefined;
+    }
+    try {
+        const processStat = plugins.fsSync.readFileSync(`/proc/${processIdArg}/stat`, 'utf8');
+        const commandEnd = processStat.lastIndexOf(')');
+        if (commandEnd === -1) {
+            return undefined;
+        }
+        const fieldsAfterCommand = processStat.slice(commandEnd + 2).trim().split(/\s+/);
+        const processStartTicks = fieldsAfterCommand[19];
+        return processStartTicks ? `linux-proc-start:${processStartTicks}` : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const encodeProcessIdentity = (processIdentityArg) => (plugins.crypto.createHash('sha256').update(processIdentityArg).digest('base64url').slice(0, 16));
+const getProcessIdentityToken = (processIdArg) => {
+    const processIdentity = getProcessIdentity(processIdArg);
+    return processIdentity
+        ? encodeProcessIdentity(processIdentity)
+        : 'lease';
+};
+export const createProcessOwnership = () => ({
+    leaseManaged: true,
+    processId: process.pid,
+    processIdentity: getProcessIdentity(process.pid) || '',
+});
+export const isProcessOwnershipActive = (ownershipArg, markerPathArg, leaseTimeoutMsArg) => {
+    if (!isProcessAlive(ownershipArg.processId)) {
+        return false;
+    }
+    if (ownershipArg.processIdentity) {
+        const currentIdentity = getProcessIdentity(ownershipArg.processId);
+        return currentIdentity === undefined || currentIdentity === ownershipArg.processIdentity;
+    }
+    if (!ownershipArg.leaseManaged) {
+        return true;
+    }
+    try {
+        return Date.now() - plugins.fsSync.statSync(markerPathArg).mtimeMs < leaseTimeoutMsArg;
+    }
+    catch {
+        return false;
+    }
+};
+export const startOwnershipHeartbeat = (markerPathArg) => {
+    const heartbeat = setInterval(() => {
+        try {
+            const now = new Date();
+            plugins.fsSync.utimesSync(markerPathArg, now, now);
+        }
+        catch (error) {
+            if (!hasErrorCode(error) || error.code !== 'ENOENT') {
+                console.warn(`tsbundle: unable to update ownership lease ${markerPathArg}: ${String(error)}`);
+            }
+        }
+    }, ownershipHeartbeatIntervalMs);
+    heartbeat.unref();
+    return () => clearInterval(heartbeat);
+};
+const assertPathNotSymbolicLink = (pathArg, descriptionArg) => {
+    if (!plugins.fsSync.existsSync(pathArg)) {
+        return;
+    }
+    const stat = plugins.fsSync.lstatSync(pathArg);
+    if (stat.isSymbolicLink()) {
+        throw new Error(`Refusing to use symbolic-link ${descriptionArg}: ${pathArg}`);
+    }
+};
+const assertRegularFile = (pathArg, descriptionArg) => {
+    const stat = plugins.fsSync.lstatSync(pathArg);
+    if (stat.isSymbolicLink() || !stat.isFile()) {
+        throw new Error(`Expected a regular ${descriptionArg}: ${pathArg}`);
+    }
+};
+const sameFile = (firstPathArg, secondPathArg) => {
+    const firstStat = plugins.fsSync.statSync(firstPathArg);
+    const secondStat = plugins.fsSync.statSync(secondPathArg);
+    return firstStat.dev === secondStat.dev && firstStat.ino === secondStat.ino;
+};
+const getLockPath = (targetPathArg) => `${targetPathArg}.tsbundle-lock`;
+const getLockOwnerPath = (lockPathArg, ownerTokenArg) => (`${lockPathArg}.owner-${ownerTokenArg}`);
+const parseLockMarker = (rawMarkerArg, targetPathArg) => {
+    const marker = JSON.parse(rawMarkerArg);
+    if (marker.owner !== artifactOwner
+        || marker.kind !== lockKind
+        || typeof marker.processId !== 'number'
+        || !Number.isSafeInteger(marker.processId)
+        || marker.processId <= 0
+        || (marker.processIdentity !== undefined && typeof marker.processIdentity !== 'string')
+        || (marker.leaseManaged !== undefined && typeof marker.leaseManaged !== 'boolean')
+        || typeof marker.createdAt !== 'string'
+        || typeof marker.ownerToken !== 'string'
+        || !/^[a-f0-9]{32}$/.test(marker.ownerToken)
+        || typeof marker.targetPath !== 'string'
+        || plugins.path.resolve(marker.targetPath) !== plugins.path.resolve(targetPathArg)
+        || marker.schemaVersion !== lockSchemaVersion) {
+        throw new Error(`Refusing to use invalid artifact publication lock for ${targetPathArg}`);
+    }
+    return marker;
+};
+const readLockMarker = (lockPathArg, targetPathArg) => {
+    try {
+        const stat = plugins.fsSync.lstatSync(lockPathArg);
+        if (stat.isSymbolicLink() || !stat.isFile()) {
+            throw new Error(`Refusing to use unsafe artifact publication lock: ${lockPathArg}`);
+        }
+        return parseLockMarker(plugins.fsSync.readFileSync(lockPathArg, 'utf8'), targetPathArg);
+    }
+    catch (error) {
+        if (hasErrorCode(error) && error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+};
+const createLockOwner = (targetPathArg) => {
+    const lockPath = getLockPath(targetPathArg);
+    const marker = {
+        owner: artifactOwner,
+        kind: lockKind,
+        ...createProcessOwnership(),
+        createdAt: new Date().toISOString(),
+        ownerToken: createToken(),
+        targetPath: plugins.path.resolve(targetPathArg),
+        schemaVersion: lockSchemaVersion,
+    };
+    const ownerPath = getLockOwnerPath(lockPath, marker.ownerToken);
+    try {
+        plugins.fsSync.writeFileSync(ownerPath, `${JSON.stringify(marker, null, 2)}\n`, {
+            flag: 'wx',
+            mode: 0o600,
+        });
+        return { lockPath, marker, ownerPath };
+    }
+    catch (error) {
+        plugins.fsSync.rmSync(ownerPath, { force: true });
+        throw error;
+    }
+};
+const cleanupOrphanLockOwners = (targetPathArg) => {
+    const lockPath = getLockPath(targetPathArg);
+    const directory = plugins.path.dirname(lockPath);
+    const lockBasename = plugins.path.basename(lockPath);
+    const escapedLockBasename = lockBasename.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const ownerPattern = new RegExp(`^${escapedLockBasename}\\.owner-([a-f0-9]{32})(?:\\.reaping-(\\d+)-([A-Za-z0-9_-]{1,32})-(\\d+)-[a-f0-9]{32})?$`);
+    for (const entry of plugins.fsSync.readdirSync(directory, { withFileTypes: true })) {
+        const match = ownerPattern.exec(entry.name);
+        if (!match || !entry.isFile()) {
+            continue;
+        }
+        const ownerPath = plugins.path.join(directory, entry.name);
+        const marker = parseLockMarker(plugins.fsSync.readFileSync(ownerPath, 'utf8'), targetPathArg);
+        if (isProcessOwnershipActive(marker, ownerPath, lockLeaseTimeoutMs)) {
+            continue;
+        }
+        const baseOwnerPath = getLockOwnerPath(lockPath, match[1]);
+        const reaperOwnership = match[2]
+            ? parseReaperOwnership(baseOwnerPath, ownerPath)
+            : undefined;
+        if (match[2] && !reaperOwnership) {
+            throw new Error(`Refusing to use invalid artifact lock reaping path: ${ownerPath}`);
+        }
+        if (reaperOwnership && isReaperOwnershipActive(reaperOwnership)) {
+            continue;
+        }
+        if (plugins.fsSync.existsSync(lockPath) && sameFile(lockPath, ownerPath)) {
+            continue;
+        }
+        plugins.fsSync.rmSync(ownerPath, { force: true });
+    }
+};
+const getReapingPath = (ownerPathArg) => (`${ownerPathArg}.reaping-${process.pid}-${getProcessIdentityToken(process.pid)}-${Date.now()}-${createToken()}`);
+const parseReaperOwnership = (ownerPathArg, reapingPathArg) => {
+    const suffix = plugins.path.basename(reapingPathArg).slice(plugins.path.basename(ownerPathArg).length);
+    const match = /^\.reaping-(\d+)-([A-Za-z0-9_-]{1,32})-(\d+)-[a-f0-9]{32}$/.exec(suffix);
+    if (!match) {
+        return undefined;
+    }
+    const processId = Number(match[1]);
+    const createdAt = Number(match[3]);
+    if (!Number.isSafeInteger(processId)
+        || processId <= 0
+        || !Number.isSafeInteger(createdAt)
+        || createdAt <= 0) {
+        return undefined;
+    }
+    return {
+        processId,
+        processIdentityToken: match[2],
+        createdAt,
+    };
+};
+const isReaperOwnershipActive = (ownershipArg) => {
+    if (!isProcessAlive(ownershipArg.processId)) {
+        return false;
+    }
+    if (ownershipArg.processIdentityToken !== 'lease') {
+        const currentIdentity = getProcessIdentity(ownershipArg.processId);
+        if (currentIdentity) {
+            return encodeProcessIdentity(currentIdentity) === ownershipArg.processIdentityToken;
+        }
+    }
+    return Date.now() - ownershipArg.createdAt < lockLeaseTimeoutMs;
+};
+const claimReapingOwner = (lockPathArg, ownerPathArg) => {
+    const reapingPath = getReapingPath(ownerPathArg);
+    try {
+        plugins.fsSync.renameSync(ownerPathArg, reapingPath);
+        return reapingPath;
+    }
+    catch (error) {
+        if (!hasErrorCode(error) || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    const directory = plugins.path.dirname(ownerPathArg);
+    const prefix = `${plugins.path.basename(ownerPathArg)}.reaping-`;
+    let entries;
+    try {
+        entries = plugins.fsSync.readdirSync(directory).filter((entry) => entry.startsWith(prefix));
+    }
+    catch (error) {
+        if (hasErrorCode(error) && error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+    for (const entry of entries) {
+        const existingReapingPath = plugins.path.join(directory, entry);
+        const reaperOwnership = parseReaperOwnership(ownerPathArg, existingReapingPath);
+        if (!reaperOwnership) {
+            throw new Error(`Refusing to use invalid artifact lock reaping path: ${existingReapingPath}`);
+        }
+        if (isReaperOwnershipActive(reaperOwnership)) {
+            return undefined;
+        }
+        try {
+            plugins.fsSync.renameSync(existingReapingPath, reapingPath);
+            return reapingPath;
+        }
+        catch (error) {
+            if (hasErrorCode(error) && error.code === 'ENOENT') {
+                continue;
+            }
+            throw error;
+        }
+    }
+    // The stale lock may already have been removed between inspection and claim.
+    if (!plugins.fsSync.existsSync(lockPathArg)) {
+        return undefined;
+    }
+    return undefined;
+};
+const tryReapStaleLock = (targetPathArg) => {
+    const lockPath = getLockPath(targetPathArg);
+    const marker = readLockMarker(lockPath, targetPathArg);
+    if (!marker || isProcessOwnershipActive(marker, lockPath, lockLeaseTimeoutMs)) {
+        return false;
+    }
+    const ownerPath = getLockOwnerPath(lockPath, marker.ownerToken);
+    const reapingPath = claimReapingOwner(lockPath, ownerPath);
+    if (!reapingPath) {
+        return false;
+    }
+    try {
+        if (plugins.fsSync.existsSync(lockPath) && sameFile(lockPath, reapingPath)) {
+            plugins.fsSync.unlinkSync(lockPath);
+        }
+    }
+    finally {
+        plugins.fsSync.rmSync(reapingPath, { force: true });
+    }
+    return true;
+};
+const releaseLockOwner = (ownerArg) => {
+    let canRemoveOwner = false;
+    try {
+        if (!plugins.fsSync.existsSync(ownerArg.lockPath)) {
+            canRemoveOwner = true;
+        }
+        else if (plugins.fsSync.existsSync(ownerArg.ownerPath)
+            && sameFile(ownerArg.lockPath, ownerArg.ownerPath)) {
+            plugins.fsSync.unlinkSync(ownerArg.lockPath);
+            canRemoveOwner = true;
+        }
+        else {
+            canRemoveOwner = true;
+        }
+    }
+    catch (error) {
+        console.warn(`tsbundle: unable to release artifact publication lock ${ownerArg.lockPath}: ${String(error)}`);
+        try {
+            const abandonedMarker = {
+                ...ownerArg.marker,
+                leaseManaged: false,
+                processId: 2_147_483_647,
+                processIdentity: '',
+            };
+            plugins.fsSync.writeFileSync(ownerArg.ownerPath, `${JSON.stringify(abandonedMarker, null, 2)}\n`, { flag: 'w', mode: 0o600 });
+        }
+        catch (markerError) {
+            console.warn(`tsbundle: unable to mark artifact lock abandoned ${ownerArg.ownerPath}: ${String(markerError)}`);
+        }
+    }
+    if (canRemoveOwner) {
+        try {
+            plugins.fsSync.rmSync(ownerArg.ownerPath, { force: true });
+        }
+        catch (error) {
+            console.warn(`tsbundle: unable to remove artifact lock owner ${ownerArg.ownerPath}: ${String(error)}`);
+        }
+    }
+};
+export const withArtifactPublicationLock = async (targetPathArg, callbackArg) => {
+    const resolvedTargetPath = plugins.path.resolve(targetPathArg);
+    plugins.fsSync.mkdirSync(plugins.path.dirname(resolvedTargetPath), { recursive: true });
+    cleanupOrphanLockOwners(resolvedTargetPath);
+    const owner = createLockOwner(resolvedTargetPath);
+    const deadline = Date.now() + lockWaitTimeoutMs;
+    let acquired = false;
+    let stopHeartbeat;
+    try {
+        while (!acquired) {
+            try {
+                plugins.fsSync.linkSync(owner.ownerPath, owner.lockPath);
+                acquired = true;
+                stopHeartbeat = startOwnershipHeartbeat(owner.ownerPath);
+            }
+            catch (error) {
+                if (!hasErrorCode(error) || error.code !== 'EEXIST') {
+                    const detail = hasErrorCode(error) ? ` (${error.code})` : '';
+                    throw new Error(`Unable to acquire hard-link artifact publication lock${detail}: ${owner.lockPath}`);
+                }
+                tryReapStaleLock(resolvedTargetPath);
+                if (Date.now() >= deadline) {
+                    throw new Error(`Timed out waiting for artifact publication lock: ${owner.lockPath}`);
+                }
+                await plugins.delay(25);
+            }
+        }
+        return await callbackArg();
+    }
+    finally {
+        stopHeartbeat?.();
+        if (acquired) {
+            releaseLockOwner(owner);
+        }
+        else {
+            plugins.fsSync.rmSync(owner.ownerPath, { force: true });
+        }
+    }
+};
+const getArtifactPublicationLockTargets = (targetPathArg, additionalTargetPathsArg = []) => {
+    const targetPath = plugins.path.resolve(targetPathArg);
+    return [...new Set([
+            targetPath,
+            plugins.path.join(plugins.path.dirname(targetPath), '.tsbundle-output-directory'),
+            ...additionalTargetPathsArg.map((additionalPath) => plugins.path.resolve(additionalPath)),
+        ])].sort((first, second) => first.localeCompare(second));
+};
+export const withArtifactPublicationLocks = async (targetPathArg, callbackArg, additionalTargetPathsArg = []) => {
+    const lockTargetPaths = getArtifactPublicationLockTargets(targetPathArg, additionalTargetPathsArg);
+    const acquireLock = async (indexArg) => {
+        if (indexArg === lockTargetPaths.length) {
+            return await callbackArg();
+        }
+        return await withArtifactPublicationLock(lockTargetPaths[indexArg], async () => await acquireLock(indexArg + 1));
+    };
+    return await acquireLock(0);
+};
+export const writeFileAtomically = (targetPathArg, contentArg, modeArg) => {
+    const targetPath = plugins.path.resolve(targetPathArg);
+    plugins.fsSync.mkdirSync(plugins.path.dirname(targetPath), { recursive: true });
+    assertPathNotSymbolicLink(targetPath, 'artifact target');
+    if (plugins.fsSync.existsSync(targetPath) && !plugins.fsSync.lstatSync(targetPath).isFile()) {
+        throw new Error(`Refusing to replace non-file artifact target: ${targetPath}`);
+    }
+    const temporaryPath = plugins.path.join(plugins.path.dirname(targetPath), `.${plugins.path.basename(targetPath)}.${process.pid}.${createToken()}.tsbundle-tmp`);
+    try {
+        plugins.fsSync.writeFileSync(temporaryPath, contentArg, {
+            flag: 'wx',
+            mode: modeArg,
+        });
+        plugins.fsSync.renameSync(temporaryPath, targetPath);
+    }
+    finally {
+        plugins.fsSync.rmSync(temporaryPath, { force: true });
+    }
+};
+export const getChunkNamespace = (logicalOutputNameArg) => (plugins.crypto
+    .createHash('sha256')
+    .update(logicalOutputNameArg)
+    .digest('base64url')
+    .slice(0, 24));
+const getChunkNamespaceDirectory = (directoryArg, namespaceArg) => (plugins.path.join(directoryArg, 'chunks', namespaceArg));
+const getChunkManifestPath = (namespaceDirectoryArg) => (plugins.path.join(namespaceDirectoryArg, chunkManifestFile));
+const parseChunkManifest = (rawManifestArg) => {
+    try {
+        const manifest = JSON.parse(rawManifestArg);
+        if (manifest.owner === artifactOwner
+            && manifest.kind === chunkManifestKind
+            && typeof manifest.logicalOutputName === 'string'
+            && typeof manifest.namespace === 'string'
+            && manifest.schemaVersion === chunkManifestSchemaVersion) {
+            return manifest;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+};
+const readChunkManifest = (namespaceDirectoryArg) => {
+    const manifestPath = getChunkManifestPath(namespaceDirectoryArg);
+    try {
+        assertRegularFile(manifestPath, 'chunk ownership manifest');
+        return parseChunkManifest(plugins.fsSync.readFileSync(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        if (hasErrorCode(error) && error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+};
+const assertOwnedChunkNamespace = (namespaceDirectoryArg, logicalOutputNameArg, namespaceArg) => {
+    const manifest = readChunkManifest(namespaceDirectoryArg);
+    if (!manifest
+        || manifest.logicalOutputName !== logicalOutputNameArg
+        || manifest.namespace !== namespaceArg) {
+        throw new Error(`Refusing to modify unowned chunk namespace: ${namespaceDirectoryArg}`);
+    }
+};
+const assertSafeArtifactTree = (directoryArg) => {
+    if (!plugins.fsSync.existsSync(directoryArg)) {
+        return;
+    }
+    const stat = plugins.fsSync.lstatSync(directoryArg);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new Error(`Refusing to use unsafe generated artifact directory: ${directoryArg}`);
+    }
+    for (const entry of plugins.fsSync.readdirSync(directoryArg, { withFileTypes: true })) {
+        const entryPath = plugins.path.join(directoryArg, entry.name);
+        const entryStat = plugins.fsSync.lstatSync(entryPath);
+        if (entryStat.isSymbolicLink()) {
+            throw new Error(`Refusing to use symbolic-link generated artifact: ${entryPath}`);
+        }
+        if (entryStat.isDirectory()) {
+            assertSafeArtifactTree(entryPath);
+        }
+        else if (!entryStat.isFile()) {
+            throw new Error(`Refusing to use non-file generated artifact: ${entryPath}`);
+        }
+    }
+};
+const listArtifactFiles = (directoryArg) => {
+    if (!plugins.fsSync.existsSync(directoryArg)) {
+        return [];
+    }
+    assertSafeArtifactTree(directoryArg);
+    const files = [];
+    const collect = (currentDirectoryArg) => {
+        for (const entry of plugins.fsSync.readdirSync(currentDirectoryArg, { withFileTypes: true })) {
+            const entryPath = plugins.path.join(currentDirectoryArg, entry.name);
+            if (entry.isDirectory()) {
+                collect(entryPath);
+            }
+            else if (entry.isFile() && entry.name !== chunkManifestFile) {
+                files.push(entryPath);
+            }
+        }
+    };
+    collect(directoryArg);
+    return files.sort((first, second) => first.localeCompare(second));
+};
+const rebaseSourceMap = (sourceMapContentArg, sourceDirectoryArg, targetDirectoryArg, targetFileNameArg) => {
+    const sourceMap = JSON.parse(sourceMapContentArg.toString('utf8'));
+    if (Array.isArray(sourceMap.sources)) {
+        const sourceRoot = sourceMap.sourceRoot || '';
+        sourceMap.sources = sourceMap.sources.map((source) => {
+            if (/^(?:[a-z]+:|\/)/i.test(source)) {
+                return source;
+            }
+            const absoluteSource = plugins.path.resolve(sourceDirectoryArg, sourceRoot, source);
+            return plugins.path.relative(targetDirectoryArg, absoluteSource).split(plugins.path.sep).join('/');
+        });
+        if (sourceMap.sourceRoot) {
+            sourceMap.sourceRoot = '';
+        }
+    }
+    if (targetFileNameArg) {
+        sourceMap.file = targetFileNameArg;
+    }
+    return Buffer.from(JSON.stringify(sourceMap));
+};
+const prepareChunkArtifacts = (sourceNamespaceDirectoryArg, targetNamespaceDirectoryArg) => listArtifactFiles(sourceNamespaceDirectoryArg).map((sourcePath) => {
+    const relativePath = plugins.path.relative(sourceNamespaceDirectoryArg, sourcePath);
+    const targetPath = plugins.path.join(targetNamespaceDirectoryArg, relativePath);
+    const sourceStat = plugins.fsSync.statSync(sourcePath);
+    const sourceContent = plugins.fsSync.readFileSync(sourcePath);
+    return {
+        content: sourcePath.endsWith('.map')
+            ? rebaseSourceMap(sourceContent, sourceNamespaceDirectoryArg, targetNamespaceDirectoryArg)
+            : sourceContent,
+        mode: sourceStat.mode,
+        relativePath,
+        targetPath,
+    };
+});
+const snapshotFile = (pathArg) => {
+    if (!plugins.fsSync.existsSync(pathArg)) {
+        return { existed: false, path: pathArg };
+    }
+    assertRegularFile(pathArg, 'destination artifact');
+    const stat = plugins.fsSync.statSync(pathArg);
+    return {
+        content: plugins.fsSync.readFileSync(pathArg),
+        existed: true,
+        mode: stat.mode,
+        path: pathArg,
+    };
+};
+const restoreSnapshot = (snapshotArg) => {
+    if (snapshotArg.existed) {
+        writeFileAtomically(snapshotArg.path, snapshotArg.content, snapshotArg.mode);
+    }
+    else {
+        assertPathNotSymbolicLink(snapshotArg.path, 'rollback target');
+        plugins.fsSync.rmSync(snapshotArg.path, { force: true });
+    }
+};
+const removeEmptyDirectories = (startDirectoryArg, stopDirectoryArg) => {
+    let currentDirectory = plugins.path.resolve(startDirectoryArg);
+    const stopDirectory = plugins.path.resolve(stopDirectoryArg);
+    while (currentDirectory !== stopDirectory && currentDirectory.startsWith(`${stopDirectory}${plugins.path.sep}`)) {
+        try {
+            plugins.fsSync.rmdirSync(currentDirectory);
+        }
+        catch (error) {
+            if (hasErrorCode(error) && ['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(error.code || '')) {
+                return;
+            }
+            throw error;
+        }
+        currentDirectory = plugins.path.dirname(currentDirectory);
+    }
+};
+const prepareAdditionalArtifacts = (artifactsArg, targetPathArg, targetMapPathArg, targetChunksDirectoryArg, lockTargetPathsArg) => {
+    const outputDirectory = plugins.path.dirname(targetPathArg);
+    const seenTargets = new Set();
+    return artifactsArg.map((artifact) => {
+        const sourcePath = plugins.path.resolve(artifact.sourcePath);
+        const targetPath = plugins.path.resolve(artifact.targetPath);
+        assertRegularFile(sourcePath, 'included source file');
+        if (plugins.path.dirname(targetPath) !== outputDirectory) {
+            throw new Error(`Included artifact must target the bundle output directory: ${targetPath}`);
+        }
+        if (targetPath === targetPathArg
+            || targetPath === targetMapPathArg
+            || lockTargetPathsArg.some((lockTargetPath) => (targetPath === plugins.path.resolve(lockTargetPath)
+                || targetPath === plugins.path.resolve(getLockPath(lockTargetPath))))
+            || targetPath === targetChunksDirectoryArg
+            || targetPath.startsWith(`${targetChunksDirectoryArg}${plugins.path.sep}`)
+            || plugins.path.basename(targetPath).includes('.tsbundle-')) {
+            throw new Error(`Included artifact collides with a reserved bundle path: ${targetPath}`);
+        }
+        if (seenTargets.has(targetPath)) {
+            throw new Error(`Multiple included artifacts target the same output path: ${targetPath}`);
+        }
+        seenTargets.add(targetPath);
+        const sourceStat = plugins.fsSync.statSync(sourcePath);
+        return {
+            content: plugins.fsSync.readFileSync(sourcePath),
+            mode: sourceStat.mode,
+            targetPath,
+        };
+    });
+};
+const ensureChunkNamespace = (namespaceDirectoryArg, logicalOutputNameArg, namespaceArg) => {
+    if (plugins.fsSync.existsSync(namespaceDirectoryArg)) {
+        assertSafeArtifactTree(namespaceDirectoryArg);
+        assertOwnedChunkNamespace(namespaceDirectoryArg, logicalOutputNameArg, namespaceArg);
+        return false;
+    }
+    plugins.fsSync.mkdirSync(namespaceDirectoryArg, { recursive: true });
+    try {
+        const manifest = {
+            owner: artifactOwner,
+            kind: chunkManifestKind,
+            logicalOutputName: logicalOutputNameArg,
+            namespace: namespaceArg,
+            schemaVersion: chunkManifestSchemaVersion,
+        };
+        writeFileAtomically(getChunkManifestPath(namespaceDirectoryArg), `${JSON.stringify(manifest, null, 2)}\n`);
+    }
+    catch (error) {
+        plugins.fsSync.rmSync(namespaceDirectoryArg, { recursive: true, force: true });
+        throw error;
+    }
+    return true;
+};
+const reconcileChunkNamespace = (namespaceDirectoryArg, chunksDirectoryArg, desiredRelativePathsArg, logicalOutputNameArg, namespaceArg) => {
+    if (!plugins.fsSync.existsSync(namespaceDirectoryArg)) {
+        return;
+    }
+    assertSafeArtifactTree(namespaceDirectoryArg);
+    assertOwnedChunkNamespace(namespaceDirectoryArg, logicalOutputNameArg, namespaceArg);
+    if (desiredRelativePathsArg.size === 0) {
+        plugins.fsSync.rmSync(namespaceDirectoryArg, { recursive: true, force: true });
+    }
+    else {
+        for (const artifactPath of listArtifactFiles(namespaceDirectoryArg)) {
+            const relativePath = plugins.path.relative(namespaceDirectoryArg, artifactPath);
+            if (!desiredRelativePathsArg.has(relativePath)) {
+                plugins.fsSync.rmSync(artifactPath, { force: true });
+                removeEmptyDirectories(plugins.path.dirname(artifactPath), namespaceDirectoryArg);
+            }
+        }
+    }
+    try {
+        plugins.fsSync.rmdirSync(chunksDirectoryArg);
+    }
+    catch (error) {
+        if (!hasErrorCode(error) || !['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(error.code || '')) {
+            throw error;
+        }
+    }
+};
+export const publishGeneratedArtifacts = async (optionsArg) => {
+    const sourceDirectory = plugins.path.resolve(optionsArg.sourceDirectory);
+    const sourceMainPath = plugins.path.resolve(optionsArg.sourceMainPath);
+    const targetPath = plugins.path.resolve(optionsArg.targetPath);
+    const targetDirectory = plugins.path.dirname(targetPath);
+    const targetMapPath = `${targetPath}.map`;
+    const additionalLockTargets = optionsArg.lockTargetPath
+        ? [optionsArg.lockTargetPath]
+        : [];
+    const lockTargetPaths = getArtifactPublicationLockTargets(targetPath, additionalLockTargets);
+    const sourceNamespaceDirectory = getChunkNamespaceDirectory(sourceDirectory, optionsArg.chunkNamespace);
+    const targetChunksDirectory = plugins.path.join(targetDirectory, 'chunks');
+    const targetNamespaceDirectory = getChunkNamespaceDirectory(targetDirectory, optionsArg.chunkNamespace);
+    const publishUnderLocks = async () => {
+        assertRegularFile(sourceMainPath, 'generated main bundle');
+        assertPathNotSymbolicLink(targetPath, 'bundle target');
+        assertPathNotSymbolicLink(targetMapPath, 'bundle source map target');
+        assertPathNotSymbolicLink(targetChunksDirectory, 'chunk directory');
+        if (plugins.fsSync.existsSync(targetPath)) {
+            assertRegularFile(targetPath, 'bundle target');
+        }
+        if (plugins.fsSync.existsSync(targetNamespaceDirectory)) {
+            assertSafeArtifactTree(targetNamespaceDirectory);
+            assertOwnedChunkNamespace(targetNamespaceDirectory, optionsArg.logicalOutputName, optionsArg.chunkNamespace);
+        }
+        const sourceMainStat = plugins.fsSync.statSync(sourceMainPath);
+        let mainContent = plugins.fsSync.readFileSync(sourceMainPath, 'utf8');
+        const sourceMainName = plugins.path.basename(sourceMainPath);
+        const targetMainName = plugins.path.basename(targetPath);
+        const sourceMapPattern = new RegExp(`//# sourceMappingURL=${sourceMainName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.map`, 'g');
+        mainContent = mainContent.replace(sourceMapPattern, `//# sourceMappingURL=${targetMainName}.map`);
+        const sourceMapPath = `${sourceMainPath}.map`;
+        let preparedMainMap;
+        let sourceMapMode;
+        if (optionsArg.sourceMapsEnabled) {
+            assertRegularFile(sourceMapPath, 'generated source map');
+            preparedMainMap = rebaseSourceMap(plugins.fsSync.readFileSync(sourceMapPath), sourceDirectory, targetDirectory, targetMainName);
+            sourceMapMode = plugins.fsSync.statSync(sourceMapPath).mode;
+        }
+        const preparedChunks = prepareChunkArtifacts(sourceNamespaceDirectory, targetNamespaceDirectory);
+        const desiredChunkPaths = new Set(preparedChunks.map((artifact) => artifact.relativePath));
+        for (const artifact of preparedChunks) {
+            if (plugins.fsSync.existsSync(artifact.targetPath)) {
+                assertRegularFile(artifact.targetPath, 'generated chunk target');
+                if (!plugins.fsSync.readFileSync(artifact.targetPath).equals(artifact.content)) {
+                    throw new Error(`Generated chunk name collision with different content: ${artifact.targetPath}`);
+                }
+            }
+        }
+        const preparedAdditionalArtifacts = prepareAdditionalArtifacts(optionsArg.additionalArtifacts || [], targetPath, targetMapPath, targetChunksDirectory, lockTargetPaths);
+        const additionalSnapshots = preparedAdditionalArtifacts.map((artifact) => snapshotFile(artifact.targetPath));
+        const mapSnapshot = snapshotFile(targetMapPath);
+        const newlyCreatedChunkPaths = [];
+        let namespaceCreated = false;
+        let mainCommitted = false;
+        try {
+            if (preparedChunks.length > 0) {
+                namespaceCreated = ensureChunkNamespace(targetNamespaceDirectory, optionsArg.logicalOutputName, optionsArg.chunkNamespace);
+                for (const artifact of preparedChunks) {
+                    if (plugins.fsSync.existsSync(artifact.targetPath)) {
+                        continue;
+                    }
+                    writeFileAtomically(artifact.targetPath, artifact.content, artifact.mode);
+                    newlyCreatedChunkPaths.push(artifact.targetPath);
+                }
+            }
+            for (const artifact of preparedAdditionalArtifacts) {
+                writeFileAtomically(artifact.targetPath, artifact.content, artifact.mode);
+            }
+            if (preparedMainMap) {
+                writeFileAtomically(targetMapPath, preparedMainMap, sourceMapMode);
+            }
+            writeFileAtomically(targetPath, mainContent, sourceMainStat.mode);
+            mainCommitted = true;
+        }
+        catch (error) {
+            const rollbackErrors = [];
+            for (const snapshot of [...additionalSnapshots].reverse()) {
+                try {
+                    restoreSnapshot(snapshot);
+                }
+                catch (rollbackError) {
+                    rollbackErrors.push(rollbackError);
+                }
+            }
+            try {
+                restoreSnapshot(mapSnapshot);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+            try {
+                if (namespaceCreated) {
+                    plugins.fsSync.rmSync(targetNamespaceDirectory, { recursive: true, force: true });
+                    try {
+                        plugins.fsSync.rmdirSync(targetChunksDirectory);
+                    }
+                    catch (cleanupError) {
+                        if (!hasErrorCode(cleanupError)
+                            || !['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(cleanupError.code || '')) {
+                            throw cleanupError;
+                        }
+                    }
+                }
+                else {
+                    for (const chunkPath of [...newlyCreatedChunkPaths].reverse()) {
+                        plugins.fsSync.rmSync(chunkPath, { force: true });
+                        removeEmptyDirectories(plugins.path.dirname(chunkPath), targetNamespaceDirectory);
+                    }
+                }
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+            if (rollbackErrors.length > 0) {
+                throw new AggregateError([error, ...rollbackErrors], 'Artifact publication failed and rollback was incomplete.');
+            }
+            throw error;
+        }
+        if (mainCommitted) {
+            try {
+                if (!optionsArg.sourceMapsEnabled) {
+                    assertPathNotSymbolicLink(targetMapPath, 'stale source map target');
+                    plugins.fsSync.rmSync(targetMapPath, { force: true });
+                }
+                reconcileChunkNamespace(targetNamespaceDirectory, targetChunksDirectory, desiredChunkPaths, optionsArg.logicalOutputName, optionsArg.chunkNamespace);
+            }
+            catch (error) {
+                console.warn(`tsbundle: output committed but stale artifact cleanup was incomplete: ${String(error)}`);
+            }
+        }
+    };
+    await withArtifactPublicationLocks(targetPath, publishUnderLocks, additionalLockTargets);
+};
+const assertBuildStageDirectory = (stageDirectoryArg, outputDirectoryArg) => {
+    const stageDirectory = plugins.path.resolve(stageDirectoryArg);
+    const outputDirectory = plugins.path.resolve(outputDirectoryArg);
+    if (plugins.path.dirname(stageDirectory) !== outputDirectory
+        || !plugins.path.basename(stageDirectory).startsWith('.tsbundle-stage-')) {
+        throw new Error(`Refusing to use unexpected build stage: ${stageDirectoryArg}`);
+    }
+    const stat = plugins.fsSync.lstatSync(stageDirectory);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new Error(`Refusing to use unsafe build stage: ${stageDirectoryArg}`);
+    }
+};
+const getBuildStageMarkerPath = (stageDirectoryArg) => (plugins.path.join(stageDirectoryArg, '.tsbundle-stage.json'));
+const parseBuildStageMarker = (rawMarkerArg) => {
+    try {
+        const marker = JSON.parse(rawMarkerArg);
+        if (marker.owner === artifactOwner
+            && marker.kind === buildStageKind
+            && typeof marker.processId === 'number'
+            && Number.isSafeInteger(marker.processId)
+            && marker.processId > 0
+            && (marker.processIdentity === undefined || typeof marker.processIdentity === 'string')
+            && (marker.leaseManaged === undefined || typeof marker.leaseManaged === 'boolean')
+            && typeof marker.createdAt === 'string'
+            && typeof marker.invocationId === 'string'
+            && /^[A-Za-z0-9._-]{1,128}$/.test(marker.invocationId)
+            && marker.schemaVersion === buildStageSchemaVersion) {
+            return marker;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+};
+const readBuildStageMarker = (stageDirectoryArg) => {
+    try {
+        const markerPath = getBuildStageMarkerPath(stageDirectoryArg);
+        assertRegularFile(markerPath, 'build stage marker');
+        return parseBuildStageMarker(plugins.fsSync.readFileSync(markerPath, 'utf8'));
+    }
+    catch (error) {
+        if (hasErrorCode(error) && error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+};
+const buildStageMarkersMatch = (firstMarkerArg, secondMarkerArg) => (firstMarkerArg.owner === secondMarkerArg.owner
+    && firstMarkerArg.kind === secondMarkerArg.kind
+    && firstMarkerArg.processId === secondMarkerArg.processId
+    && firstMarkerArg.processIdentity === secondMarkerArg.processIdentity
+    && firstMarkerArg.leaseManaged === secondMarkerArg.leaseManaged
+    && firstMarkerArg.createdAt === secondMarkerArg.createdAt
+    && firstMarkerArg.invocationId === secondMarkerArg.invocationId
+    && firstMarkerArg.schemaVersion === secondMarkerArg.schemaVersion);
+export const cleanupStaleBuildStages = (outputDirectoryArg) => {
+    const outputDirectory = plugins.path.resolve(outputDirectoryArg);
+    if (!plugins.fsSync.existsSync(outputDirectory)) {
+        return;
+    }
+    for (const entry of plugins.fsSync.readdirSync(outputDirectory, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !entry.name.startsWith('.tsbundle-stage-')) {
+            continue;
+        }
+        const stageDirectory = plugins.path.join(outputDirectory, entry.name);
+        let marker;
+        try {
+            assertBuildStageDirectory(stageDirectory, outputDirectory);
+            marker = readBuildStageMarker(stageDirectory);
+        }
+        catch (error) {
+            if (hasErrorCode(error) && error.code === 'ENOENT') {
+                continue;
+            }
+            throw error;
+        }
+        if (!marker) {
+            continue;
+        }
+        const createdAt = Date.parse(marker.createdAt);
+        if (!Number.isFinite(createdAt)
+            || Date.now() - createdAt < staleStageThresholdMs
+            || isProcessOwnershipActive(marker, getBuildStageMarkerPath(stageDirectory), staleStageThresholdMs)) {
+            continue;
+        }
+        const currentMarker = readBuildStageMarker(stageDirectory);
+        if (currentMarker && buildStageMarkersMatch(marker, currentMarker)) {
+            plugins.fsSync.rmSync(stageDirectory, { recursive: true, force: true });
+        }
+    }
+};
+export const createBuildStage = (outputDirectoryArg) => {
+    const outputDirectory = plugins.path.resolve(outputDirectoryArg);
+    plugins.fsSync.mkdirSync(outputDirectory, { recursive: true });
+    assertPathNotSymbolicLink(outputDirectory, 'build output directory');
+    cleanupStaleBuildStages(outputDirectory);
+    const stageDirectory = plugins.fsSync.mkdtempSync(plugins.path.join(outputDirectory, '.tsbundle-stage-'));
+    try {
+        assertBuildStageDirectory(stageDirectory, outputDirectory);
+        const marker = {
+            owner: artifactOwner,
+            kind: buildStageKind,
+            ...createProcessOwnership(),
+            createdAt: new Date().toISOString(),
+            invocationId: `${process.pid}-${Date.now()}-${createToken()}`,
+            schemaVersion: buildStageSchemaVersion,
+        };
+        plugins.fsSync.writeFileSync(getBuildStageMarkerPath(stageDirectory), `${JSON.stringify(marker, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+        buildStageHeartbeats.set(stageDirectory, startOwnershipHeartbeat(getBuildStageMarkerPath(stageDirectory)));
+        return { marker, stageDirectory };
+    }
+    catch (error) {
+        plugins.fsSync.rmSync(stageDirectory, { recursive: true, force: true });
+        throw error;
+    }
+};
+export const cleanupBuildStage = (stageDirectoryArg, outputDirectoryArg, expectedMarkerArg) => {
+    buildStageHeartbeats.get(stageDirectoryArg)?.();
+    buildStageHeartbeats.delete(stageDirectoryArg);
+    try {
+        assertBuildStageDirectory(stageDirectoryArg, outputDirectoryArg);
+        const currentMarker = readBuildStageMarker(stageDirectoryArg);
+        if (currentMarker && buildStageMarkersMatch(currentMarker, expectedMarkerArg)) {
+            plugins.fsSync.rmSync(stageDirectoryArg, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        if (!hasErrorCode(error) || error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"artifactpublisher.js","sourceRoot":"","sources":["../../ts/mod_output/artifactpublisher.ts"],"names":[],"mappings":"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"}