@lossless.org/client 0.1.0

package/dist_ts/objectstorage/internal.multipart.planner.d.ts

@@ -0,0 +1,8 @@
+import type { IMultipartPlanningOptions, TMultipartUploadPlan } from './internal.multipart.types.js';
+export declare const MULTIPART_MIN_PART_SIZE: number;
+export declare const MULTIPART_MAX_PART_SIZE: number;
+export declare const MULTIPART_MAX_PART_COUNT = 10000;
+export declare const MULTIPART_MAX_OBJECT_SIZE: number;
+export declare const MULTIPART_DEFAULT_CONCURRENCY = 1;
+export declare const MULTIPART_MAX_CONCURRENCY = 32;
+export declare const planMultipartUpload: (optionsArg: IMultipartPlanningOptions) => TMultipartUploadPlan;

package/dist_ts/objectstorage/internal.multipart.planner.js

@@ -0,0 +1,63 @@
+export const MULTIPART_MIN_PART_SIZE = 5 * 1024 * 1024;
+export const MULTIPART_MAX_PART_SIZE = 5 * 1024 * 1024 * 1024;
+export const MULTIPART_MAX_PART_COUNT = 10_000;
+export const MULTIPART_MAX_OBJECT_SIZE = 5 * 1024 * 1024 * 1024 * 1024;
+export const MULTIPART_DEFAULT_CONCURRENCY = 1;
+export const MULTIPART_MAX_CONCURRENCY = 32;
+const requireSafeNonNegativeInteger = (valueArg, nameArg) => {
+    if (!Number.isSafeInteger(valueArg) || valueArg < 0) {
+        throw new TypeError(`${nameArg} must be a non-negative safe integer.`);
+    }
+};
+const normalizeRequestedPartSize = (requestedPartSizeArg) => {
+    if (requestedPartSizeArg === undefined) {
+        return MULTIPART_MIN_PART_SIZE;
+    }
+    if (!Number.isSafeInteger(requestedPartSizeArg) || requestedPartSizeArg <= 0) {
+        throw new TypeError('requestedPartSize must be a positive safe integer.');
+    }
+    return Math.min(MULTIPART_MAX_PART_SIZE, Math.max(MULTIPART_MIN_PART_SIZE, requestedPartSizeArg));
+};
+const normalizeRequestedConcurrency = (requestedConcurrencyArg) => {
+    if (requestedConcurrencyArg === undefined) {
+        return MULTIPART_DEFAULT_CONCURRENCY;
+    }
+    if (!Number.isSafeInteger(requestedConcurrencyArg) || requestedConcurrencyArg <= 0) {
+        throw new TypeError('requestedConcurrency must be a positive safe integer.');
+    }
+    return Math.min(MULTIPART_MAX_CONCURRENCY, requestedConcurrencyArg);
+};
+export const planMultipartUpload = (optionsArg) => {
+    requireSafeNonNegativeInteger(optionsArg.objectSize, 'objectSize');
+    if (optionsArg.objectSize > MULTIPART_MAX_OBJECT_SIZE) {
+        throw new RangeError(`objectSize exceeds the ${MULTIPART_MAX_OBJECT_SIZE} byte multipart limit.`);
+    }
+    const requestedConcurrency = normalizeRequestedConcurrency(optionsArg.requestedConcurrency);
+    if (optionsArg.objectSize === 0) {
+        return {
+            classification: 'zero',
+            objectSize: 0,
+            partSize: 0,
+            partCount: 0,
+            concurrency: requestedConcurrency,
+            maximumBufferedBytes: 0,
+        };
+    }
+    const preferredPartSize = normalizeRequestedPartSize(optionsArg.requestedPartSize);
+    const minimumPartSizeForCount = Math.ceil(optionsArg.objectSize / MULTIPART_MAX_PART_COUNT);
+    const partSize = Math.max(preferredPartSize, minimumPartSizeForCount);
+    if (partSize > MULTIPART_MAX_PART_SIZE) {
+        throw new RangeError('The object cannot be represented by legal multipart parts.');
+    }
+    const partCount = Math.ceil(optionsArg.objectSize / partSize);
+    const concurrency = Math.min(requestedConcurrency, partCount);
+    return {
+        classification: 'multipart',
+        objectSize: optionsArg.objectSize,
+        partSize,
+        partCount,
+        concurrency,
+        maximumBufferedBytes: Math.min(optionsArg.objectSize, partSize * concurrency) + Math.min(optionsArg.objectSize, partSize),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/objectstorage/internal.multipart.stream.d.ts

@@ -0,0 +1,17 @@
+import type { IConsumeExactMultipartStreamOptions, IMultipartStreamConsumptionResult, IMultipartStreamFailureState } from './internal.multipart.types.js';
+export declare class MultipartStreamConsumptionError extends Error {
+    readonly state: IMultipartStreamFailureState;
+    /**
+     * Non-rejecting settlement of every started part callback.
+     */
+    readonly callbackSettlement: Promise<void>;
+    /**
+     * Non-rejecting settlement of callbacks and owned reader cancellation.
+     */
+    readonly ownedSettlement: Promise<void>;
+    constructor(stateArg: IMultipartStreamFailureState, settlementsArg?: {
+        callbackSettlement: Promise<void>;
+        ownedSettlement: Promise<void>;
+    });
+}
+export declare const consumeExactMultipartStream: (optionsArg: IConsumeExactMultipartStreamOptions) => Promise<IMultipartStreamConsumptionResult>;

package/dist_ts/objectstorage/internal.multipart.stream.js

@@ -0,0 +1,440 @@
+import { MULTIPART_MAX_CONCURRENCY, MULTIPART_MAX_OBJECT_SIZE, MULTIPART_MAX_PART_COUNT, MULTIPART_MAX_PART_SIZE, MULTIPART_MIN_PART_SIZE, } from './internal.multipart.planner.js';
+const failureMessages = {
+    aborted: 'Multipart stream consumption was aborted.',
+    'source-read': 'The multipart source stream failed while being read.',
+    'source-buffer-limit': 'The multipart source emitted a chunk larger than the buffer limit.',
+    'source-empty-chunk-limit': 'The multipart source emitted too many consecutive empty chunks.',
+    'source-short': 'The multipart source ended before the declared content length.',
+    'source-extra': 'The multipart source exceeded the declared content length.',
+    'part-callback': 'A multipart part callback failed.',
+};
+const failureSettlementMaximumTimeoutMs = 30_000;
+const maximumConsecutiveEmptyChunks = 1_024;
+export class MultipartStreamConsumptionError extends Error {
+    state;
+    /**
+     * Non-rejecting settlement of every started part callback.
+     */
+    callbackSettlement;
+    /**
+     * Non-rejecting settlement of callbacks and owned reader cancellation.
+     */
+    ownedSettlement;
+    constructor(stateArg, settlementsArg) {
+        super(failureMessages[stateArg.kind], {
+            cause: stateArg.cause,
+        });
+        this.name = 'MultipartStreamConsumptionError';
+        this.state = stateArg;
+        this.callbackSettlement =
+            settlementsArg?.callbackSettlement ?? Promise.resolve();
+        this.ownedSettlement =
+            settlementsArg?.ownedSettlement ?? Promise.resolve();
+    }
+}
+const validatePlan = (planArg) => {
+    if (!Number.isSafeInteger(planArg.objectSize) ||
+        planArg.objectSize < 0 ||
+        planArg.objectSize > MULTIPART_MAX_OBJECT_SIZE) {
+        throw new TypeError('plan.objectSize is invalid.');
+    }
+    if (!Number.isSafeInteger(planArg.concurrency) ||
+        planArg.concurrency < 1 ||
+        planArg.concurrency > MULTIPART_MAX_CONCURRENCY) {
+        throw new TypeError('plan.concurrency is invalid.');
+    }
+    if (planArg.classification === 'zero') {
+        if (planArg.objectSize !== 0 ||
+            planArg.partSize !== 0 ||
+            planArg.partCount !== 0 ||
+            planArg.maximumBufferedBytes !== 0) {
+            throw new TypeError('The zero-byte multipart plan is inconsistent.');
+        }
+        return;
+    }
+    if (planArg.objectSize === 0 ||
+        !Number.isSafeInteger(planArg.partSize) ||
+        planArg.partSize < MULTIPART_MIN_PART_SIZE ||
+        planArg.partSize > MULTIPART_MAX_PART_SIZE ||
+        planArg.partCount !== Math.ceil(planArg.objectSize / planArg.partSize) ||
+        planArg.partCount < 1 ||
+        planArg.partCount > MULTIPART_MAX_PART_COUNT ||
+        planArg.concurrency > planArg.partCount ||
+        planArg.maximumBufferedBytes !==
+            Math.min(planArg.objectSize, planArg.partSize * planArg.concurrency) +
+                Math.min(planArg.objectSize, planArg.partSize)) {
+        throw new TypeError('The multipart plan is inconsistent.');
+    }
+};
+export const consumeExactMultipartStream = async (optionsArg) => {
+    validatePlan(optionsArg.plan);
+    if (!optionsArg.readableStream ||
+        typeof optionsArg.readableStream.getReader !== 'function') {
+        throw new TypeError('readableStream must be a web ReadableStream.');
+    }
+    if (typeof optionsArg.onPart !== 'function') {
+        throw new TypeError('onPart must be a function.');
+    }
+    const failureSettlementTimeoutMs = optionsArg.failureSettlementTimeoutMs ??
+        failureSettlementMaximumTimeoutMs;
+    if (!Number.isSafeInteger(failureSettlementTimeoutMs) ||
+        failureSettlementTimeoutMs <= 0 ||
+        failureSettlementTimeoutMs > failureSettlementMaximumTimeoutMs) {
+        throw new TypeError(`failureSettlementTimeoutMs must be a positive safe integer no greater than ${failureSettlementMaximumTimeoutMs}.`);
+    }
+    const reader = optionsArg.readableStream.getReader();
+    const callbackAbortController = new AbortController();
+    const inFlightParts = new Map();
+    const completedPartNumbers = new Set();
+    let inFlightBytes = 0;
+    let currentPartBytes = 0;
+    let pendingChunkBytes = 0;
+    let peakBufferedBytes = 0;
+    let observedBytes = 0;
+    let partCallbacksStarted = 0;
+    let sourceClosed = false;
+    let consecutiveEmptyChunks = 0;
+    let resolveAbort;
+    const abortOutcome = new Promise((resolveArg) => {
+        resolveAbort = resolveArg;
+    });
+    const handleAbort = () => {
+        const cause = optionsArg.signal?.reason ?? new Error('Multipart stream aborted.');
+        callbackAbortController.abort(cause);
+        resolveAbort({
+            type: 'abort',
+            cause,
+        });
+    };
+    optionsArg.signal?.addEventListener('abort', handleAbort, { once: true });
+    if (optionsArg.signal?.aborted) {
+        handleAbort();
+    }
+    const processPartOutcome = (outcomeArg) => {
+        const inFlightPart = inFlightParts.get(outcomeArg.token);
+        if (!inFlightPart) {
+            return;
+        }
+        inFlightParts.delete(outcomeArg.token);
+        inFlightBytes -= inFlightPart.byteLength;
+        if (outcomeArg.succeeded) {
+            completedPartNumbers.add(outcomeArg.partNumber);
+            return;
+        }
+        throw {
+            kind: 'part-callback',
+            cause: outcomeArg.cause,
+        };
+    };
+    const observeBufferedBytes = () => {
+        const bufferedBytes = inFlightBytes + currentPartBytes + pendingChunkBytes;
+        if (bufferedBytes > optionsArg.plan.maximumBufferedBytes) {
+            throw {
+                kind: 'source-buffer-limit',
+                cause: new RangeError('Multipart buffering exceeded its planned bound.'),
+            };
+        }
+        peakBufferedBytes = Math.max(peakBufferedBytes, bufferedBytes);
+    };
+    const waitForOnePart = async () => {
+        const outcome = await Promise.race([
+            abortOutcome,
+            ...[...inFlightParts.values()].map((inFlightPartArg) => inFlightPartArg.outcome),
+        ]);
+        if (!('token' in outcome)) {
+            throw {
+                kind: 'aborted',
+                cause: outcome.cause,
+            };
+        }
+        processPartOutcome(outcome);
+    };
+    const waitForCapacity = async () => {
+        while (inFlightParts.size >= optionsArg.plan.concurrency) {
+            await waitForOnePart();
+        }
+    };
+    const readWhileObservingCallbacks = async () => {
+        const readOutcome = reader.read().then((resultArg) => ({
+            type: 'read',
+            result: resultArg,
+        }), (causeArg) => ({
+            type: 'read-error',
+            cause: causeArg,
+        }));
+        while (true) {
+            const outcome = await Promise.race([
+                readOutcome,
+                abortOutcome,
+                ...[...inFlightParts.values()].map((inFlightPartArg) => inFlightPartArg.outcome),
+            ]);
+            if ('token' in outcome) {
+                processPartOutcome(outcome);
+                continue;
+            }
+            if (outcome.type === 'abort') {
+                throw {
+                    kind: 'aborted',
+                    cause: outcome.cause,
+                };
+            }
+            if (outcome.type === 'read-error') {
+                throw {
+                    kind: 'source-read',
+                    cause: outcome.cause,
+                };
+            }
+            return outcome.result;
+        }
+    };
+    const dispatchPart = (dataArg, partNumberArg) => {
+        const token = Symbol(`multipart-part-${partNumberArg}`);
+        partCallbacksStarted++;
+        currentPartBytes = 0;
+        inFlightBytes += dataArg.byteLength;
+        observeBufferedBytes();
+        const outcome = Promise.resolve()
+            .then(() => optionsArg.onPart({
+            partNumber: partNumberArg,
+            byteOffset: (partNumberArg - 1) * optionsArg.plan.partSize,
+            isLastPart: partNumberArg === optionsArg.plan.partCount,
+            data: dataArg,
+            signal: callbackAbortController.signal,
+        }))
+            .then(() => ({
+            token,
+            partNumber: partNumberArg,
+            succeeded: true,
+        }), (causeArg) => ({
+            token,
+            partNumber: partNumberArg,
+            succeeded: false,
+            cause: causeArg,
+        }));
+        inFlightParts.set(token, {
+            byteLength: dataArg.byteLength,
+            outcome,
+        });
+    };
+    const acceptSourceChunk = (chunkArg) => {
+        if (chunkArg.byteLength > 0) {
+            consecutiveEmptyChunks = 0;
+            return true;
+        }
+        consecutiveEmptyChunks++;
+        if (consecutiveEmptyChunks > maximumConsecutiveEmptyChunks) {
+            throw {
+                kind: 'source-empty-chunk-limit',
+                cause: new RangeError(`The multipart source emitted more than ${maximumConsecutiveEmptyChunks} consecutive empty chunks.`),
+            };
+        }
+        return false;
+    };
+    try {
+        let pendingChunk;
+        let pendingChunkOffset = 0;
+        for (let partNumber = 1; partNumber <= optionsArg.plan.partCount; partNumber++) {
+            await waitForCapacity();
+            const partByteLength = Math.min(optionsArg.plan.partSize, optionsArg.plan.objectSize -
+                (partNumber - 1) * optionsArg.plan.partSize);
+            if (inFlightBytes + partByteLength >
+                optionsArg.plan.maximumBufferedBytes) {
+                throw new Error('The multipart plan cannot honor its buffering bound.');
+            }
+            const partData = new Uint8Array(partByteLength);
+            currentPartBytes = partByteLength;
+            observeBufferedBytes();
+            let partOffset = 0;
+            while (partOffset < partByteLength) {
+                if (pendingChunk &&
+                    pendingChunkOffset < pendingChunk.byteLength) {
+                    const copyByteLength = Math.min(partByteLength - partOffset, pendingChunk.byteLength - pendingChunkOffset);
+                    partData.set(pendingChunk.subarray(pendingChunkOffset, pendingChunkOffset + copyByteLength), partOffset);
+                    pendingChunkOffset += copyByteLength;
+                    partOffset += copyByteLength;
+                    if (pendingChunkOffset === pendingChunk.byteLength) {
+                        pendingChunk = undefined;
+                        pendingChunkOffset = 0;
+                        pendingChunkBytes = 0;
+                    }
+                    continue;
+                }
+                const readResult = await readWhileObservingCallbacks();
+                if (readResult.done) {
+                    sourceClosed = true;
+                    throw {
+                        kind: 'source-short',
+                    };
+                }
+                if (!(readResult.value instanceof Uint8Array)) {
+                    throw {
+                        kind: 'source-read',
+                        cause: new TypeError('The multipart source emitted a non-Uint8Array chunk.'),
+                    };
+                }
+                if (!acceptSourceChunk(readResult.value)) {
+                    continue;
+                }
+                observedBytes += readResult.value.byteLength;
+                if (observedBytes > optionsArg.plan.objectSize) {
+                    throw {
+                        kind: 'source-extra',
+                    };
+                }
+                if (readResult.value.byteLength > optionsArg.plan.partSize) {
+                    throw {
+                        kind: 'source-buffer-limit',
+                        cause: new RangeError(`Source chunks must not exceed ${optionsArg.plan.partSize} bytes.`),
+                    };
+                }
+                pendingChunk = readResult.value;
+                pendingChunkBytes = readResult.value.byteLength;
+                observeBufferedBytes();
+            }
+            dispatchPart(partData, partNumber);
+        }
+        while (!sourceClosed) {
+            const readResult = await readWhileObservingCallbacks();
+            if (readResult.done) {
+                sourceClosed = true;
+                break;
+            }
+            if (!(readResult.value instanceof Uint8Array)) {
+                throw {
+                    kind: 'source-read',
+                    cause: new TypeError('The multipart source emitted a non-Uint8Array chunk.'),
+                };
+            }
+            if (!acceptSourceChunk(readResult.value)) {
+                continue;
+            }
+            observedBytes += readResult.value.byteLength;
+            throw {
+                kind: 'source-extra',
+            };
+        }
+        while (inFlightParts.size > 0) {
+            await waitForOnePart();
+        }
+        if (optionsArg.signal?.aborted) {
+            throw {
+                kind: 'aborted',
+                cause: optionsArg.signal.reason,
+            };
+        }
+        return {
+            completionAuthorized: true,
+            bytesConsumed: observedBytes,
+            partsConsumed: completedPartNumbers.size,
+            peakBufferedBytes,
+            maximumBufferedBytes: optionsArg.plan.maximumBufferedBytes,
+        };
+    }
+    catch (error) {
+        const failure = typeof error === 'object' &&
+            error !== null &&
+            'kind' in error &&
+            typeof error.kind === 'string'
+            ? error
+            : {
+                kind: 'source-read',
+                cause: error,
+            };
+        callbackAbortController.abort(failure.cause ?? new Error(failureMessages[failure.kind]));
+        const readerCleanupPromise = sourceClosed
+            ? Promise.resolve({
+                status: 'closed',
+            })
+            : Promise.resolve()
+                .then(() => reader.cancel(failure.cause))
+                .then(() => ({
+                status: 'cancelled',
+            }), (causeArg) => ({
+                status: 'cancel-failed',
+                cause: causeArg,
+            }));
+        let callbacksSettled = false;
+        const callbackSettlement = Promise.all([...inFlightParts.values()].map((inFlightPartArg) => inFlightPartArg.outcome))
+            .then((remainingOutcomesArg) => {
+            for (const outcome of remainingOutcomesArg) {
+                if (outcome.succeeded) {
+                    completedPartNumbers.add(outcome.partNumber);
+                }
+            }
+            inFlightParts.clear();
+            inFlightBytes = 0;
+        })
+            .then(() => undefined, () => undefined);
+        const observedCallbackSettlement = callbackSettlement.then(() => {
+            callbacksSettled = true;
+        });
+        let readerCleanup;
+        let readerCleanupSettled = false;
+        const observedReaderCleanup = readerCleanupPromise.then((readerCleanupArg) => {
+            readerCleanup = readerCleanupArg;
+            readerCleanupSettled = true;
+        }, () => {
+            readerCleanup = {
+                status: 'cancel-failed',
+                cause: new Error('Reader cancellation rejected unexpectedly.'),
+            };
+            readerCleanupSettled = true;
+        });
+        const ownedSettlement = Promise.allSettled([
+            observedCallbackSettlement,
+            observedReaderCleanup,
+        ]).then(() => undefined);
+        const settlementDeadlineToken = Symbol('multipart-failure-settlement-deadline');
+        let resolveSettlementDeadline;
+        const settlementDeadlineOutcome = new Promise((resolveArg) => {
+            resolveSettlementDeadline = resolveArg;
+        });
+        const settlementDeadline = setTimeout(() => {
+            resolveSettlementDeadline(settlementDeadlineToken);
+        }, failureSettlementTimeoutMs);
+        await Promise.race([ownedSettlement, settlementDeadlineOutcome]);
+        clearTimeout(settlementDeadline);
+        const retry = partCallbacksStarted === 0
+            ? {
+                disposition: 'safe-to-retry',
+                requiresMultipartAbort: false,
+            }
+            : {
+                disposition: 'abort-multipart-first',
+                requiresMultipartAbort: true,
+            };
+        throw new MultipartStreamConsumptionError({
+            completionAuthorized: false,
+            kind: failure.kind,
+            cause: failure.cause,
+            expectedBytes: optionsArg.plan.objectSize,
+            observedBytes,
+            partCallbacksStarted,
+            completedPartNumbers: [...completedPartNumbers].sort((leftArg, rightArg) => {
+                return leftArg - rightArg;
+            }),
+            cleanup: {
+                callbacks: callbacksSettled ? 'settled' : 'detached',
+                reader: readerCleanupSettled && readerCleanup
+                    ? readerCleanup
+                    : {
+                        status: 'cancel-detached',
+                    },
+            },
+            retry,
+        }, {
+            callbackSettlement,
+            ownedSettlement,
+        });
+    }
+    finally {
+        optionsArg.signal?.removeEventListener('abort', handleAbort);
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // Detached reader cancellation retains ownership until it settles.
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"internal.multipart.stream.js","sourceRoot":"","sources":["../../ts/objectstorage/internal.multipart.stream.ts"],"names":[],"mappings":"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"}

package/dist_ts/objectstorage/internal.multipart.types.d.ts

@@ -0,0 +1,82 @@
+export interface IMultipartPlanningOptions {
+    objectSize: number;
+    requestedPartSize?: number;
+    requestedConcurrency?: number;
+}
+interface IMultipartUploadPlanBase {
+    objectSize: number;
+    concurrency: number;
+    maximumBufferedBytes: number;
+}
+export interface IMultipartZeroUploadPlan extends IMultipartUploadPlanBase {
+    classification: 'zero';
+    objectSize: 0;
+    partSize: 0;
+    partCount: 0;
+    maximumBufferedBytes: 0;
+}
+export interface IMultipartDataUploadPlan extends IMultipartUploadPlanBase {
+    classification: 'multipart';
+    partSize: number;
+    partCount: number;
+}
+export type TMultipartUploadPlan = IMultipartZeroUploadPlan | IMultipartDataUploadPlan;
+export interface IMultipartStreamPart {
+    partNumber: number;
+    byteOffset: number;
+    isLastPart: boolean;
+    /**
+     * An exact, exclusively owned copy. The consumer never mutates or reuses it.
+     */
+    data: Uint8Array;
+    signal: AbortSignal;
+}
+export interface IConsumeExactMultipartStreamOptions {
+    readableStream: ReadableStream<Uint8Array>;
+    plan: TMultipartUploadPlan;
+    onPart: (part: IMultipartStreamPart) => Promise<void>;
+    signal?: AbortSignal;
+    /** Internal failure-teardown bound (default and maximum: 30000ms). */
+    failureSettlementTimeoutMs?: number;
+}
+export interface IMultipartStreamConsumptionResult {
+    completionAuthorized: true;
+    bytesConsumed: number;
+    partsConsumed: number;
+    peakBufferedBytes: number;
+    maximumBufferedBytes: number;
+}
+export type TMultipartStreamFailureKind = 'aborted' | 'source-read' | 'source-buffer-limit' | 'source-empty-chunk-limit' | 'source-short' | 'source-extra' | 'part-callback';
+export type TMultipartOwnedReaderCleanup = {
+    status: 'closed';
+} | {
+    status: 'cancelled';
+} | {
+    status: 'cancel-failed';
+    cause: unknown;
+} | {
+    status: 'cancel-detached';
+};
+export interface IMultipartOwnedCleanupState {
+    callbacks: 'settled' | 'detached';
+    reader: TMultipartOwnedReaderCleanup;
+}
+export type TMultipartRetryState = {
+    disposition: 'safe-to-retry';
+    requiresMultipartAbort: false;
+} | {
+    disposition: 'abort-multipart-first';
+    requiresMultipartAbort: true;
+};
+export interface IMultipartStreamFailureState {
+    completionAuthorized: false;
+    kind: TMultipartStreamFailureKind;
+    cause?: unknown;
+    expectedBytes: number;
+    observedBytes: number;
+    partCallbacksStarted: number;
+    completedPartNumbers: number[];
+    cleanup: IMultipartOwnedCleanupState;
+    retry: TMultipartRetryState;
+}
+export {};

package/dist_ts/objectstorage/internal.multipart.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJuYWwubXVsdGlwYXJ0LnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvb2JqZWN0c3RvcmFnZS9pbnRlcm5hbC5tdWx0aXBhcnQudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/objectstorage/plugins.d.ts

@@ -0,0 +1,17 @@
+import * as crypto from 'node:crypto';
+import * as path from 'node:path';
+import * as stream from 'node:stream';
+export { crypto, path, stream };
+import * as smartmime from '@push.rocks/smartmime';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smartstream from '@push.rocks/smartstream';
+import * as smartstring from '@push.rocks/smartstring';
+import * as smartunique from '@push.rocks/smartunique';
+export { smartmime, smartpath, smartpromise, smartrx, smartstream, smartstring, smartunique };
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass, };
+import * as s3 from '@aws-sdk/client-s3';
+import { Minimatch } from 'minimatch';
+export { s3, Minimatch, };