@lossless.org/client 0.1.0

package/dist_ts/objectstorage/internal.exactpathpurge.operations.js

@@ -0,0 +1,1069 @@
+import * as plugins from './plugins.js';
+import { ExactPathPurgeError } from './classes.exactpathpurgeerror.js';
+import { beginExactPathPurgeCapabilityOperation, beginExactPathPurgeProbeOperation, mintExactPathPurgeCapability, } from './internal.exactupload.capability.js';
+class ExactPathInventoryFailure extends Error {
+    reason;
+    constructor(reason, messageArg, optionsArg) {
+        super(messageArg, optionsArg);
+        this.reason = reason;
+        this.name = 'ExactPathInventoryFailure';
+    }
+}
+class ExactPathPurgeProbeSemanticError extends Error {
+    reason;
+    constructor(reason, messageArg, optionsArg) {
+        super(messageArg, optionsArg);
+        this.reason = reason;
+        this.name = 'ExactPathPurgeProbeSemanticError';
+    }
+}
+class ExactPathPurgeDeadlineError extends Error {
+    constructor(messageArg) {
+        super(messageArg);
+        this.name = 'ExactPathPurgeDeadlineError';
+    }
+}
+const inventoryMaximumEntries = 10_000;
+const inventoryMaximumPages = 100;
+const inventoryPageSize = 1_000;
+const purgeDefaultTimeoutMs = 30_000;
+const purgeMaximumTimeoutMs = 300_000;
+const probeTimeoutMs = 30_000;
+const reconciliationTimeoutMs = 20_000;
+const emptyCounts = () => ({
+    unversionedObjects: 0,
+    versions: 0,
+    nullVersions: 0,
+    deleteMarkers: 0,
+});
+const createEmptyEvidence = () => ({
+    initialCounts: emptyCounts(),
+    remainingCounts: emptyCounts(),
+    inventoryScansCompleted: 0,
+    verificationScansCompleted: 0,
+    pagesScanned: 0,
+    neighborEntriesObserved: 0,
+    deleteRequestsAttempted: 0,
+    deleteRequestsAcknowledged: 0,
+});
+const copyCounts = (countsArg) => ({
+    unversionedObjects: countsArg.unversionedObjects,
+    versions: countsArg.versions,
+    nullVersions: countsArg.nullVersions,
+    deleteMarkers: countsArg.deleteMarkers,
+});
+const copyEvidence = (evidenceArg) => ({
+    initialCounts: copyCounts(evidenceArg.initialCounts),
+    remainingCounts: copyCounts(evidenceArg.remainingCounts),
+    initialFingerprint: evidenceArg.initialFingerprint,
+    remainingFingerprint: evidenceArg.remainingFingerprint,
+    inventoryScansCompleted: evidenceArg.inventoryScansCompleted,
+    verificationScansCompleted: evidenceArg.verificationScansCompleted,
+    pagesScanned: evidenceArg.pagesScanned,
+    neighborEntriesObserved: evidenceArg.neighborEntriesObserved,
+    deleteRequestsAttempted: evidenceArg.deleteRequestsAttempted,
+    deleteRequestsAcknowledged: evidenceArg.deleteRequestsAcknowledged,
+    verifiedAt: evidenceArg.verifiedAt,
+});
+const getHttpStatus = (errorArg) => {
+    if (typeof errorArg !== 'object' || errorArg === null) {
+        return undefined;
+    }
+    const statusCode = errorArg.$metadata?.httpStatusCode;
+    return typeof statusCode === 'number' ? statusCode : undefined;
+};
+const isHttpStatus = (errorArg, statusCodeArg) => {
+    return getHttpStatus(errorArg) === statusCodeArg;
+};
+const requireNonEmptyString = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'string' || valueArg.length === 0) {
+        throw new ExactPathInventoryFailure('malformed-provider-response', `${fieldNameArg} must be a non-empty string.`);
+    }
+    return valueArg;
+};
+const requireSafeNonNegativeInteger = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'number' ||
+        !Number.isSafeInteger(valueArg) ||
+        valueArg < 0) {
+        throw new ExactPathInventoryFailure('malformed-provider-response', `${fieldNameArg} must be a non-negative safe integer.`);
+    }
+    return valueArg;
+};
+const requireDateMilliseconds = (valueArg, fieldNameArg) => {
+    if (!(valueArg instanceof Date) || Number.isNaN(valueArg.getTime())) {
+        throw new ExactPathInventoryFailure('malformed-provider-response', `${fieldNameArg} must be a valid Date.`);
+    }
+    return valueArg.getTime();
+};
+const requireBoolean = (valueArg, fieldNameArg) => {
+    if (typeof valueArg !== 'boolean') {
+        throw new ExactPathInventoryFailure('malformed-provider-response', `${fieldNameArg} must be a boolean.`);
+    }
+    return valueArg;
+};
+const createDeadlineSignal = (callerSignalArg, timeoutMsArg, timeoutMessageArg) => {
+    const abortController = new AbortController();
+    let timedOut = false;
+    const abortForCaller = () => {
+        abortController.abort(callerSignalArg?.reason ??
+            new Error('The exact-path purge operation was aborted.'));
+    };
+    callerSignalArg?.addEventListener('abort', abortForCaller, {
+        once: true,
+    });
+    if (callerSignalArg?.aborted) {
+        abortForCaller();
+    }
+    const deadlineTimer = setTimeout(() => {
+        timedOut = true;
+        abortController.abort(new ExactPathPurgeDeadlineError(timeoutMessageArg));
+    }, timeoutMsArg);
+    let disposed = false;
+    return {
+        signal: abortController.signal,
+        didTimeout() {
+            return timedOut;
+        },
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            clearTimeout(deadlineTimer);
+            callerSignalArg?.removeEventListener('abort', abortForCaller);
+        },
+    };
+};
+const detachedProviderSendSettlements = new WeakMap();
+const trackDetachedProviderSend = (signalArg, settlementArg) => {
+    let settlements = detachedProviderSendSettlements.get(signalArg);
+    if (!settlements) {
+        settlements = new Set();
+        detachedProviderSendSettlements.set(signalArg, settlements);
+    }
+    settlements.add(settlementArg);
+    void settlementArg.then(() => {
+        settlements?.delete(settlementArg);
+        if (settlements?.size === 0) {
+            detachedProviderSendSettlements.delete(signalArg);
+        }
+    });
+};
+const getDetachedProviderSendSettlement = (signalArg) => {
+    const settlements = detachedProviderSendSettlements.get(signalArg);
+    if (!settlements || settlements.size === 0) {
+        return undefined;
+    }
+    return Promise.allSettled([...settlements]).then(() => undefined);
+};
+const runIndependentTask = async (taskArg, timeoutMsArg, operationArg) => {
+    const abortController = new AbortController();
+    const deadlineToken = Symbol('exact-path-purge-independent-deadline');
+    let resolveDeadline;
+    const deadlineOutcome = new Promise((resolveArg) => {
+        resolveDeadline = resolveArg;
+    });
+    const deadlineTimer = setTimeout(() => {
+        const deadlineError = new ExactPathPurgeDeadlineError(`Exact-path purge reconciliation exceeded ${timeoutMsArg}ms.`);
+        abortController.abort(deadlineError);
+        resolveDeadline(deadlineToken);
+    }, timeoutMsArg);
+    let deadlineDisposed = false;
+    const disposeDeadline = () => {
+        if (deadlineDisposed) {
+            return;
+        }
+        deadlineDisposed = true;
+        clearTimeout(deadlineTimer);
+    };
+    let releaseOwnedAbort;
+    try {
+        releaseOwnedAbort = operationArg.registerOwnedIndependentAbort(abortController, disposeDeadline);
+    }
+    catch (error) {
+        abortController.abort(error);
+        disposeDeadline();
+        throw error;
+    }
+    const taskOutcome = Promise.resolve()
+        .then(() => taskArg(abortController.signal))
+        .then((valueArg) => ({
+        status: 'fulfilled',
+        value: valueArg,
+    }), (causeArg) => ({
+        status: 'rejected',
+        cause: causeArg,
+    }));
+    const settlement = taskOutcome.then(async () => {
+        await getDetachedProviderSendSettlement(abortController.signal);
+    });
+    void settlement.then(() => {
+        releaseOwnedAbort();
+    });
+    try {
+        const outcome = await Promise.race([taskOutcome, deadlineOutcome]);
+        if (outcome === deadlineToken) {
+            return {
+                succeeded: false,
+                timedOut: true,
+                settlement,
+                cause: abortController.signal.reason ??
+                    new ExactPathPurgeDeadlineError('Exact-path purge reconciliation exceeded its deadline.'),
+            };
+        }
+        if (outcome.status === 'rejected') {
+            return {
+                succeeded: false,
+                timedOut: false,
+                settlement,
+                cause: outcome.cause,
+            };
+        }
+        return {
+            succeeded: true,
+            timedOut: false,
+            settlement,
+            value: outcome.value,
+        };
+    }
+    finally {
+        disposeDeadline();
+    }
+};
+const assertSignalActive = (signalArg) => {
+    if (signalArg.aborted) {
+        throw (signalArg.reason ??
+            new Error('The exact-path purge operation was aborted.'));
+    }
+};
+const sendWithOptionalFence = async (sendArg, assertCurrentArg, signalArg) => {
+    if (signalArg) {
+        assertSignalActive(signalArg);
+    }
+    assertCurrentArg?.();
+    const sendOutcome = Promise.resolve()
+        .then(() => {
+        if (signalArg) {
+            assertSignalActive(signalArg);
+        }
+        assertCurrentArg?.();
+        return sendArg();
+    })
+        .then((valueArg) => ({
+        status: 'fulfilled',
+        value: valueArg,
+    }), (causeArg) => ({
+        status: 'rejected',
+        cause: causeArg,
+    }));
+    let outcome;
+    if (signalArg) {
+        let abortListener;
+        const abortOutcome = new Promise((resolveArg) => {
+            abortListener = () => {
+                resolveArg({
+                    status: 'aborted',
+                });
+            };
+            signalArg.addEventListener('abort', abortListener, {
+                once: true,
+            });
+            if (signalArg.aborted) {
+                abortListener();
+            }
+        });
+        outcome = await Promise.race([sendOutcome, abortOutcome]);
+        if (abortListener) {
+            signalArg.removeEventListener('abort', abortListener);
+        }
+        if (outcome.status === 'aborted') {
+            trackDetachedProviderSend(signalArg, sendOutcome.then(() => undefined));
+            assertSignalActive(signalArg);
+            throw new Error('Unreachable exact-path purge abort state.');
+        }
+    }
+    else {
+        outcome = await sendOutcome;
+    }
+    if (outcome.status === 'rejected') {
+        throw outcome.cause;
+    }
+    const output = outcome.value;
+    if (signalArg) {
+        assertSignalActive(signalArg);
+    }
+    assertCurrentArg?.();
+    return output;
+};
+const finishOperationAfterOwnedSettlements = (operationArg, additionalSettlementsArg = []) => {
+    const detachedProviderSettlement = getDetachedProviderSendSettlement(operationArg.signal);
+    const ownedSettlements = detachedProviderSettlement
+        ? [detachedProviderSettlement, ...additionalSettlementsArg]
+        : additionalSettlementsArg;
+    if (ownedSettlements.length === 0) {
+        operationArg.finish();
+        return;
+    }
+    void Promise.allSettled(ownedSettlements).then(() => {
+        operationArg.finish();
+    });
+};
+const readVersioningMode = async (clientArg, bucketNameArg, signalArg, assertCurrentArg) => {
+    const output = await sendWithOptionalFence(() => clientArg.send(new plugins.s3.GetBucketVersioningCommand({
+        Bucket: bucketNameArg,
+    }), {
+        abortSignal: signalArg,
+    }), assertCurrentArg, signalArg);
+    if (output.Status === undefined) {
+        return 'unversioned';
+    }
+    if (output.Status === 'Enabled') {
+        return 'enabled';
+    }
+    if (output.Status === 'Suspended') {
+        return 'suspended';
+    }
+    throw new ExactPathInventoryFailure('malformed-provider-response', `Unsupported bucket versioning status '${String(output.Status)}'.`);
+};
+const assertExpectedMode = (actualModeArg, expectedModeArg) => {
+    if (actualModeArg !== expectedModeArg) {
+        throw new ExactPathInventoryFailure('versioning-mode-changed', `Bucket versioning changed from '${expectedModeArg}' to '${actualModeArg}'.`);
+    }
+};
+const stableEntryToken = (entryArg) => {
+    if (entryArg.type === 'unversioned') {
+        return 'unversioned';
+    }
+    return `${entryArg.type}:${entryArg.versionId}`;
+};
+const canonicalEntry = (entryArg) => {
+    if (entryArg.type === 'unversioned') {
+        return JSON.stringify([
+            entryArg.type,
+            entryArg.etag,
+            entryArg.size,
+            entryArg.lastModifiedMs,
+        ]);
+    }
+    return JSON.stringify([
+        entryArg.type,
+        entryArg.versionId,
+        entryArg.etag ?? null,
+        entryArg.size ?? null,
+        entryArg.lastModifiedMs,
+        entryArg.isLatest,
+    ]);
+};
+const stableEntryIdentity = (entryArg) => {
+    if (entryArg.type === 'unversioned') {
+        return canonicalEntry(entryArg);
+    }
+    return JSON.stringify([
+        entryArg.type,
+        entryArg.versionId,
+        entryArg.etag ?? null,
+        entryArg.size ?? null,
+        entryArg.lastModifiedMs,
+    ]);
+};
+const createSnapshot = (modeArg, entriesArg, pagesScannedArg, neighborEntriesObservedArg) => {
+    const sortedEntries = [...entriesArg].sort((leftArg, rightArg) => {
+        return stableEntryToken(leftArg).localeCompare(stableEntryToken(rightArg));
+    });
+    const canonicalEntries = sortedEntries.map(canonicalEntry);
+    const identity = JSON.stringify([modeArg, canonicalEntries]);
+    const counts = emptyCounts();
+    for (const entry of sortedEntries) {
+        if (entry.type === 'unversioned') {
+            counts.unversionedObjects++;
+        }
+        else if (entry.type === 'delete-marker') {
+            counts.deleteMarkers++;
+        }
+        else {
+            counts.versions++;
+            if (entry.versionId === 'null') {
+                counts.nullVersions++;
+            }
+        }
+    }
+    return {
+        mode: modeArg,
+        entries: sortedEntries,
+        counts,
+        pagesScanned: pagesScannedArg,
+        neighborEntriesObserved: neighborEntriesObservedArg,
+        identity,
+        fingerprint: plugins.crypto
+            .createHash('sha256')
+            .update(identity)
+            .digest('hex'),
+    };
+};
+const validateListTruncation = (isTruncatedArg, fieldNameArg) => {
+    if (isTruncatedArg !== undefined &&
+        typeof isTruncatedArg !== 'boolean') {
+        throw new ExactPathInventoryFailure('malformed-provider-response', `${fieldNameArg} must be a boolean when present.`);
+    }
+    return isTruncatedArg === true;
+};
+const inventoryVersionedExactPath = async (clientArg, bucketNameArg, pathArg, modeArg, signalArg, assertCurrentArg) => {
+    const entries = [];
+    const exactEntryTokens = new Set();
+    let keyMarker;
+    let versionIdMarker;
+    let neighborEntriesObserved = 0;
+    let pagesScanned = 0;
+    for (let pageNumber = 1; pageNumber <= inventoryMaximumPages; pageNumber++) {
+        pagesScanned++;
+        const output = await sendWithOptionalFence(() => clientArg.send(new plugins.s3.ListObjectVersionsCommand({
+            Bucket: bucketNameArg,
+            Prefix: pathArg,
+            KeyMarker: keyMarker,
+            VersionIdMarker: versionIdMarker,
+            MaxKeys: inventoryPageSize,
+        }), {
+            abortSignal: signalArg,
+        }), assertCurrentArg, signalArg);
+        if (output.Versions !== undefined &&
+            !Array.isArray(output.Versions)) {
+            throw new ExactPathInventoryFailure('malformed-provider-response', 'ListObjectVersions Versions must be an array.');
+        }
+        if (output.DeleteMarkers !== undefined &&
+            !Array.isArray(output.DeleteMarkers)) {
+            throw new ExactPathInventoryFailure('malformed-provider-response', 'ListObjectVersions DeleteMarkers must be an array.');
+        }
+        for (const version of output.Versions ?? []) {
+            const key = requireNonEmptyString(version.Key, 'ObjectVersion Key');
+            if (!key.startsWith(pathArg)) {
+                throw new ExactPathInventoryFailure('malformed-provider-response', `ListObjectVersions returned key '${key}' outside the requested prefix.`);
+            }
+            const versionId = requireNonEmptyString(version.VersionId, `ObjectVersion '${key}' VersionId`);
+            if (key !== pathArg) {
+                neighborEntriesObserved++;
+                continue;
+            }
+            if (exactEntryTokens.has(versionId)) {
+                throw new ExactPathInventoryFailure('malformed-provider-response', `Object version '${versionId}' was returned more than once.`);
+            }
+            exactEntryTokens.add(versionId);
+            entries.push({
+                type: 'version',
+                versionId,
+                etag: requireNonEmptyString(version.ETag, `ObjectVersion '${key}' ETag`),
+                size: requireSafeNonNegativeInteger(version.Size, `ObjectVersion '${key}' Size`),
+                lastModifiedMs: requireDateMilliseconds(version.LastModified, `ObjectVersion '${key}' LastModified`),
+                isLatest: requireBoolean(version.IsLatest, `ObjectVersion '${key}' IsLatest`),
+            });
+        }
+        for (const marker of output.DeleteMarkers ?? []) {
+            const key = requireNonEmptyString(marker.Key, 'DeleteMarker Key');
+            if (!key.startsWith(pathArg)) {
+                throw new ExactPathInventoryFailure('malformed-provider-response', `ListObjectVersions returned marker key '${key}' outside the requested prefix.`);
+            }
+            const versionId = requireNonEmptyString(marker.VersionId, `DeleteMarker '${key}' VersionId`);
+            if (key !== pathArg) {
+                neighborEntriesObserved++;
+                continue;
+            }
+            if (exactEntryTokens.has(versionId)) {
+                throw new ExactPathInventoryFailure('malformed-provider-response', `Delete marker '${versionId}' was returned more than once.`);
+            }
+            exactEntryTokens.add(versionId);
+            entries.push({
+                type: 'delete-marker',
+                versionId,
+                lastModifiedMs: requireDateMilliseconds(marker.LastModified, `DeleteMarker '${key}' LastModified`),
+                isLatest: requireBoolean(marker.IsLatest, `DeleteMarker '${key}' IsLatest`),
+            });
+        }
+        if (entries.length > inventoryMaximumEntries) {
+            throw new ExactPathInventoryFailure('inventory-limit-exceeded', `Exact path contains more than ${inventoryMaximumEntries} versions and markers.`);
+        }
+        const isTruncated = validateListTruncation(output.IsTruncated, 'ListObjectVersions IsTruncated');
+        if (!isTruncated) {
+            const latestCount = entries.filter((entryArg) => entryArg.isLatest).length;
+            if (entries.length > 0 && latestCount !== 1) {
+                throw new ExactPathInventoryFailure('malformed-provider-response', `Exact version inventory must contain exactly one latest entry, received ${latestCount}.`);
+            }
+            const nullVersionCount = entries.filter((entryArg) => entryArg.type === 'version' && entryArg.versionId === 'null').length;
+            if (nullVersionCount > 1) {
+                throw new ExactPathInventoryFailure('malformed-provider-response', 'Exact version inventory contains more than one null data version.');
+            }
+            return createSnapshot(modeArg, entries, pagesScanned, neighborEntriesObserved);
+        }
+        const nextKeyMarker = requireNonEmptyString(output.NextKeyMarker, 'ListObjectVersions NextKeyMarker');
+        const nextVersionIdMarker = output.NextVersionIdMarker === undefined
+            ? undefined
+            : requireNonEmptyString(output.NextVersionIdMarker, 'ListObjectVersions NextVersionIdMarker');
+        if (nextKeyMarker === keyMarker &&
+            nextVersionIdMarker === versionIdMarker) {
+            throw new ExactPathInventoryFailure('malformed-provider-response', 'ListObjectVersions pagination did not advance.');
+        }
+        keyMarker = nextKeyMarker;
+        versionIdMarker = nextVersionIdMarker;
+    }
+    throw new ExactPathInventoryFailure('inventory-limit-exceeded', `Exact version inventory exceeded ${inventoryMaximumPages} pages.`);
+};
+const inventoryUnversionedExactPath = async (clientArg, bucketNameArg, pathArg, signalArg, assertCurrentArg) => {
+    let exactEntry;
+    let continuationToken;
+    let neighborEntriesObserved = 0;
+    let pagesScanned = 0;
+    for (let pageNumber = 1; pageNumber <= inventoryMaximumPages; pageNumber++) {
+        pagesScanned++;
+        const output = await sendWithOptionalFence(() => clientArg.send(new plugins.s3.ListObjectsV2Command({
+            Bucket: bucketNameArg,
+            Prefix: pathArg,
+            ContinuationToken: continuationToken,
+            MaxKeys: inventoryPageSize,
+        }), {
+            abortSignal: signalArg,
+        }), assertCurrentArg, signalArg);
+        if (output.Contents !== undefined && !Array.isArray(output.Contents)) {
+            throw new ExactPathInventoryFailure('malformed-provider-response', 'ListObjectsV2 Contents must be an array.');
+        }
+        for (const object of output.Contents ?? []) {
+            const key = requireNonEmptyString(object.Key, 'Object Key');
+            if (!key.startsWith(pathArg)) {
+                throw new ExactPathInventoryFailure('malformed-provider-response', `ListObjectsV2 returned key '${key}' outside the requested prefix.`);
+            }
+            if (key !== pathArg) {
+                neighborEntriesObserved++;
+                continue;
+            }
+            if (exactEntry) {
+                throw new ExactPathInventoryFailure('malformed-provider-response', 'ListObjectsV2 returned the exact unversioned key more than once.');
+            }
+            exactEntry = {
+                type: 'unversioned',
+                etag: requireNonEmptyString(object.ETag, `Object '${key}' ETag`),
+                size: requireSafeNonNegativeInteger(object.Size, `Object '${key}' Size`),
+                lastModifiedMs: requireDateMilliseconds(object.LastModified, `Object '${key}' LastModified`),
+            };
+        }
+        const isTruncated = validateListTruncation(output.IsTruncated, 'ListObjectsV2 IsTruncated');
+        if (!isTruncated) {
+            return createSnapshot('unversioned', exactEntry ? [exactEntry] : [], pagesScanned, neighborEntriesObserved);
+        }
+        const nextContinuationToken = requireNonEmptyString(output.NextContinuationToken, 'ListObjectsV2 NextContinuationToken');
+        if (nextContinuationToken === continuationToken) {
+            throw new ExactPathInventoryFailure('malformed-provider-response', 'ListObjectsV2 pagination did not advance.');
+        }
+        continuationToken = nextContinuationToken;
+    }
+    throw new ExactPathInventoryFailure('inventory-limit-exceeded', `Exact object inventory exceeded ${inventoryMaximumPages} pages.`);
+};
+const inventoryExactPath = (clientArg, bucketNameArg, pathArg, modeArg, signalArg, assertCurrentArg) => {
+    if (modeArg === 'unversioned') {
+        return inventoryUnversionedExactPath(clientArg, bucketNameArg, pathArg, signalArg, assertCurrentArg);
+    }
+    return inventoryVersionedExactPath(clientArg, bucketNameArg, pathArg, modeArg, signalArg, assertCurrentArg);
+};
+const assertSnapshotUnchanged = (initialSnapshotArg, currentSnapshotArg) => {
+    if (initialSnapshotArg.mode !== currentSnapshotArg.mode ||
+        initialSnapshotArg.identity !== currentSnapshotArg.identity) {
+        throw new ExactPathInventoryFailure('concurrent-recreation', 'The exact path changed between its two pre-delete inventories.');
+    }
+};
+const deleteEntry = async (clientArg, bucketNameArg, pathArg, entryArg, signalArg, assertCurrentArg) => {
+    await sendWithOptionalFence(() => clientArg.send(new plugins.s3.DeleteObjectCommand({
+        Bucket: bucketNameArg,
+        Key: pathArg,
+        VersionId: entryArg.type === 'unversioned'
+            ? undefined
+            : entryArg.versionId,
+        IfMatch: entryArg.type === 'delete-marker'
+            ? undefined
+            : entryArg.etag,
+    }), {
+        abortSignal: signalArg,
+    }), assertCurrentArg, signalArg);
+};
+const snapshotIsEmpty = (snapshotArg) => {
+    return snapshotArg.entries.length === 0;
+};
+const classifyRemainingSnapshot = (initialSnapshotArg, remainingSnapshotArg) => {
+    if (snapshotIsEmpty(remainingSnapshotArg)) {
+        return 'empty';
+    }
+    const initialEntries = new Map(initialSnapshotArg.entries.map((entryArg) => [
+        stableEntryToken(entryArg),
+        stableEntryIdentity(entryArg),
+    ]));
+    for (const remainingEntry of remainingSnapshotArg.entries) {
+        const initialIdentity = initialEntries.get(stableEntryToken(remainingEntry));
+        if (initialIdentity === undefined ||
+            initialIdentity !== stableEntryIdentity(remainingEntry)) {
+            return 'concurrent-recreation';
+        }
+    }
+    return 'captured-remains';
+};
+const verifyExactPathEmpty = async (clientArg, bucketNameArg, pathArg, expectedModeArg, signalArg, assertCurrentArg) => {
+    let pagesScanned = 0;
+    let neighborEntriesObserved = 0;
+    let verificationScansCompleted = 0;
+    let remainingSnapshot = createSnapshot(expectedModeArg, [], 0, 0);
+    for (let scanNumber = 1; scanNumber <= 2; scanNumber++) {
+        const actualMode = await readVersioningMode(clientArg, bucketNameArg, signalArg, assertCurrentArg);
+        assertExpectedMode(actualMode, expectedModeArg);
+        remainingSnapshot = await inventoryExactPath(clientArg, bucketNameArg, pathArg, expectedModeArg, signalArg, assertCurrentArg);
+        verificationScansCompleted++;
+        pagesScanned += remainingSnapshot.pagesScanned;
+        neighborEntriesObserved +=
+            remainingSnapshot.neighborEntriesObserved;
+        if (!snapshotIsEmpty(remainingSnapshot)) {
+            return {
+                remainingSnapshot,
+                verificationScansCompleted,
+                pagesScanned,
+                neighborEntriesObserved,
+            };
+        }
+    }
+    return {
+        remainingSnapshot,
+        verificationScansCompleted,
+        pagesScanned,
+        neighborEntriesObserved,
+        verifiedAt: new Date().toISOString(),
+    };
+};
+const createPurgeError = (phaseArg, reasonArg, pathArg, evidenceArg, causeArg, versioningModeArg) => {
+    return new ExactPathPurgeError({
+        phase: phaseArg,
+        reason: reasonArg,
+        destinationPath: pathArg,
+        versioningMode: versioningModeArg,
+        evidence: copyEvidence(evidenceArg),
+    }, causeArg);
+};
+const failureReasonForInventoryError = (errorArg) => {
+    if (errorArg instanceof ExactPathInventoryFailure) {
+        return errorArg.reason;
+    }
+    return 'unavailable';
+};
+const cleanupProbePath = async (clientArg, bucketNameArg, pathArg, expectedModeArg, signalArg, assertCurrentArg) => {
+    const actualMode = await readVersioningMode(clientArg, bucketNameArg, signalArg, assertCurrentArg);
+    assertExpectedMode(actualMode, expectedModeArg);
+    const snapshot = await inventoryExactPath(clientArg, bucketNameArg, pathArg, expectedModeArg, signalArg, assertCurrentArg);
+    for (const entry of snapshot.entries) {
+        await sendWithOptionalFence(() => clientArg.send(new plugins.s3.DeleteObjectCommand({
+            Bucket: bucketNameArg,
+            Key: pathArg,
+            VersionId: entry.type === 'unversioned' ? undefined : entry.versionId,
+        }), {
+            abortSignal: signalArg,
+        }), assertCurrentArg, signalArg);
+    }
+    const verification = await verifyExactPathEmpty(clientArg, bucketNameArg, pathArg, expectedModeArg, signalArg, assertCurrentArg);
+    if (!snapshotIsEmpty(verification.remainingSnapshot)) {
+        throw new Error('The exact-path purge probe key remains after cleanup.');
+    }
+};
+const headProbeEntry = async (operationArg, pathArg, entryArg) => {
+    const output = await sendWithOptionalFence(() => operationArg.client.send(new plugins.s3.HeadObjectCommand({
+        Bucket: operationArg.bucketName,
+        Key: pathArg,
+        VersionId: entryArg.type === 'unversioned'
+            ? undefined
+            : entryArg.versionId,
+    }), {
+        abortSignal: operationArg.signal,
+    }), () => operationArg.assertCurrent(), operationArg.signal);
+    return requireNonEmptyString(output.ETag, 'HeadObject ETag');
+};
+const assertProbeEntryAbsentByHead = async (operationArg, pathArg, entryArg) => {
+    try {
+        await sendWithOptionalFence(() => operationArg.client.send(new plugins.s3.HeadObjectCommand({
+            Bucket: operationArg.bucketName,
+            Key: pathArg,
+            VersionId: entryArg.type === 'unversioned'
+                ? undefined
+                : entryArg.versionId,
+        }), {
+            abortSignal: operationArg.signal,
+        }), () => operationArg.assertCurrent(), operationArg.signal);
+    }
+    catch (error) {
+        operationArg.assertCurrent();
+        if (isHttpStatus(error, 404)) {
+            return;
+        }
+        throw error;
+    }
+    throw new ExactPathPurgeProbeSemanticError('conditional-delete-not-enforced', 'The correctly deleted probe object is still readable by exact identity.');
+};
+const getSingleProbeDataEntry = (snapshotArg) => {
+    if (snapshotArg.entries.length !== 1 ||
+        snapshotArg.entries[0].type === 'delete-marker') {
+        throw new ExactPathPurgeProbeSemanticError('conditional-delete-not-enforced', 'The purge probe object did not produce exactly one data entry.');
+    }
+    const entry = snapshotArg.entries[0];
+    if (snapshotArg.mode === 'enabled' &&
+        (entry.type === 'unversioned' ||
+            entry.versionId === 'null')) {
+        throw new ExactPathPurgeProbeSemanticError('conditional-delete-not-enforced', 'Enabled versioning did not return a concrete object VersionId.');
+    }
+    if (snapshotArg.mode === 'suspended' &&
+        (entry.type === 'unversioned' ||
+            entry.versionId !== 'null')) {
+        throw new ExactPathPurgeProbeSemanticError('conditional-delete-not-enforced', 'Suspended versioning did not return the current null data version.');
+    }
+    if (snapshotArg.mode === 'unversioned' &&
+        entry.type !== 'unversioned') {
+        throw new ExactPathPurgeProbeSemanticError('conditional-delete-not-enforced', 'Unversioned storage returned a versioned probe entry.');
+    }
+    return entry;
+};
+export const probeExactPathPurgeCapability = async (bucketRefArg, optionsArg) => {
+    const timeoutMs = optionsArg.timeoutMs ?? probeTimeoutMs;
+    if (!Number.isSafeInteger(timeoutMs) ||
+        timeoutMs <= 0 ||
+        timeoutMs > probeTimeoutMs) {
+        throw new TypeError(`Exact-path purge probe timeoutMs must be a positive safe integer no greater than ${probeTimeoutMs}.`);
+    }
+    const deadlineSignal = createDeadlineSignal(optionsArg.signal, timeoutMs, `Exact-path purge capability probe exceeded ${timeoutMs}ms.`);
+    let operation;
+    try {
+        operation = beginExactPathPurgeProbeOperation(bucketRefArg, deadlineSignal.signal);
+    }
+    catch (error) {
+        deadlineSignal.dispose();
+        return {
+            supported: false,
+            reason: deadlineSignal.didTimeout() ? 'timeout' : 'unavailable',
+            cause: error,
+        };
+    }
+    const probePath = `.smartbucket-probes/exact-path-purge-v1/${plugins.smartunique.uuid4()}`;
+    let versioningMode;
+    let failureReason;
+    let failureCause;
+    try {
+        versioningMode = await readVersioningMode(operation.client, operation.bucketName, operation.signal, () => operation.assertCurrent());
+        const putProbeObject = async () => {
+            await sendWithOptionalFence(() => operation.client.send(new plugins.s3.PutObjectCommand({
+                Bucket: operation.bucketName,
+                Key: probePath,
+                Body: new Uint8Array([1]),
+                ContentLength: 1,
+                Metadata: {
+                    'smartbucket-probe': 'exact-path-purge-v1',
+                },
+            }), {
+                abortSignal: operation.signal,
+            }), () => operation.assertCurrent(), operation.signal);
+            const actualMode = await readVersioningMode(operation.client, operation.bucketName, operation.signal, () => operation.assertCurrent());
+            if (actualMode !== versioningMode) {
+                throw new ExactPathPurgeProbeSemanticError('versioning-mode-changed', 'Bucket versioning changed during the purge probe.');
+            }
+            return inventoryExactPath(operation.client, operation.bucketName, probePath, versioningMode, operation.signal, () => operation.assertCurrent());
+        };
+        const initialSnapshot = await putProbeObject();
+        const initialEntry = getSingleProbeDataEntry(initialSnapshot);
+        const impossibleEtag = `"smartbucket-never-match-${plugins.smartunique.uuid4()}"`;
+        try {
+            await sendWithOptionalFence(() => operation.client.send(new plugins.s3.DeleteObjectCommand({
+                Bucket: operation.bucketName,
+                Key: probePath,
+                VersionId: initialEntry.type === 'unversioned'
+                    ? undefined
+                    : initialEntry.versionId,
+                IfMatch: impossibleEtag,
+            }), {
+                abortSignal: operation.signal,
+            }), () => operation.assertCurrent(), operation.signal);
+            throw new ExactPathPurgeProbeSemanticError('conditional-delete-not-enforced', 'The provider accepted a mismatched conditional delete.');
+        }
+        catch (error) {
+            if (error instanceof ExactPathPurgeProbeSemanticError) {
+                throw error;
+            }
+            operation.assertCurrent();
+            if (!isHttpStatus(error, 412)) {
+                throw error;
+            }
+        }
+        const retainedEtag = await headProbeEntry(operation, probePath, initialEntry);
+        if (retainedEtag !== initialEntry.etag) {
+            throw new ExactPathPurgeProbeSemanticError('conditional-delete-not-enforced', 'The mismatched conditional delete changed the probe object.');
+        }
+        let correctDeleteCause;
+        try {
+            await deleteEntry(operation.client, operation.bucketName, probePath, initialEntry, operation.signal, () => operation.assertCurrent());
+        }
+        catch (error) {
+            correctDeleteCause = error;
+        }
+        await assertProbeEntryAbsentByHead(operation, probePath, initialEntry);
+        const afterCorrectDelete = await inventoryExactPath(operation.client, operation.bucketName, probePath, versioningMode, operation.signal, () => operation.assertCurrent());
+        if (!snapshotIsEmpty(afterCorrectDelete)) {
+            throw new ExactPathPurgeProbeSemanticError('conditional-delete-not-enforced', 'The correctly matched conditional delete did not remove the probe object.', {
+                cause: correctDeleteCause,
+            });
+        }
+        if (versioningMode !== 'unversioned') {
+            const markerSourceSnapshot = await putProbeObject();
+            getSingleProbeDataEntry(markerSourceSnapshot);
+            await sendWithOptionalFence(() => operation.client.send(new plugins.s3.DeleteObjectCommand({
+                Bucket: operation.bucketName,
+                Key: probePath,
+            }), {
+                abortSignal: operation.signal,
+            }), () => operation.assertCurrent(), operation.signal);
+            const markerSnapshot = await inventoryExactPath(operation.client, operation.bucketName, probePath, versioningMode, operation.signal, () => operation.assertCurrent());
+            const marker = markerSnapshot.entries.find((entryArg) => entryArg.type === 'delete-marker' && entryArg.isLatest);
+            if (!marker) {
+                throw new ExactPathPurgeProbeSemanticError('conditional-delete-not-enforced', 'The provider did not expose the expected delete marker.');
+            }
+            await deleteEntry(operation.client, operation.bucketName, probePath, marker, operation.signal, () => operation.assertCurrent());
+            const dataAfterMarker = await inventoryExactPath(operation.client, operation.bucketName, probePath, versioningMode, operation.signal, () => operation.assertCurrent());
+            for (const entry of dataAfterMarker.entries) {
+                await deleteEntry(operation.client, operation.bucketName, probePath, entry, operation.signal, () => operation.assertCurrent());
+            }
+            const afterMarkerCleanup = await inventoryExactPath(operation.client, operation.bucketName, probePath, versioningMode, operation.signal, () => operation.assertCurrent());
+            if (!snapshotIsEmpty(afterMarkerCleanup)) {
+                throw new ExactPathPurgeProbeSemanticError('conditional-delete-not-enforced', 'Exact delete-marker removal did not empty the probe path.');
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof ExactPathPurgeProbeSemanticError) {
+            failureReason = error.reason;
+        }
+        else if (deadlineSignal.didTimeout()) {
+            failureReason = 'timeout';
+            failureCause = error;
+        }
+        else if (operation.signal.aborted) {
+            failureReason = 'aborted';
+            failureCause = operation.signal.reason;
+        }
+        else {
+            failureReason = 'unavailable';
+            failureCause = error;
+        }
+    }
+    deadlineSignal.dispose();
+    const primaryProviderSettlement = getDetachedProviderSendSettlement(operation.signal);
+    if (primaryProviderSettlement) {
+        const deferredCleanup = primaryProviderSettlement
+            .then(async () => {
+            try {
+                operation.assertLifecycleCurrent();
+                if (versioningMode === undefined) {
+                    return;
+                }
+                const cleanupResult = await runIndependentTask((signalArg) => cleanupProbePath(operation.client, operation.bucketName, probePath, versioningMode, signalArg, () => operation.assertLifecycleCurrent()), reconciliationTimeoutMs, operation);
+                await cleanupResult.settlement;
+            }
+            catch {
+                // Forced lifecycle detach makes deferred cleanup indeterminate.
+            }
+        })
+            .then(() => undefined, () => undefined);
+        finishOperationAfterOwnedSettlements(operation, [deferredCleanup]);
+        return {
+            supported: false,
+            reason: failureReason ??
+                (deadlineSignal.didTimeout()
+                    ? 'timeout'
+                    : operation.signal.aborted
+                        ? 'aborted'
+                        : 'unavailable'),
+            cause: failureCause ?? operation.signal.reason,
+        };
+    }
+    const cleanupResult = versioningMode === undefined
+        ? {
+            succeeded: true,
+            timedOut: false,
+            settlement: Promise.resolve(),
+        }
+        : await runIndependentTask((signalArg) => cleanupProbePath(operation.client, operation.bucketName, probePath, versioningMode, signalArg, () => operation.assertLifecycleCurrent()), reconciliationTimeoutMs, operation);
+    try {
+        if (!cleanupResult.succeeded) {
+            return {
+                supported: false,
+                reason: 'cleanup-failed',
+                cause: cleanupResult.cause,
+            };
+        }
+        if (failureReason) {
+            return {
+                supported: false,
+                reason: failureReason,
+                cause: failureCause,
+            };
+        }
+        return {
+            supported: true,
+            capability: mintExactPathPurgeCapability(bucketRefArg, operation, versioningMode),
+            versioningMode: versioningMode,
+        };
+    }
+    catch (error) {
+        return {
+            supported: false,
+            reason: deadlineSignal.didTimeout()
+                ? 'timeout'
+                : operation.signal.aborted
+                    ? 'aborted'
+                    : 'unavailable',
+            cause: error,
+        };
+    }
+    finally {
+        if (cleanupResult.timedOut) {
+            finishOperationAfterOwnedSettlements(operation, [
+                cleanupResult.settlement,
+            ]);
+        }
+        else {
+            finishOperationAfterOwnedSettlements(operation);
+        }
+    }
+};
+export const purgeExactPath = async (bucketRefArg, optionsArg) => {
+    if (typeof optionsArg.path !== 'string' || optionsArg.path.length === 0) {
+        throw new TypeError('path must be a non-empty string.');
+    }
+    const timeoutMs = optionsArg.timeoutMs ?? purgeDefaultTimeoutMs;
+    if (!Number.isSafeInteger(timeoutMs) ||
+        timeoutMs <= 0 ||
+        timeoutMs > purgeMaximumTimeoutMs) {
+        throw new TypeError(`Exact-path purge timeoutMs must be a positive safe integer no greater than ${purgeMaximumTimeoutMs}.`);
+    }
+    const evidence = createEmptyEvidence();
+    const deadlineSignal = createDeadlineSignal(optionsArg.signal, timeoutMs, `Exact-path purge exceeded ${timeoutMs}ms.`);
+    let operation;
+    try {
+        operation = beginExactPathPurgeCapabilityOperation(bucketRefArg, optionsArg.capability, deadlineSignal.signal);
+    }
+    catch (error) {
+        deadlineSignal.dispose();
+        throw createPurgeError('capability', deadlineSignal.didTimeout() ? 'timeout' : 'unavailable', optionsArg.path, evidence, error);
+    }
+    let initialSnapshot;
+    try {
+        const initialMode = await readVersioningMode(operation.client, operation.bucketName, operation.signal, () => operation.assertCurrent());
+        assertExpectedMode(initialMode, operation.versioningMode);
+        initialSnapshot = await inventoryExactPath(operation.client, operation.bucketName, optionsArg.path, operation.versioningMode, operation.signal, () => operation.assertCurrent());
+        evidence.inventoryScansCompleted++;
+        evidence.pagesScanned += initialSnapshot.pagesScanned;
+        evidence.neighborEntriesObserved +=
+            initialSnapshot.neighborEntriesObserved;
+        evidence.initialCounts = copyCounts(initialSnapshot.counts);
+        evidence.initialFingerprint = initialSnapshot.fingerprint;
+        const consistencyMode = await readVersioningMode(operation.client, operation.bucketName, operation.signal, () => operation.assertCurrent());
+        assertExpectedMode(consistencyMode, operation.versioningMode);
+        const consistencySnapshot = await inventoryExactPath(operation.client, operation.bucketName, optionsArg.path, operation.versioningMode, operation.signal, () => operation.assertCurrent());
+        evidence.inventoryScansCompleted++;
+        evidence.pagesScanned += consistencySnapshot.pagesScanned;
+        evidence.neighborEntriesObserved +=
+            consistencySnapshot.neighborEntriesObserved;
+        assertSnapshotUnchanged(initialSnapshot, consistencySnapshot);
+        if (snapshotIsEmpty(initialSnapshot)) {
+            evidence.remainingCounts = copyCounts(consistencySnapshot.counts);
+            evidence.remainingFingerprint = consistencySnapshot.fingerprint;
+            evidence.verificationScansCompleted = 2;
+            evidence.verifiedAt = new Date().toISOString();
+            deadlineSignal.dispose();
+            operation.finish();
+            return {
+                destinationPath: optionsArg.path,
+                status: 'already-absent',
+                versioningMode: operation.versioningMode,
+                purgedCounts: copyCounts(initialSnapshot.counts),
+                evidence: copyEvidence(evidence),
+            };
+        }
+    }
+    catch (error) {
+        const phase = error instanceof ExactPathInventoryFailure &&
+            error.message.includes('changed between')
+            ? 'consistency'
+            : 'inventory';
+        const reason = deadlineSignal.didTimeout()
+            ? 'timeout'
+            : operation.signal.aborted
+                ? 'aborted'
+                : failureReasonForInventoryError(error);
+        deadlineSignal.dispose();
+        finishOperationAfterOwnedSettlements(operation);
+        throw createPurgeError(phase, reason, optionsArg.path, evidence, error, operation.versioningMode);
+    }
+    let deleteCause;
+    for (const entry of initialSnapshot.entries) {
+        evidence.deleteRequestsAttempted++;
+        try {
+            await deleteEntry(operation.client, operation.bucketName, optionsArg.path, entry, operation.signal, () => operation.assertCurrent());
+            evidence.deleteRequestsAcknowledged++;
+        }
+        catch (error) {
+            deleteCause = error;
+            break;
+        }
+    }
+    deadlineSignal.dispose();
+    const primaryProviderSettlement = getDetachedProviderSendSettlement(operation.signal);
+    if (primaryProviderSettlement) {
+        finishOperationAfterOwnedSettlements(operation);
+        throw createPurgeError('delete', deadlineSignal.didTimeout()
+            ? 'timeout'
+            : operation.signal.aborted
+                ? 'aborted'
+                : 'delete-unverified', optionsArg.path, evidence, deleteCause ?? operation.signal.reason, operation.versioningMode);
+    }
+    const verificationResult = await runIndependentTask((signalArg) => verifyExactPathEmpty(operation.client, operation.bucketName, optionsArg.path, operation.versioningMode, signalArg, () => operation.assertLifecycleCurrent()), reconciliationTimeoutMs, operation);
+    try {
+        if (!verificationResult.succeeded || !verificationResult.value) {
+            throw createPurgeError('verification', 'verification-ambiguous', optionsArg.path, evidence, verificationResult.cause, operation.versioningMode);
+        }
+        const verification = verificationResult.value;
+        evidence.verificationScansCompleted =
+            verification.verificationScansCompleted;
+        evidence.pagesScanned += verification.pagesScanned;
+        evidence.neighborEntriesObserved +=
+            verification.neighborEntriesObserved;
+        evidence.remainingCounts = copyCounts(verification.remainingSnapshot.counts);
+        evidence.remainingFingerprint =
+            verification.remainingSnapshot.fingerprint;
+        evidence.verifiedAt = verification.verifiedAt;
+        const remainingClassification = classifyRemainingSnapshot(initialSnapshot, verification.remainingSnapshot);
+        if (remainingClassification === 'concurrent-recreation' ||
+            isHttpStatus(deleteCause, 409) ||
+            isHttpStatus(deleteCause, 412)) {
+            throw createPurgeError('verification', 'concurrent-recreation', optionsArg.path, evidence, deleteCause, operation.versioningMode);
+        }
+        if (remainingClassification === 'captured-remains') {
+            const reason = deadlineSignal.didTimeout()
+                ? 'timeout'
+                : operation.signal.aborted
+                    ? 'aborted'
+                    : 'delete-unverified';
+            throw createPurgeError('delete', reason, optionsArg.path, evidence, deleteCause, operation.versioningMode);
+        }
+        return {
+            destinationPath: optionsArg.path,
+            status: 'purged',
+            versioningMode: operation.versioningMode,
+            purgedCounts: copyCounts(initialSnapshot.counts),
+            evidence: copyEvidence(evidence),
+        };
+    }
+    finally {
+        if (verificationResult.timedOut) {
+            finishOperationAfterOwnedSettlements(operation, [
+                verificationResult.settlement,
+            ]);
+        }
+        else {
+            finishOperationAfterOwnedSettlements(operation);
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"internal.exactpathpurge.operations.js","sourceRoot":"","sources":["../../ts/objectstorage/internal.exactpathpurge.operations.ts"],"names":[],"mappings":"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"}