@lossless.org/client 0.1.0

package/dist_ts/objectstorage/classes.bucket.js

@@ -0,0 +1,939 @@
+// classes.bucket.ts
+import * as plugins from './plugins.js';
+import * as helpers from './helpers.js';
+import * as interfaces from './interfaces.js';
+import { SmartBucket } from './classes.smartbucket.js';
+import { Directory } from './classes.directory.js';
+import { File } from './classes.file.js';
+import { Trash } from './classes.trash.js';
+import { ListCursor } from './classes.listcursor.js';
+import { BucketWatcher } from './classes.watcher.js';
+import { fastPutStreamExact as fastPutStreamExactOperation, probeExactUploadCapability as probeExactUploadCapabilityOperation, } from './internal.exactupload.operations.js';
+import { probeExactPathPurgeCapability as probeExactPathPurgeCapabilityOperation, purgeExactPath as purgeExactPathOperation, } from './internal.exactpathpurge.operations.js';
+import { beginBasicBucketOperation } from './internal.exactupload.capability.js';
+const compareUtf8ObjectKeys = (leftArg, rightArg) => Buffer.compare(Buffer.from(leftArg, 'utf8'), Buffer.from(rightArg, 'utf8'));
+const destroyReadableAndWaitForSettlement = async (readableArg) => {
+    let removeFinishedListeners = () => { };
+    const settlement = new Promise((resolveArg) => {
+        removeFinishedListeners = plugins.stream.finished(readableArg, { readable: true, writable: false }, () => resolveArg(true));
+    });
+    readableArg.destroy();
+    let settlementDeadline;
+    let settled = false;
+    try {
+        settled = await Promise.race([
+            settlement,
+            new Promise((resolveArg) => {
+                settlementDeadline = setTimeout(() => resolveArg(false), 5_000);
+            }),
+        ]);
+    }
+    finally {
+        if (settlementDeadline) {
+            clearTimeout(settlementDeadline);
+        }
+        removeFinishedListeners();
+    }
+    if (!settled && !readableArg.closed) {
+        const onLateError = () => {
+            readableArg.removeListener('close', onLateClose);
+        };
+        const onLateClose = () => {
+            readableArg.removeListener('error', onLateError);
+        };
+        readableArg.once('error', onLateError);
+        readableArg.once('close', onLateClose);
+    }
+};
+/**
+ * The bucket class exposes the basic functionality of a bucket.
+ * The functions of the bucket alone are enough to
+ * operate on blobs of data in an S3-compatible object store.
+ */
+export class Bucket {
+    static async getBucketByName(smartbucketRef, bucketNameArg) {
+        const command = new plugins.s3.ListBucketsCommand({});
+        const buckets = await smartbucketRef.storageClient.send(command);
+        const foundBucket = buckets.Buckets.find((bucket) => bucket.Name === bucketNameArg);
+        if (foundBucket) {
+            console.log(`bucket with name ${bucketNameArg} exists.`);
+            console.log(`Taking this as base for new Bucket instance`);
+            return new this(smartbucketRef, bucketNameArg);
+        }
+        else {
+            throw new Error(`Bucket '${bucketNameArg}' not found.`);
+        }
+    }
+    static async createBucketByName(smartbucketRef, bucketName) {
+        const command = new plugins.s3.CreateBucketCommand({ Bucket: bucketName });
+        await smartbucketRef.storageClient.send(command);
+        return new Bucket(smartbucketRef, bucketName);
+    }
+    static async removeBucketByName(smartbucketRef, bucketName) {
+        const command = new plugins.s3.DeleteBucketCommand({ Bucket: bucketName });
+        await smartbucketRef.storageClient.send(command);
+    }
+    smartbucketRef;
+    name;
+    constructor(smartbucketRef, bucketName) {
+        this.smartbucketRef = smartbucketRef;
+        this.name = bucketName;
+    }
+    /**
+     * Returns the underlying AWS SDK v3 S3Client for this bucket.
+     *
+     * Use this when you need to perform operations smartbucket doesn't
+     * wrap directly (e.g. lifecycle policies, bucket tagging, multipart
+     * upload control, object-lock, inventory config, etc.).
+     *
+     * The returned client is shared with the parent SmartBucket — do not
+     * call `.destroy()` on it.
+     */
+    getStorageClient() {
+        return this.smartbucketRef.storageClient;
+    }
+    /**
+     * Performs a live, side-effectful provider probe for the conditional S3
+     * semantics required by fastPutStreamExact().
+     *
+     * Probe objects and multipart uploads use unique private keys and are removed
+     * before a capability is returned. A capability becomes stale when the
+     * Bucket object, bucket name, parent SmartBucket, S3 client, or SmartBucket
+     * lifecycle generation changes.
+     */
+    probeExactUploadCapability(optionsArg = {}) {
+        return probeExactUploadCapabilityOperation(this, optionsArg);
+    }
+    /**
+     * Performs a live provider probe for exact conditional deletion,
+     * version-specific deletion, delete-marker removal, and verified cleanup.
+     */
+    probeExactPathPurgeCapability(optionsArg = {}) {
+        return probeExactPathPurgeCapabilityOperation(this, optionsArg);
+    }
+    /**
+     * gets the base directory of the bucket
+     */
+    async getBaseDirectory() {
+        return new Directory(this, null, '');
+    }
+    /**
+     * gets the trash directory
+     */
+    async getTrash() {
+        const trash = new Trash(this);
+        return trash;
+    }
+    async getDirectoryFromPath(pathDescriptorArg) {
+        if (!pathDescriptorArg.path && !pathDescriptorArg.directory) {
+            return this.getBaseDirectory();
+        }
+        const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptorArg);
+        const baseDirectory = await this.getBaseDirectory();
+        return await baseDirectory.getSubDirectoryByName(checkPath, {
+            getEmptyDirectory: true,
+        });
+    }
+    // ===============
+    // Fast Operations
+    // ===============
+    /**
+     * store file
+     */
+    async fastPut(optionsArg) {
+        try {
+            const reducedPath = await helpers.reducePathDescriptorToPath(optionsArg);
+            const exists = await this.fastExists({ path: reducedPath });
+            if (exists && !optionsArg.overwrite) {
+                throw new Error(`Object already exists at path '${reducedPath}' in bucket '${this.name}'. ` +
+                    `Set overwrite:true to replace it.`);
+            }
+            else if (exists && optionsArg.overwrite) {
+                console.log(`Overwriting existing object at path '${reducedPath}' in bucket '${this.name}'.`);
+            }
+            else {
+                console.log(`Creating new object at path '${reducedPath}' in bucket '${this.name}'.`);
+            }
+            const command = new plugins.s3.PutObjectCommand({
+                Bucket: this.name,
+                Key: reducedPath,
+                Body: optionsArg.contents,
+            });
+            await this.smartbucketRef.storageClient.send(command);
+            console.log(`Object '${reducedPath}' has been successfully stored in bucket '${this.name}'.`);
+            const parsedPath = plugins.path.parse(reducedPath);
+            return new File({
+                directoryRefArg: await this.getDirectoryFromPath({
+                    path: parsedPath.dir,
+                }),
+                fileName: parsedPath.base,
+            });
+        }
+        catch (error) {
+            console.error(`Error storing object at path '${optionsArg.path}' in bucket '${this.name}':`, error);
+            throw error;
+        }
+    }
+    /**
+     * get file
+     */
+    async fastGet(optionsArg) {
+        const source = await this.fastGetStream(optionsArg);
+        const chunks = [];
+        try {
+            for await (const chunk of source)
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            return Buffer.concat(chunks);
+        }
+        finally {
+            source.destroy();
+        }
+    }
+    /**
+     * good when time to first byte is important
+     * and multiple subscribers are expected
+     * @param optionsArg
+     * @returns
+     */
+    async fastGetReplaySubject(optionsArg) {
+        const command = new plugins.s3.GetObjectCommand({
+            Bucket: this.name,
+            Key: optionsArg.path,
+        });
+        const response = await this.smartbucketRef.storageClient.send(command);
+        const replaySubject = new plugins.smartrx.rxjs.ReplaySubject();
+        // Convert the stream to a format that supports piping
+        const stream = response.Body; // SdkStreamMixin includes readable stream
+        if (typeof stream.pipe === 'function') {
+            const duplexStream = new plugins.smartstream.SmartDuplex({
+                writeFunction: async (chunk) => {
+                    replaySubject.next(chunk);
+                    return;
+                },
+                finalFunction: async (cb) => {
+                    replaySubject.complete();
+                    return;
+                },
+            });
+            stream.pipe(duplexStream);
+        }
+        return replaySubject;
+    }
+    async fastGetStream(optionsArg, typeArg = 'nodestream') {
+        const operation = beginBasicBucketOperation(this, optionsArg.signal);
+        const disposeBody = async (responseBodyArg) => {
+            try {
+                if (responseBodyArg instanceof plugins.stream.Readable) {
+                    await destroyReadableAndWaitForSettlement(responseBodyArg);
+                }
+                else if (typeof ReadableStream !== 'undefined'
+                    && responseBodyArg instanceof ReadableStream) {
+                    await responseBodyArg.cancel();
+                }
+                else if (typeof responseBodyArg === 'object'
+                    && responseBodyArg !== null
+                    && typeof responseBodyArg.destroy === 'function') {
+                    responseBodyArg.destroy();
+                }
+                else if (typeof responseBodyArg === 'object'
+                    && responseBodyArg !== null
+                    && typeof responseBodyArg.cancel === 'function') {
+                    await responseBodyArg.cancel();
+                }
+            }
+            catch {
+                // Preserve the primary response-body or conversion failure.
+            }
+        };
+        let response;
+        try {
+            response = await operation.runProvider(() => operation.client.send(new plugins.s3.GetObjectCommand({
+                Bucket: operation.bucketName,
+                Key: optionsArg.path,
+            }), { abortSignal: operation.signal }), {
+                disposeLateResult: async (lateResponseArg) => {
+                    await disposeBody(lateResponseArg.Body);
+                },
+            });
+        }
+        catch (error) {
+            operation.finish();
+            throw error;
+        }
+        const responseBody = response.Body;
+        const disposeResponseBody = async () => {
+            await disposeBody(responseBody);
+        };
+        let sourceStream = null;
+        try {
+            sourceStream = responseBody instanceof plugins.stream.Readable
+                ? responseBody
+                : (typeof ReadableStream !== 'undefined'
+                    && responseBody instanceof ReadableStream)
+                    ? plugins.stream.Readable.fromWeb(responseBody)
+                    : null;
+        }
+        catch (error) {
+            await disposeResponseBody();
+            operation.finish();
+            throw error;
+        }
+        if (!sourceStream) {
+            await disposeResponseBody();
+            operation.finish();
+            throw new Error('S3 GetObject returned no supported response stream.');
+        }
+        const outputStream = new plugins.stream.PassThrough();
+        const abortError = () => {
+            if (operation.signal.reason instanceof Error) {
+                return operation.signal.reason;
+            }
+            const error = new Error('S3 object download was aborted.');
+            error.name = 'AbortError';
+            return error;
+        };
+        let sourceEnded = false;
+        let forwardingCleanedUp = false;
+        let sourceErrorGuardReleased = false;
+        const preventUnhandledSourceError = () => { };
+        const preventUnhandledOutputError = () => { };
+        const cleanupForwarding = () => {
+            if (forwardingCleanedUp) {
+                return;
+            }
+            forwardingCleanedUp = true;
+            operation.signal.removeEventListener('abort', onAbort);
+            sourceStream.removeListener('error', onSourceError);
+            sourceStream.removeListener('end', onSourceEnd);
+            sourceStream.removeListener('close', onSourceClose);
+            outputStream.removeListener('error', preventUnhandledOutputError);
+            outputStream.removeListener('close', onOutputClose);
+        };
+        const releaseSourceErrorGuard = () => {
+            if (sourceErrorGuardReleased) {
+                return;
+            }
+            sourceErrorGuardReleased = true;
+            sourceStream.removeListener('error', preventUnhandledSourceError);
+        };
+        let sourceSettlement;
+        const settleSource = () => {
+            sourceSettlement ??= destroyReadableAndWaitForSettlement(sourceStream);
+            return sourceSettlement;
+        };
+        const finishAfterSourceSettlement = async () => {
+            await settleSource();
+            releaseSourceErrorGuard();
+            operation.finish();
+        };
+        const onAbort = () => {
+            const error = abortError();
+            outputStream.destroy(error);
+            void settleSource();
+        };
+        const onSourceError = (errorArg) => {
+            outputStream.destroy(errorArg);
+        };
+        const onSourceEnd = () => {
+            sourceEnded = true;
+        };
+        const onSourceClose = () => {
+            if (!sourceEnded && !outputStream.destroyed) {
+                outputStream.destroy(new Error('S3 object download stream closed before completion.'));
+            }
+        };
+        const onOutputClose = () => {
+            cleanupForwarding();
+            if (sourceStream.closed) {
+                releaseSourceErrorGuard();
+                operation.finish();
+            }
+            else {
+                void finishAfterSourceSettlement();
+            }
+        };
+        sourceStream.on('error', preventUnhandledSourceError);
+        sourceStream.once('error', onSourceError);
+        sourceStream.once('end', onSourceEnd);
+        sourceStream.once('close', onSourceClose);
+        outputStream.on('error', preventUnhandledOutputError);
+        outputStream.once('close', onOutputClose);
+        operation.signal.addEventListener('abort', onAbort, { once: true });
+        if (sourceStream.closed) {
+            sourceEnded = sourceStream.readableEnded;
+            onSourceClose();
+        }
+        if (operation.signal.aborted) {
+            const error = abortError();
+            cleanupForwarding();
+            outputStream.destroy();
+            await settleSource();
+            releaseSourceErrorGuard();
+            operation.finish();
+            throw error;
+        }
+        let result;
+        try {
+            if (typeArg === 'nodestream') {
+                result = outputStream;
+            }
+            else if (typeArg === 'webstream') {
+                result = plugins.stream.Readable.toWeb(outputStream);
+            }
+            else {
+                throw new Error('unknown typeArg');
+            }
+            sourceStream.pipe(outputStream);
+        }
+        catch (error) {
+            cleanupForwarding();
+            outputStream.destroy();
+            await settleSource();
+            releaseSourceErrorGuard();
+            operation.finish();
+            throw error;
+        }
+        return result;
+    }
+    /**
+     * store file as stream
+     */
+    async fastPutStream(optionsArg) {
+        if (optionsArg.contentLength !== undefined
+            && (!Number.isSafeInteger(optionsArg.contentLength)
+                || optionsArg.contentLength < 0)) {
+            throw new Error('contentLength must be a non-negative safe integer');
+        }
+        const operation = beginBasicBucketOperation(this, optionsArg.signal);
+        let uploadStream;
+        let sourceOwnershipStarted = false;
+        const disposeSource = async () => {
+            if (!uploadStream) {
+                if (optionsArg.readableStream instanceof plugins.stream.Readable) {
+                    uploadStream = optionsArg.readableStream;
+                }
+                else {
+                    const cancellation = optionsArg.readableStream.cancel().catch(() => undefined);
+                    let cancellationDeadline;
+                    try {
+                        await Promise.race([
+                            cancellation,
+                            new Promise((resolveCancellationArg) => {
+                                cancellationDeadline = setTimeout(resolveCancellationArg, 5_000);
+                            }),
+                        ]);
+                    }
+                    finally {
+                        if (cancellationDeadline) {
+                            clearTimeout(cancellationDeadline);
+                        }
+                    }
+                    return;
+                }
+            }
+            await destroyReadableAndWaitForSettlement(uploadStream);
+        };
+        let putDispatched = false;
+        try {
+            let exists;
+            try {
+                await operation.runProvider(() => operation.client.send(new plugins.s3.HeadObjectCommand({
+                    Bucket: operation.bucketName,
+                    Key: optionsArg.path,
+                }), { abortSignal: operation.signal }));
+                exists = true;
+            }
+            catch (error) {
+                try {
+                    operation.assertCurrent();
+                }
+                catch (abortError) {
+                    throw abortError;
+                }
+                if (error?.name === 'NotFound') {
+                    exists = false;
+                }
+                else {
+                    throw error;
+                }
+            }
+            if (exists && !optionsArg.overwrite) {
+                throw new Error(`Object already exists at path '${optionsArg.path}' in bucket '${this.name}'. ` +
+                    `Set overwrite:true to replace it.`);
+            }
+            else if (exists && optionsArg.overwrite) {
+                console.log(`Overwriting existing object at path '${optionsArg.path}' in bucket '${this.name}'.`);
+            }
+            else {
+                console.log(`Creating new object at path '${optionsArg.path}' in bucket '${this.name}'.`);
+            }
+            sourceOwnershipStarted = true;
+            uploadStream = optionsArg.readableStream instanceof plugins.stream.Readable
+                ? optionsArg.readableStream
+                : plugins.stream.Readable.fromWeb(optionsArg.readableStream);
+            const command = new plugins.s3.PutObjectCommand({
+                Bucket: operation.bucketName,
+                Key: optionsArg.path,
+                Body: uploadStream,
+                ContentLength: optionsArg.contentLength,
+                Metadata: optionsArg.nativeMetadata,
+            });
+            putDispatched = true;
+            await operation.runProvider(() => operation.client.send(command, { abortSignal: operation.signal }));
+            console.log(`Object '${optionsArg.path}' has been successfully stored in bucket '${this.name}'.`);
+        }
+        catch (error) {
+            if (sourceOwnershipStarted || putDispatched || operation.signal.aborted) {
+                await disposeSource();
+            }
+            console.error(`Error storing object at path '${optionsArg.path}' in bucket '${this.name}':`, error);
+            throw error;
+        }
+        finally {
+            operation.finish();
+        }
+    }
+    /**
+     * Creates an object from a stream while enforcing the declared byte length
+     * and create-only destination semantics.
+     *
+     * Non-empty inputs always use multipart upload and never fall back to a
+     * single streaming PutObject request. Memory is bounded by the returned
+     * multipart plan. Every source chunk must be no larger than the effective
+     * multipart part size (5 MiB by default, or requestedPartSize after protocol
+     * normalization).
+     */
+    fastPutStreamExact(optionsArg) {
+        return fastPutStreamExactOperation(this, optionsArg);
+    }
+    /**
+     * Permanently removes the exact key, including every object version and
+     * delete marker, without deleting keys that merely share its prefix.
+     */
+    purgeExactPath(optionsArg) {
+        return purgeExactPathOperation(this, optionsArg);
+    }
+    async fastCopy(optionsArg) {
+        const operation = beginBasicBucketOperation(this, optionsArg.signal);
+        try {
+            const targetBucketName = optionsArg.targetBucket ? optionsArg.targetBucket.name : this.name;
+            // Retrieve current object information to use in copy conditions
+            const currentObjInfo = await operation.runProvider(() => operation.client.send(new plugins.s3.HeadObjectCommand({
+                Bucket: operation.bucketName,
+                Key: optionsArg.sourcePath,
+            }), { abortSignal: operation.signal }));
+            // Prepare new metadata
+            const newNativeMetadata = {
+                ...(optionsArg.deleteExistingNativeMetadata ? {} : currentObjInfo.Metadata),
+                ...optionsArg.nativeMetadata,
+            };
+            // Define the copy operation
+            const copySource = `${operation.bucketName}/${optionsArg.sourcePath}`;
+            const command = new plugins.s3.CopyObjectCommand({
+                Bucket: targetBucketName,
+                CopySource: copySource,
+                Key: optionsArg.destinationPath || optionsArg.sourcePath,
+                Metadata: newNativeMetadata,
+                MetadataDirective: optionsArg.deleteExistingNativeMetadata ? 'REPLACE' : 'COPY',
+            });
+            await operation.runProvider(() => operation.client.send(command, { abortSignal: operation.signal }));
+        }
+        catch (err) {
+            console.error('Error updating metadata:', err);
+            throw err; // rethrow to allow caller to handle
+        }
+        finally {
+            operation.finish();
+        }
+    }
+    /**
+     * Move object from one path to another within the same bucket or to another bucket
+     */
+    async fastMove(optionsArg) {
+        try {
+            const destinationBucket = optionsArg.targetBucket || this;
+            const exists = await destinationBucket.fastExists({
+                path: optionsArg.destinationPath,
+            });
+            if (exists && !optionsArg.overwrite) {
+                console.error(`Object already exists at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
+                return;
+            }
+            else if (exists && optionsArg.overwrite) {
+                console.log(`Overwriting existing object at destination path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
+            }
+            else {
+                console.log(`Moving object to path '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
+            }
+            await this.fastCopy(optionsArg);
+            await this.fastRemove({ path: optionsArg.sourcePath });
+            console.log(`Object '${optionsArg.sourcePath}' has been successfully moved to '${optionsArg.destinationPath}' in bucket '${destinationBucket.name}'.`);
+        }
+        catch (error) {
+            console.error(`Error moving object from '${optionsArg.sourcePath}' to '${optionsArg.destinationPath}':`, error);
+            throw error;
+        }
+    }
+    /**
+     * removeObject
+     */
+    async fastRemove(optionsArg) {
+        const operation = beginBasicBucketOperation(this, optionsArg.signal);
+        const command = new plugins.s3.DeleteObjectCommand({
+            Bucket: operation.bucketName,
+            Key: optionsArg.path,
+        });
+        try {
+            await operation.runProvider(() => operation.client.send(command, { abortSignal: operation.signal }));
+        }
+        finally {
+            operation.finish();
+        }
+    }
+    /**
+     * check whether file exists
+     * @param optionsArg
+     * @returns
+     */
+    async fastExists(optionsArg) {
+        const operation = beginBasicBucketOperation(this, optionsArg.signal);
+        try {
+            const command = new plugins.s3.HeadObjectCommand({
+                Bucket: operation.bucketName,
+                Key: optionsArg.path,
+            });
+            await operation.runProvider(() => operation.client.send(command, { abortSignal: operation.signal }));
+            console.log(`Object '${optionsArg.path}' exists in bucket '${this.name}'.`);
+            return true;
+        }
+        catch (error) {
+            try {
+                operation.assertCurrent();
+            }
+            catch (abortError) {
+                throw abortError;
+            }
+            if (error?.name === 'NotFound') {
+                console.log(`Object '${optionsArg.path}' does not exist in bucket '${this.name}'.`);
+                return false;
+            }
+            else {
+                console.error('Error checking object existence:', error);
+                throw error; // Rethrow if it's not a NotFound error to handle unexpected issues
+            }
+        }
+        finally {
+            operation.finish();
+        }
+    }
+    /**
+     * deletes this bucket
+     */
+    async delete() {
+        await this.smartbucketRef.storageClient.send(new plugins.s3.DeleteBucketCommand({ Bucket: this.name }));
+    }
+    async fastStat(pathDescriptor) {
+        const operation = beginBasicBucketOperation(this, pathDescriptor.signal);
+        try {
+            operation.assertCurrent();
+            const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+            operation.assertCurrent();
+            const command = new plugins.s3.HeadObjectCommand({
+                Bucket: operation.bucketName,
+                Key: checkPath,
+            });
+            return await operation.runProvider(() => operation.client.send(command, { abortSignal: operation.signal }));
+        }
+        finally {
+            operation.finish();
+        }
+    }
+    async isDirectory(pathDescriptor) {
+        const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+        const command = new plugins.s3.ListObjectsV2Command({
+            Bucket: this.name,
+            Prefix: checkPath,
+            Delimiter: '/',
+        });
+        const { CommonPrefixes } = await this.smartbucketRef.storageClient.send(command);
+        return !!CommonPrefixes && CommonPrefixes.length > 0;
+    }
+    async isFile(pathDescriptor) {
+        const checkPath = await helpers.reducePathDescriptorToPath(pathDescriptor);
+        const command = new plugins.s3.ListObjectsV2Command({
+            Bucket: this.name,
+            Prefix: checkPath,
+            Delimiter: '/',
+        });
+        const { Contents } = await this.smartbucketRef.storageClient.send(command);
+        return !!Contents && Contents.length > 0;
+    }
+    async getMagicBytes(optionsArg) {
+        try {
+            const command = new plugins.s3.GetObjectCommand({
+                Bucket: this.name,
+                Key: optionsArg.path,
+                Range: `bytes=0-${optionsArg.length - 1}`,
+            });
+            const response = await this.smartbucketRef.storageClient.send(command);
+            const chunks = [];
+            const stream = response.Body; // SdkStreamMixin includes readable stream
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+            return Buffer.concat(chunks);
+        }
+        catch (error) {
+            console.error(`Error retrieving magic bytes from object at path '${optionsArg.path}' in bucket '${this.name}':`, error);
+            throw error;
+        }
+    }
+    // ==========================================
+    // Memory-Efficient Listing Methods (Phase 1)
+    // ==========================================
+    /**
+     * List all objects with a given prefix using async generator (memory-efficient streaming)
+     * @param prefix - Optional prefix to filter objects (default: '' for all objects)
+     * @yields Object keys one at a time
+     * @example
+     * ```ts
+     * for await (const key of bucket.listAllObjects('npm/')) {
+     *   console.log(key);
+     *   if (shouldStop) break; // Early exit supported
+     * }
+     * ```
+     */
+    async *listAllObjects(prefix = '') {
+        let continuationToken;
+        do {
+            const command = new plugins.s3.ListObjectsV2Command({
+                Bucket: this.name,
+                Prefix: prefix,
+                ContinuationToken: continuationToken,
+            });
+            const response = await this.smartbucketRef.storageClient.send(command);
+            for (const obj of response.Contents || []) {
+                if (obj.Key)
+                    yield obj.Key;
+            }
+            continuationToken = response.NextContinuationToken;
+        } while (continuationToken);
+    }
+    /**
+     * List all objects as an RxJS Observable (for complex reactive pipelines)
+     * @param prefix - Optional prefix to filter objects (default: '' for all objects)
+     * @returns Observable that emits object keys
+     * @example
+     * ```ts
+     * bucket.listAllObjectsObservable('npm/')
+     *   .pipe(
+     *     filter(key => key.endsWith('.json')),
+     *     take(100)
+     *   )
+     *   .subscribe(key => console.log(key));
+     * ```
+     */
+    listAllObjectsObservable(prefix = '') {
+        return new plugins.smartrx.rxjs.Observable((subscriber) => {
+            const fetchPage = async (token) => {
+                try {
+                    const command = new plugins.s3.ListObjectsV2Command({
+                        Bucket: this.name,
+                        Prefix: prefix,
+                        ContinuationToken: token,
+                    });
+                    const response = await this.smartbucketRef.storageClient.send(command);
+                    for (const obj of response.Contents || []) {
+                        if (obj.Key)
+                            subscriber.next(obj.Key);
+                    }
+                    if (response.NextContinuationToken) {
+                        await fetchPage(response.NextContinuationToken);
+                    }
+                    else {
+                        subscriber.complete();
+                    }
+                }
+                catch (error) {
+                    subscriber.error(error);
+                }
+            };
+            fetchPage();
+        });
+    }
+    /**
+     * Create a cursor for manual pagination control
+     * @param prefix - Optional prefix to filter objects (default: '' for all objects)
+     * @param options - Cursor options (pageSize, etc.)
+     * @returns ListCursor instance
+     * @example
+     * ```ts
+     * const cursor = bucket.createCursor('npm/', { pageSize: 500 });
+     * while (cursor.hasMore()) {
+     *   const { keys, done } = await cursor.next();
+     *   console.log(`Processing ${keys.length} keys...`);
+     * }
+     * ```
+     */
+    createCursor(prefix = '', options) {
+        return new ListCursor(this, prefix, options);
+    }
+    /**
+     * List one deletion-stable keyset page using S3 ListObjectsV2 StartAfter.
+     * This requires a general-purpose S3 provider with UTF-8 byte-ordered keys.
+     */
+    async listObjectKeysPage(optionsArg) {
+        if (!optionsArg || typeof optionsArg !== 'object' || Array.isArray(optionsArg)) {
+            throw new TypeError('Object key page options must be a plain object');
+        }
+        const prefix = optionsArg.prefix ?? '';
+        if (typeof prefix !== 'string') {
+            throw new TypeError('Object key page prefix must be a string');
+        }
+        if (!Number.isInteger(optionsArg.limit) || optionsArg.limit < 1 || optionsArg.limit > 1_000) {
+            throw new Error('Object key page limit must be an integer from 1 to 1000');
+        }
+        if (optionsArg.startAfter !== undefined
+            && (typeof optionsArg.startAfter !== 'string'
+                || optionsArg.startAfter.length === 0
+                || !optionsArg.startAfter.startsWith(prefix))) {
+            throw new Error('Object key page startAfter must be a non-empty key under the prefix');
+        }
+        const response = await this.smartbucketRef.storageClient.send(new plugins.s3.ListObjectsV2Command({
+            Bucket: this.name,
+            Prefix: prefix,
+            MaxKeys: optionsArg.limit,
+            ...(optionsArg.startAfter ? { StartAfter: optionsArg.startAfter } : {}),
+        }));
+        if (typeof response.IsTruncated !== 'boolean') {
+            throw new Error('Object storage returned an invalid key page truncation flag');
+        }
+        if (response.Contents !== undefined && !Array.isArray(response.Contents)) {
+            throw new Error('Object storage returned invalid key page contents');
+        }
+        const keys = (response.Contents ?? []).map((entry) => {
+            if (!entry || typeof entry.Key !== 'string') {
+                throw new Error('Object storage returned a key page entry without a string key');
+            }
+            return entry.Key;
+        });
+        if (keys.length > optionsArg.limit) {
+            throw new Error('Object storage returned more keys than the requested page limit');
+        }
+        if (new Set(keys).size !== keys.length) {
+            throw new Error('Object storage returned duplicate keys in one page');
+        }
+        let previousKey = optionsArg.startAfter;
+        for (const key of keys) {
+            if (!key.startsWith(prefix)) {
+                throw new Error('Object storage returned a key outside the requested prefix');
+            }
+            if (previousKey !== undefined && compareUtf8ObjectKeys(key, previousKey) <= 0) {
+                throw new Error('Object storage returned keys outside strict UTF-8 byte order');
+            }
+            previousKey = key;
+        }
+        if (response.IsTruncated && keys.length === 0) {
+            throw new Error('Object storage returned an empty truncated key page');
+        }
+        return {
+            keys,
+            ...(response.IsTruncated ? { nextStartAfter: keys[keys.length - 1] } : {}),
+        };
+    }
+    /**
+     * Create a watcher for monitoring bucket changes (add/modify/delete)
+     * @param options - Watcher options (prefix, pollIntervalMs, etc.)
+     * @returns BucketWatcher instance
+     * @example
+     * ```ts
+     * const watcher = bucket.createWatcher({ prefix: 'uploads/', pollIntervalMs: 3000 });
+     * watcher.changeSubject.subscribe((change) => console.log('Change:', change));
+     * await watcher.start();
+     * // ... later
+     * await watcher.stop();
+     * ```
+     */
+    createWatcher(options) {
+        return new BucketWatcher(this, options);
+    }
+    // ==========================================
+    // High-Level Listing Helpers (Phase 2)
+    // ==========================================
+    /**
+     * Find objects matching a glob pattern (memory-efficient)
+     * @param pattern - Glob pattern (e.g., "**\/*.json", "npm/packages/*\/index.json")
+     * @yields Matching object keys
+     * @example
+     * ```ts
+     * for await (const key of bucket.findByGlob('npm/packages/*\/index.json')) {
+     *   console.log('Found package index:', key);
+     * }
+     * ```
+     */
+    async *findByGlob(pattern) {
+        const matcher = new plugins.Minimatch(pattern);
+        for await (const key of this.listAllObjects('')) {
+            if (matcher.match(key))
+                yield key;
+        }
+    }
+    /**
+     * List all objects and collect into an array (convenience method)
+     * WARNING: Loads entire result set into memory. Use listAllObjects() generator for large buckets.
+     * @param prefix - Optional prefix to filter objects (default: '' for all objects)
+     * @returns Array of all object keys
+     * @example
+     * ```ts
+     * const allKeys = await bucket.listAllObjectsArray('npm/');
+     * console.log(`Found ${allKeys.length} objects`);
+     * ```
+     */
+    async listAllObjectsArray(prefix = '') {
+        const keys = [];
+        for await (const key of this.listAllObjects(prefix)) {
+            keys.push(key);
+        }
+        return keys;
+    }
+    async cleanAllContents() {
+        try {
+            // Define the command type explicitly
+            const listCommandInput = {
+                Bucket: this.name,
+            };
+            let isTruncated = true;
+            let continuationToken = undefined;
+            while (isTruncated) {
+                // Add the continuation token to the input if present
+                const listCommand = new plugins.s3.ListObjectsV2Command({
+                    ...listCommandInput,
+                    ContinuationToken: continuationToken,
+                });
+                // Explicitly type the response
+                const response = await this.smartbucketRef.storageClient.send(listCommand);
+                console.log(`Cleaning contents of bucket '${this.name}': Now deleting ${response.Contents?.length} items...`);
+                if (response.Contents && response.Contents.length > 0) {
+                    // Delete objects in batches, mapping each item to { Key: string }
+                    const deleteCommand = new plugins.s3.DeleteObjectsCommand({
+                        Bucket: this.name,
+                        Delete: {
+                            Objects: response.Contents.map((item) => ({ Key: item.Key })),
+                            Quiet: true,
+                        },
+                    });
+                    await this.smartbucketRef.storageClient.send(deleteCommand);
+                }
+                // Update continuation token and truncation status
+                isTruncated = response.IsTruncated || false;
+                continuationToken = response.NextContinuationToken;
+            }
+            console.log(`All contents in bucket '${this.name}' have been deleted.`);
+        }
+        catch (error) {
+            console.error(`Error cleaning contents of bucket '${this.name}':`, error);
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.bucket.js","sourceRoot":"","sources":["../../ts/objectstorage/classes.bucket.ts"],"names":[],"mappings":"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"}