@neottia/repository-store 0.2.1 → 0.3.2

package/dist/lease.js

@@ -14,6 +14,8 @@ const DEFAULT_STALE_MS = 60_000;
 const DEFAULT_POLL_MS = 20;
 const DEFAULT_WAIT_MS = 10_000;
 const MAX_LEASE_METADATA_BYTES = 4 * 1024;
+const WINDOWS_RELEASE_RETRY_ATTEMPTS = 25;
+const WINDOWS_RELEASE_RETRY_DELAY_MS = 10;
 export async function withRepositoryLease(root, operation, options = {}) {
     const rootState = getRootState(root);
     if (rootState === undefined)
@@ -40,18 +42,38 @@ export async function withRepositoryLease(root, operation, options = {}) {
     let ownerIdentity;
     let leaseState;
     let lockPath = '';
+    let lockKind = 'directory';
     let token = '';
     try {
         checkAcquisitionControl(deadline, explicitDeadline !== undefined, options.signal);
         ensurePrivateDirectory(controlRoot);
         const cleanupBackend = requireRepositoryPlatformBackend();
         assertPlatformFilesystem(cleanupBackend, controlRoot);
+        lockKind = cleanupBackend.leaseArtifact;
         const hostId = ensureHostId(controlRoot);
         lockPath = join(controlRoot, 'authority.lease');
         const claimPath = join(controlRoot, 'authority.claim');
         token = randomBytes(32).toString('hex');
         while (!acquired) {
             checkAcquisitionControl(deadline, explicitDeadline !== undefined, options.signal);
+            if (lockKind === 'file') {
+                if (!acquireClaim(lockPath, controlRoot, token, hostId)) {
+                    if (tryReclaimFileLease(lockPath, controlRoot, hostId, staleMs))
+                        continue;
+                    await waitForLeasePoll(pollMs, deadline, explicitDeadline !== undefined, options.signal);
+                    continue;
+                }
+                emitLeaseFault('lease-directory-created');
+                const owner = readOwner(lockPath);
+                if (owner.metadata.token !== token)
+                    throw new LeaseContentionError('Repository file lease ownership changed.', 'LEASE_OWNER_UNKNOWN');
+                lockIdentity = owner.identity;
+                ownerIdentity = owner.identity;
+                emitLeaseFault('lease-owner-written');
+                emitLeaseFault('lease-claim-removed');
+                acquired = true;
+                continue;
+            }
             if (!acquireClaim(claimPath, controlRoot, token, hostId)) {
                 if (tryReclaimClaim(claimPath, lockPath, controlRoot, hostId, staleMs))
                     continue;
@@ -87,7 +109,7 @@ export async function withRepositoryLease(root, operation, options = {}) {
                 syncDirectory(controlRoot);
                 if (!removeOwnedClaim(claimPath, token)) {
                     claimOwnershipUncertain = true;
-                    releaseOwnedLease(lockPath, controlRoot, token, lockIdentity, ownerIdentity);
+                    await releaseOwnedLease(lockPath, controlRoot, token, lockIdentity, ownerIdentity, lockKind);
                     throw new LeaseContentionError('Repository initialization claim ownership changed.', 'LEASE_OWNER_UNKNOWN');
                 }
                 emitLeaseFault('lease-claim-removed');
@@ -109,6 +131,7 @@ export async function withRepositoryLease(root, operation, options = {}) {
             authorityId: rootState.authorityId,
             token,
             lockPath,
+            lockKind,
             lockIdentity,
             ownerIdentity,
             pendingOperations: new Set(),
@@ -131,7 +154,7 @@ export async function withRepositoryLease(root, operation, options = {}) {
             leaseState.active = false;
         }
         if (acquired && lockIdentity !== undefined && ownerIdentity !== undefined)
-            releaseOwnedLease(lockPath, controlRoot, token, lockIdentity, ownerIdentity);
+            await releaseOwnedLease(lockPath, controlRoot, token, lockIdentity, ownerIdentity, lockKind);
         turn.release();
     }
 }
@@ -142,7 +165,7 @@ export function assertLiveLease(root, lease) {
         throw new RepositoryStoreConfigError('Lease and managed root have different authorities.', 'AUTHORITY_MISMATCH');
     if (!leaseState.active)
         throw new LeaseContentionError('Repository lease is no longer active.', 'LEASE_BUSY');
-    if (!ownedLeaseIdentityMatches(leaseState.lockPath, leaseState.token, leaseState.lockIdentity, leaseState.ownerIdentity)) {
+    if (!ownedLeaseIdentityMatches(leaseState.lockPath, leaseState.token, leaseState.lockIdentity, leaseState.ownerIdentity, leaseState.lockKind)) {
         leaseState.active = false;
         throw new LeaseContentionError('Repository lease ownership changed.', 'LEASE_OWNER_UNKNOWN');
     }
@@ -196,10 +219,7 @@ function ownerMetadata(token, hostId) {
 function ensureHostId(controlRoot) {
     const path = join(controlRoot, 'host-id');
     try {
-        const value = new TextDecoder().decode(readRegularFile(path, MAX_LEASE_METADATA_BYTES)).trim();
-        if (!/^[0-9a-f]{64}$/u.test(value))
-            throw new PathSafetyError('Repository host-id is malformed.');
-        return value;
+        return readHostId(path, controlRoot);
     }
     catch (error) {
         if (!hasCode(error, 'ENOENT'))
@@ -229,6 +249,92 @@ function ensureHostId(controlRoot) {
         rmSync(candidate, { force: true });
     }
 }
+function readHostId(path, controlRoot) {
+    const identity = lstatSync(path);
+    if (identity.isSymbolicLink() || !identity.isFile())
+        throw new PathSafetyError('Repository host-id has an unsafe identity.', 'UNSAFE_LINK');
+    if (identity.nlink !== 1 && identity.nlink !== 2)
+        throw new PathSafetyError('Repository host-id has an unsafe hard-link count.', 'UNSAFE_HARD_LINK');
+    if (identity.nlink === 2) {
+        const prefix = '.host-id-';
+        const peers = readdirSync(controlRoot).filter((name) => {
+            if (!name.startsWith(prefix) || !name.endsWith('.tmp'))
+                return false;
+            const token = name.slice(prefix.length, -'.tmp'.length);
+            if (!/^[0-9a-f]{32}$/u.test(token))
+                return false;
+            try {
+                const peer = lstatSync(join(controlRoot, name));
+                return peer.isFile() && !peer.isSymbolicLink() && sameIdentity(identity, peer);
+            }
+            catch (error) {
+                if (hasCode(error, 'ENOENT'))
+                    return false;
+                throw error;
+            }
+        });
+        if (peers.length === 1) {
+            rmSync(join(controlRoot, peers[0]));
+            syncDirectory(controlRoot);
+        }
+        else {
+            const stabilized = lstatSync(path);
+            if (stabilized.nlink !== 1 || !sameIdentity(identity, stabilized))
+                throw new PathSafetyError('Repository host-id hard link is not package-owned.', 'UNSAFE_HARD_LINK');
+        }
+    }
+    const value = new TextDecoder().decode(readRegularFile(path, MAX_LEASE_METADATA_BYTES)).trim();
+    if (!/^[0-9a-f]{64}$/u.test(value))
+        throw new PathSafetyError('Repository host-id is malformed.');
+    return value;
+}
+function tryReclaimFileLease(lockPath, controlRoot, hostId, staleMs) {
+    const controlDirectories = captureDirectories(controlRoot);
+    try {
+        const preliminary = lstatSync(lockPath);
+        assertPreliminaryFileLeaseIdentity(preliminary);
+        const verifiedOwner = readOwner(lockPath, true, true);
+        if (!sameIdentity(preliminary, verifiedOwner.identity))
+            throw new LeaseContentionError('File lease identity changed before owner verification.', 'LEASE_OWNER_UNKNOWN');
+        if (Date.now() - verifiedOwner.identity.mtimeMs < staleMs)
+            return false;
+        if (!conclusivelyDead(verifiedOwner.metadata, hostId))
+            return false;
+        normalizeInterruptedClaimLink(lockPath, controlRoot, true, verifiedOwner.metadata.token);
+        const normalizedOwner = readOwner(lockPath);
+        if (!sameIdentity(preliminary, normalizedOwner.identity) ||
+            normalizedOwner.metadata.token !== verifiedOwner.metadata.token)
+            throw new LeaseContentionError('File lease owner changed during reclamation.', 'LEASE_OWNER_UNKNOWN');
+        const quarantine = `${lockPath}.release-${normalizedOwner.metadata.token}`;
+        const expected = {
+            kind: 'file',
+            identity: normalizedOwner.identity,
+            token: normalizedOwner.metadata.token,
+        };
+        if (!quarantineNoReplace(lockPath, quarantine))
+            return false;
+        const moved = readOwner(quarantine);
+        if (!sameIdentity(normalizedOwner.identity, moved.identity) ||
+            moved.metadata.token !== normalizedOwner.metadata.token) {
+            restoreQuarantinedLease(quarantine, lockPath, expected, {
+                kind: 'file',
+                identity: moved.identity,
+                token: moved.metadata.token,
+            });
+            return false;
+        }
+        rmSync(quarantine);
+        syncDirectory(controlRoot);
+        return true;
+    }
+    catch (error) {
+        if (hasCode(error, 'ENOENT') || (error instanceof PathSafetyError && error.code === 'IDENTITY_CHANGED'))
+            return exactPathWasReleased(lockPath, controlDirectories, error, false);
+        if (error instanceof PathSafetyError || error instanceof ResourceLimitError)
+            throw error;
+        return false;
+    }
+}
 function tryReclaimLockedLease(lockPath, controlRoot, hostId, staleMs) {
     const controlDirectories = captureDirectories(controlRoot);
     try {
@@ -324,10 +430,7 @@ function tryReclaimClaim(claimPath, lockPath, controlRoot, hostId, staleMs) {
     const controlDirectories = captureDirectories(controlRoot);
     try {
         const preliminary = lstatSync(claimPath);
-        if (preliminary.isSymbolicLink())
-            throw new PathSafetyError('Unsafe repository claim symbolic link.', 'UNSAFE_LINK');
-        if (!preliminary.isFile() || (preliminary.nlink !== 1 && preliminary.nlink !== 2))
-            throw new PathSafetyError('Unsafe repository claim artifact.', 'UNSAFE_HARD_LINK');
+        assertPreliminaryClaimIdentity(preliminary);
         const verifiedOwner = readOwner(claimPath, true);
         if (!sameIdentity(preliminary, verifiedOwner.identity))
             throw new LeaseContentionError('Claim identity changed before owner verification.', 'LEASE_OWNER_UNKNOWN');
@@ -373,6 +476,24 @@ function tryReclaimClaim(claimPath, lockPath, controlRoot, hostId, staleMs) {
         return false;
     }
 }
+export function assertPreliminaryFileLeaseIdentity(identity) {
+    if (identity.isSymbolicLink() || !identity.isFile())
+        throw new PathSafetyError('Unsafe repository file lease.', 'UNSAFE_HARD_LINK');
+    if (identity.nlink === 0)
+        throw new PathSafetyError('Repository file lease was released before owner verification.', 'IDENTITY_CHANGED');
+    if (identity.nlink !== 1 && identity.nlink !== 2)
+        throw new PathSafetyError('Unsafe repository file lease.', 'UNSAFE_HARD_LINK');
+}
+export function assertPreliminaryClaimIdentity(identity) {
+    if (identity.isSymbolicLink())
+        throw new PathSafetyError('Unsafe repository claim symbolic link.', 'UNSAFE_LINK');
+    if (!identity.isFile())
+        throw new PathSafetyError('Unsafe repository claim artifact.', 'UNSAFE_HARD_LINK');
+    if (identity.nlink === 0)
+        throw new PathSafetyError('Repository claim was released before owner verification.', 'IDENTITY_CHANGED');
+    if (identity.nlink !== 1 && identity.nlink !== 2)
+        throw new PathSafetyError('Unsafe repository claim artifact.', 'UNSAFE_HARD_LINK');
+}
 function cleanupInterruptedInitialization(lockPath, controlRoot, owner, staleMs) {
     let lockStat;
     try {
@@ -459,17 +580,22 @@ function cleanupOwnedInitialization(lockPath, controlRoot, token, expectedLock)
             restoreQuarantinedLease(quarantine, lockPath, releaseExpectation);
     }
 }
-function normalizeInterruptedClaimLink(claimPath, controlRoot) {
+function normalizeInterruptedClaimLink(claimPath, controlRoot, allowReleasePeer = false, expectedToken) {
     const claim = lstatSync(claimPath);
     if (!claim.isFile() || claim.isSymbolicLink() || claim.nlink === 1)
         return;
     if (claim.nlink !== 2)
         throw new PathSafetyError('Unsafe repository claim hard-link count.', 'UNSAFE_HARD_LINK');
-    const prefix = `${basename(claimPath)}.prepare-`;
-    const candidates = readdirSync(dirname(claimPath)).filter((name) => name.startsWith(prefix));
-    const matching = candidates.filter((name) => {
-        const suffix = name.slice(prefix.length);
-        if (!/^[0-9a-f-]{32,64}$/u.test(suffix))
+    const base = basename(claimPath);
+    const prefixes = [`${base}.prepare-`, ...(allowReleasePeer ? [`${base}.release-`] : [])];
+    const candidates = readdirSync(dirname(claimPath)).flatMap((name) => {
+        const prefix = prefixes.find((candidate) => name.startsWith(candidate));
+        if (prefix === undefined)
+            return [];
+        return [{ name, token: name.slice(prefix.length) }];
+    });
+    const matching = candidates.filter(({ name, token }) => {
+        if (!/^[0-9a-f-]{32,64}$/u.test(token) || (expectedToken !== undefined && token !== expectedToken))
             return false;
         const stat = lstatSync(join(dirname(claimPath), name));
         return stat.isFile() && !stat.isSymbolicLink() && sameIdentity(claim, stat);
@@ -480,7 +606,7 @@ function normalizeInterruptedClaimLink(claimPath, controlRoot) {
             return;
         throw new PathSafetyError('Repository claim hard link is not package-owned.');
     }
-    rmSync(join(dirname(claimPath), matching[0]));
+    rmSync(join(dirname(claimPath), matching[0].name));
     syncDirectory(controlRoot);
 }
 function conclusivelyDead(owner, hostId) {
@@ -508,13 +634,16 @@ function readProcessStart(pid) {
         return undefined;
     }
 }
-function readOwner(path, allowInterruptedClaimLink = false) {
+function readOwner(path, allowInterruptedClaimLink = false, allowInterruptedReleaseLink = false) {
     const initialIdentity = allowInterruptedClaimLink ? lstatSync(path) : undefined;
-    const stagingPeer = allowInterruptedClaimLink ? interruptedClaimPeer(path, initialIdentity) : undefined;
+    const stagingPeer = allowInterruptedClaimLink
+        ? interruptedClaimPeer(path, initialIdentity, allowInterruptedReleaseLink)
+        : undefined;
     let file;
     try {
         file = readRegularFileWithIdentity(path, MAX_LEASE_METADATA_BYTES, {
             allowedLinkCounts: allowInterruptedClaimLink ? [1, 2] : [1],
+            unlinkedAsIdentityChange: true,
         });
     }
     catch (error) {
@@ -536,7 +665,9 @@ function readOwner(path, allowInterruptedClaimLink = false) {
             throw new PathSafetyError('Interrupted claim identity changed during owner verification.', 'IDENTITY_CHANGED');
         if (stabilized.nlink !== 1)
             throw error;
-        file = readRegularFileWithIdentity(path, MAX_LEASE_METADATA_BYTES);
+        file = readRegularFileWithIdentity(path, MAX_LEASE_METADATA_BYTES, {
+            unlinkedAsIdentityChange: true,
+        });
     }
     const owner = JSON.parse(new TextDecoder().decode(file.bytes));
     if (owner.version !== 1 ||
@@ -551,27 +682,60 @@ function readOwner(path, allowInterruptedClaimLink = false) {
     const finalIdentity = allowInterruptedClaimLink ? lstatSync(path) : undefined;
     if (finalIdentity !== undefined && !sameIdentity(file.identity, finalIdentity))
         throw new PathSafetyError('Interrupted claim identity changed after owner verification.', 'IDENTITY_CHANGED');
-    const finalStagingPeer = allowInterruptedClaimLink && finalIdentity !== undefined ? interruptedClaimPeer(path, finalIdentity) : undefined;
+    const finalStagingPeer = allowInterruptedClaimLink && finalIdentity !== undefined
+        ? interruptedClaimPeer(path, finalIdentity, allowInterruptedReleaseLink)
+        : undefined;
     if ([stagingPeer, finalStagingPeer].some((peer) => peer !== undefined && owner.token !== peer.token))
         throw new PathSafetyError('Interrupted claim token does not match its package-owned staging link.');
     return { metadata: owner, identity: file.identity };
 }
-function interruptedClaimPeer(path, observed) {
+export function interruptedClaimPeer(path, observed, allowReleasePeer = false) {
     const stat = observed ?? lstatSync(path);
-    if (stat.isSymbolicLink() || !stat.isFile() || (stat.nlink !== 1 && stat.nlink !== 2))
+    if (stat.isSymbolicLink() || !stat.isFile())
+        throw new PathSafetyError('Unsafe interrupted repository claim.', 'UNSAFE_HARD_LINK');
+    if (stat.nlink === 0)
+        throw new PathSafetyError('Interrupted claim was released before peer verification.', 'IDENTITY_CHANGED');
+    if (stat.nlink !== 1 && stat.nlink !== 2)
         throw new PathSafetyError('Unsafe interrupted repository claim.', 'UNSAFE_HARD_LINK');
     if (stat.nlink === 1)
         return undefined;
-    const prefix = `${basename(path)}.prepare-`;
-    const peers = readdirSync(dirname(path)).flatMap((name) => {
-        if (!name.startsWith(prefix))
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const peers = matchingInterruptedClaimPeers(path, stat, allowReleasePeer);
+        if (peers.length === 1)
+            return peers[0];
+        let stabilized;
+        try {
+            stabilized = lstatSync(path);
+        }
+        catch (stabilizationError) {
+            if (hasCode(stabilizationError, 'ENOENT'))
+                throw new PathSafetyError('Interrupted claim was released during peer verification.', 'IDENTITY_CHANGED');
+            throw stabilizationError;
+        }
+        if (stabilized.isSymbolicLink() || !stabilized.isFile())
+            throw new PathSafetyError('Interrupted claim path became unsafe during peer verification.', 'UNSAFE_HARD_LINK');
+        if (!sameIdentity(stat, stabilized))
+            throw new PathSafetyError('Interrupted claim identity changed during peer verification.', 'IDENTITY_CHANGED');
+        if (stabilized.nlink === 1)
+            return undefined;
+        if (stabilized.nlink !== 2)
+            break;
+    }
+    throw new PathSafetyError('Interrupted claim hard link is not package-owned.', 'UNSAFE_HARD_LINK');
+}
+function matchingInterruptedClaimPeers(path, identity, allowReleasePeer) {
+    const base = basename(path);
+    const prefixes = [`${base}.prepare-`, ...(allowReleasePeer ? [`${base}.release-`] : [])];
+    return readdirSync(dirname(path)).flatMap((name) => {
+        const prefix = prefixes.find((candidate) => name.startsWith(candidate));
+        if (prefix === undefined)
             return [];
         const token = name.slice(prefix.length);
         if (!/^[0-9a-f-]{32,64}$/u.test(token))
             return [];
         try {
             const peer = lstatSync(join(dirname(path), name));
-            return peer.isFile() && !peer.isSymbolicLink() && sameIdentity(stat, peer) ? [{ token }] : [];
+            return peer.isFile() && !peer.isSymbolicLink() && sameIdentity(identity, peer) ? [{ token }] : [];
         }
         catch (error) {
             if (hasCode(error, 'ENOENT'))
@@ -579,22 +743,12 @@ function interruptedClaimPeer(path, observed) {
             throw error;
         }
     });
-    if (peers.length === 1)
-        return peers[0];
-    let stabilized;
-    try {
-        stabilized = lstatSync(path);
-    }
-    catch (stabilizationError) {
-        if (hasCode(stabilizationError, 'ENOENT'))
-            throw new PathSafetyError('Interrupted claim was released during peer verification.', 'IDENTITY_CHANGED');
-        throw stabilizationError;
-    }
-    if (!stabilized.isSymbolicLink() && stabilized.isFile() && stabilized.nlink === 1 && sameIdentity(stat, stabilized))
-        return undefined;
-    throw new PathSafetyError('Interrupted claim hard link is not package-owned.', 'UNSAFE_HARD_LINK');
 }
-function releaseOwnedLease(lockPath, controlRoot, token, lockIdentity, ownerIdentity) {
+async function releaseOwnedLease(lockPath, controlRoot, token, lockIdentity, ownerIdentity, lockKind) {
+    if (lockKind === 'file') {
+        await releaseOwnedFileLease(lockPath, controlRoot, token, lockIdentity, ownerIdentity);
+        return;
+    }
     const releasePath = `${lockPath}.release-${token}`;
     const releaseExpectation = {
         kind: 'directory',
@@ -612,7 +766,7 @@ function releaseOwnedLease(lockPath, controlRoot, token, lockIdentity, ownerIden
             !sameLeaseIdentity(ownerIdentity, currentOwner.identity) ||
             currentOwner.metadata.token !== token)
             return;
-        if (!quarantineNoReplace(lockPath, releasePath))
+        if (!(await quarantineOwnedRelease(lockPath, releasePath)))
             return;
         restorationSafe = true;
         const movedLock = lstatSync(releasePath);
@@ -642,6 +796,37 @@ function releaseOwnedLease(lockPath, controlRoot, token, lockIdentity, ownerIden
             restoreQuarantinedLease(releasePath, lockPath, releaseExpectation);
     }
 }
+async function releaseOwnedFileLease(lockPath, controlRoot, token, lockIdentity, ownerIdentity) {
+    const releasePath = `${lockPath}.release-${token}`;
+    const expected = { kind: 'file', identity: lockIdentity, token };
+    let restorationSafe = false;
+    try {
+        const current = readOwner(lockPath);
+        if (current.metadata.token !== token ||
+            !sameIdentity(current.identity, lockIdentity) ||
+            !sameIdentity(current.identity, ownerIdentity))
+            return;
+        if (!(await quarantineOwnedRelease(lockPath, releasePath)))
+            return;
+        restorationSafe = true;
+        const moved = readOwner(releasePath);
+        if (moved.metadata.token !== token || !sameIdentity(moved.identity, lockIdentity)) {
+            restoreQuarantinedLease(releasePath, lockPath, expected, {
+                kind: 'file',
+                identity: moved.identity,
+                token: moved.metadata.token,
+            });
+            return;
+        }
+        rmSync(releasePath);
+        restorationSafe = false;
+        syncDirectory(controlRoot);
+    }
+    catch {
+        if (restorationSafe)
+            restoreQuarantinedLease(releasePath, lockPath, expected);
+    }
+}
 export function restoreQuarantinedLease(quarantine, lockPath, expected, movedFromLock) {
     const verification = `${quarantine}.restore-${randomBytes(16).toString('hex')}`;
     let staged = false;
@@ -801,8 +986,14 @@ function removeOwnedClaim(path, token) {
         return false;
     }
 }
-function ownedLeaseIdentityMatches(lockPath, token, lockIdentity, ownerIdentity) {
+function ownedLeaseIdentityMatches(lockPath, token, lockIdentity, ownerIdentity, lockKind) {
     try {
+        if (lockKind === 'file') {
+            const currentOwner = readOwner(lockPath);
+            return (currentOwner.metadata.token === token &&
+                sameIdentity(lockIdentity, currentOwner.identity) &&
+                sameIdentity(ownerIdentity, currentOwner.identity));
+        }
         const currentLock = lstatSync(lockPath);
         const currentOwner = readOwner(join(lockPath, 'owner.json'));
         return (currentLock.isDirectory() &&
@@ -926,6 +1117,20 @@ function acquisitionTimeout(hasExplicitDeadline) {
         ? new LeaseContentionError('Repository operation deadline was exceeded.', 'DEADLINE_EXCEEDED')
         : new LeaseContentionError('Repository authority lease is busy.', 'LEASE_BUSY');
 }
+async function quarantineOwnedRelease(source, destination) {
+    const backend = requireRepositoryPlatformBackend();
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            return quarantineNoReplace(source, destination);
+        }
+        catch (error) {
+            const retryableWindowsSharingFailure = backend.platform === 'win32' && (hasCode(error, 'EBUSY') || hasCode(error, 'EACCES'));
+            if (!retryableWindowsSharingFailure || attempt >= WINDOWS_RELEASE_RETRY_ATTEMPTS)
+                throw error;
+            await interruptibleDelay(WINDOWS_RELEASE_RETRY_DELAY_MS);
+        }
+    }
+}
 function quarantineNoReplace(source, destination) {
     emitFilesystemFault('before-lease-artifact-quarantine', source);
     try {