@lossless.org/objectstorage 9.0.0

package/dist_ts/index.js

@@ -0,0 +1,885 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+const resourceFenceV1Limits = {
+    maximumObjects: 10_000,
+    maximumObjectBytes: 64 * 1024 * 1024,
+    maximumImportBytes: 64 * 1024 * 1024,
+    maximumKeyBytes: 1024,
+    maximumMetadataEntries: 64,
+    maximumMetadataBytes: 8 * 1024,
+    maximumTotalKeyBytes: 1024 * 1024,
+    maximumTotalMetadataBytes: 1024 * 1024,
+    maximumIdentifierBytes: 256,
+};
+const resourceFenceV1Uint64 = (valueArg) => {
+    if (!Number.isSafeInteger(valueArg) || valueArg < 0) {
+        throw new Error('ObjectStorage resource fence v1 integers must be non-negative safe integers.');
+    }
+    const encoded = Buffer.alloc(8);
+    encoded.writeBigUInt64BE(BigInt(valueArg));
+    return encoded;
+};
+const resourceFenceV1Utf8 = (valueArg, fieldArg) => {
+    if (typeof valueArg !== 'string') {
+        throw new Error(`${fieldArg} must be a string.`);
+    }
+    const encoded = Buffer.from(valueArg, 'utf8');
+    if (encoded.toString('utf8') !== valueArg) {
+        throw new Error(`${fieldArg} must contain valid Unicode scalar values.`);
+    }
+    return encoded;
+};
+const compareResourceFenceV1Utf8 = (leftArg, rightArg) => Buffer.compare(Buffer.from(leftArg, 'utf8'), Buffer.from(rightArg, 'utf8'));
+const assertResourceFenceV1BucketName = (bucketNameArg) => {
+    const encoded = resourceFenceV1Utf8(bucketNameArg, 'bucketName');
+    const ipv4Parts = bucketNameArg.split('.');
+    const isIpv4Address = ipv4Parts.length === 4 && ipv4Parts.every((part) => /^[0-9]+$/.test(part) && Number(part) <= 255);
+    if (encoded.length < 3
+        || encoded.length > 63
+        || !/^[a-z0-9][a-z0-9.-]*[a-z0-9]$/.test(bucketNameArg)
+        || bucketNameArg.includes('..')
+        || isIpv4Address) {
+        throw new Error('bucketName is not a canonical S3 bucket name.');
+    }
+};
+const assertResourceFenceV1Identifier = (valueArg, fieldArg) => {
+    const encoded = resourceFenceV1Utf8(valueArg, fieldArg);
+    if (encoded.length === 0
+        || encoded.length > resourceFenceV1Limits.maximumIdentifierBytes
+        || !/^[A-Za-z0-9][A-Za-z0-9._:@-]*$/.test(valueArg)) {
+        throw new Error(`${fieldArg} is not a canonical identifier.`);
+    }
+};
+const canonicalResourceFenceV1Metadata = (metadataArg, objectKeyArg) => {
+    if (!metadataArg || typeof metadataArg !== 'object' || Array.isArray(metadataArg)) {
+        throw new Error(`Object '${objectKeyArg}' metadata must be an object.`);
+    }
+    const entries = Object.entries(metadataArg);
+    if (entries.length > resourceFenceV1Limits.maximumMetadataEntries) {
+        throw new Error(`Object '${objectKeyArg}' has too many metadata entries.`);
+    }
+    for (const [key, value] of entries) {
+        const keyBytes = resourceFenceV1Utf8(key, `Object '${objectKeyArg}' metadata key`);
+        const valueBytes = resourceFenceV1Utf8(value, `Object '${objectKeyArg}' metadata value`);
+        if (keyBytes.length === 0
+            || keyBytes.length > 128
+            || valueBytes.length > 2048
+            || keyBytes.some((byte) => byte <= 0x1f || byte === 0x7f)
+            || valueBytes.some((byte) => (byte <= 0x1f && byte !== 0x09) || byte === 0x7f)) {
+            throw new Error(`Object '${objectKeyArg}' metadata is invalid.`);
+        }
+    }
+    entries.sort(([left], [right]) => compareResourceFenceV1Utf8(left, right));
+    const encoded = Buffer.from(`{${entries.map(([key, value]) => `${JSON.stringify(key)}:${JSON.stringify(value)}`).join(',')}}`, 'utf8');
+    if (encoded.length > resourceFenceV1Limits.maximumMetadataBytes) {
+        throw new Error(`Object '${objectKeyArg}' metadata exceeds its size limit.`);
+    }
+    return encoded;
+};
+/**
+ * Computes the canonical provider-side effective payload digest for resource
+ * fencing v1. This intentionally excludes backup timestamps and source bucket
+ * names, matching the Rust engine's replacement and exact-delete profiles.
+ */
+export const computeObjectStorageResourceFenceEffectivePayloadSha256V1 = (payloadArg) => {
+    if (payloadArg.version !== 1) {
+        throw new Error('ObjectStorage resource fence effective payload version is unsupported.');
+    }
+    assertResourceFenceV1BucketName(payloadArg.bucketName);
+    const hash = plugins.crypto.createHash('sha256');
+    const digestField = (valueArg) => {
+        const value = typeof valueArg === 'string'
+            ? resourceFenceV1Utf8(valueArg, 'resource fence digest field')
+            : valueArg;
+        hash.update(resourceFenceV1Uint64(value.length));
+        hash.update(value);
+    };
+    if (payloadArg.kind === 'smartstorage.bucket.delete.v1') {
+        assertResourceFenceV1Identifier(payloadArg.accessKeyId, 'accessKeyId');
+        digestField(payloadArg.kind);
+        digestField(payloadArg.bucketName);
+        digestField(payloadArg.accessKeyId);
+        if (payloadArg.holdPublication === true) {
+            digestField('smartstorage.resource-fence.hold-publication.v1');
+            digestField(Buffer.from([1]));
+        }
+        return hash.digest('hex');
+    }
+    if (payloadArg.kind === 'smartstorage.bucket.ensure.v1') {
+        assertResourceFenceV1Identifier(payloadArg.accessKeyId, 'accessKeyId');
+        const secretAccessKey = resourceFenceV1Utf8(payloadArg.secretAccessKey, 'secretAccessKey');
+        if (!payloadArg.secretAccessKey.trim()) {
+            throw new Error('secretAccessKey must not be empty.');
+        }
+        const region = resourceFenceV1Utf8(payloadArg.region, 'region');
+        if (!payloadArg.region.trim()) {
+            throw new Error('region must not be empty.');
+        }
+        digestField(payloadArg.kind);
+        digestField(payloadArg.bucketName);
+        digestField(payloadArg.accessKeyId);
+        digestField(plugins.crypto.createHash('sha256').update(secretAccessKey).digest('hex'));
+        digestField(region);
+        if (payloadArg.retention) {
+            if (payloadArg.retention.mode !== 'compliance'
+                || !/^[A-Za-z0-9._-]{1,96}$/.test(payloadArg.retention.policyId)
+                || !Number.isSafeInteger(payloadArg.retention.retentionDurationSeconds)
+                || payloadArg.retention.retentionDurationSeconds <= 0
+                || payloadArg.retention.retentionDurationSeconds > 100 * 366 * 24 * 60 * 60) {
+                throw new Error('retention must contain canonical compliance-retention intent.');
+            }
+            digestField('smartstorage.bucket.retention.v1');
+            digestField(payloadArg.retention.mode);
+            digestField(payloadArg.retention.policyId);
+            digestField(resourceFenceV1Uint64(payloadArg.retention.retentionDurationSeconds));
+        }
+        return hash.digest('hex');
+    }
+    if (payloadArg.kind !== 'smartstorage.bucket.replace.v1') {
+        throw new Error('ObjectStorage resource fence effective payload kind is unsupported.');
+    }
+    if (payloadArg.accessKeyId !== undefined) {
+        assertResourceFenceV1Identifier(payloadArg.accessKeyId, 'accessKeyId');
+    }
+    const source = payloadArg.source;
+    if (source.format !== 'smartstorage.bucket.v1') {
+        throw new Error('source format must be smartstorage.bucket.v1.');
+    }
+    assertResourceFenceV1BucketName(source.bucketName);
+    if (!Number.isSafeInteger(source.exportedAt) || source.exportedAt < 0) {
+        throw new Error('source exportedAt must be a non-negative safe integer.');
+    }
+    if (!Array.isArray(source.objects) || source.objects.length > resourceFenceV1Limits.maximumObjects) {
+        throw new Error(`source exceeds the ${resourceFenceV1Limits.maximumObjects}-object limit.`);
+    }
+    const logicalKeys = new Set();
+    let totalBytes = 0;
+    let totalKeyBytes = 0;
+    let totalMetadataBytes = 0;
+    const prepared = source.objects.map((object) => {
+        const keyBytes = resourceFenceV1Utf8(object.key, 'object key');
+        if (keyBytes.length === 0
+            || keyBytes.length > resourceFenceV1Limits.maximumKeyBytes) {
+            throw new Error(`Object key '${object.key}' must contain between 1 and ${resourceFenceV1Limits.maximumKeyBytes} UTF-8 bytes.`);
+        }
+        if (logicalKeys.has(object.key)) {
+            throw new Error(`source contains duplicate object key '${object.key}'.`);
+        }
+        logicalKeys.add(object.key);
+        totalKeyBytes += keyBytes.length;
+        if (totalKeyBytes > resourceFenceV1Limits.maximumTotalKeyBytes) {
+            throw new Error(`source exceeds the ${resourceFenceV1Limits.maximumTotalKeyBytes}-byte aggregate key limit.`);
+        }
+        if (!Number.isSafeInteger(object.size)
+            || object.size < 0
+            || object.size > resourceFenceV1Limits.maximumObjectBytes
+            || object.dataHex.length !== object.size * 2
+            || !/^[0-9a-f]*$/.test(object.dataHex)) {
+            throw new Error(`Object '${object.key}' dataHex or size is not canonical.`);
+        }
+        const data = Buffer.from(object.dataHex, 'hex');
+        if (data.length !== object.size) {
+            throw new Error(`Object '${object.key}' size does not match dataHex.`);
+        }
+        if (!/^[0-9a-f]{32}$/.test(object.md5)) {
+            throw new Error(`Object '${object.key}' md5 is not canonical.`);
+        }
+        const actualMd5 = plugins.crypto.createHash('md5').update(data).digest('hex');
+        if (actualMd5 !== object.md5) {
+            throw new Error(`Object '${object.key}' md5 does not match payload.`);
+        }
+        const metadata = canonicalResourceFenceV1Metadata(object.metadata, object.key);
+        totalMetadataBytes += metadata.length;
+        if (totalMetadataBytes > resourceFenceV1Limits.maximumTotalMetadataBytes) {
+            throw new Error(`source exceeds the ${resourceFenceV1Limits.maximumTotalMetadataBytes}-byte aggregate metadata limit.`);
+        }
+        totalBytes += object.size;
+        if (totalBytes > resourceFenceV1Limits.maximumImportBytes) {
+            throw new Error(`source exceeds the ${resourceFenceV1Limits.maximumImportBytes}-byte import limit.`);
+        }
+        return {
+            key: object.key,
+            size: object.size,
+            md5: object.md5,
+            metadata,
+            dataSha256: plugins.crypto.createHash('sha256').update(data).digest('hex'),
+        };
+    });
+    prepared.sort((left, right) => compareResourceFenceV1Utf8(left.key, right.key));
+    digestField(payloadArg.kind);
+    digestField(payloadArg.bucketName);
+    if (payloadArg.accessKeyId !== undefined) {
+        digestField(payloadArg.accessKeyId);
+    }
+    digestField(resourceFenceV1Uint64(prepared.length));
+    for (const object of prepared) {
+        digestField(object.key);
+        digestField(resourceFenceV1Uint64(object.size));
+        digestField(object.md5);
+        digestField(object.metadata);
+        digestField(object.dataSha256);
+    }
+    if (payloadArg.holdPublication === true) {
+        digestField('smartstorage.resource-fence.hold-publication.v1');
+        digestField(Buffer.from([1]));
+    }
+    return hash.digest('hex');
+};
+export const objectStorageResourceFenceErrorCodes = [
+    'EFENCE_REQUIRED',
+    'EFENCE_STALE',
+    'EFENCE_SCOPE_MISMATCH',
+    'EFENCE_UNSUPPORTED',
+    'EFENCE_MUTATION_MISMATCH',
+    'EFENCE_STATE_CORRUPT',
+    'EFENCE_RECEIPT_LIMIT',
+    'EFENCE_BUSY',
+    'EFENCE_OWNERSHIP_MISMATCH',
+    'EFENCE_PUBLICATION_HELD',
+    'EFENCE_PUBLICATION_MISMATCH',
+    'EFENCE_PUBLICATION_CAPABILITY',
+];
+export class ObjectStorageResourceFenceError extends Error {
+    code;
+    constructor(codeArg, messageArg, causeArg) {
+        super(`${codeArg}: ${messageArg}`, { cause: causeArg });
+        this.name = 'ObjectStorageResourceFenceError';
+        this.code = codeArg;
+    }
+}
+const normalizeResourceFenceError = (errorArg) => {
+    const error = errorArg instanceof Error ? errorArg : new Error(String(errorArg));
+    const match = /(EFENCE_[A-Z_]+):\s*(.*)$/s.exec(error.message);
+    if (!match ||
+        !objectStorageResourceFenceErrorCodes.includes(match[1])) {
+        return error;
+    }
+    return new ObjectStorageResourceFenceError(match[1], match[2], error);
+};
+/**
+ * Default configuration values
+ */
+const DEFAULT_CONFIG = {
+    server: {
+        port: 3000,
+        address: '0.0.0.0',
+        silent: false,
+        region: 'us-east-1',
+    },
+    storage: {
+        directory: paths.bucketsDir,
+        cleanSlate: false,
+    },
+    auth: {
+        enabled: false,
+        credentials: [
+            {
+                accessKeyId: 'STORAGE',
+                secretAccessKey: 'STORAGE',
+            },
+        ],
+    },
+    cors: {
+        enabled: false,
+        allowedOrigins: ['*'],
+        allowedMethods: ['GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'OPTIONS'],
+        allowedHeaders: ['*'],
+        exposedHeaders: ['ETag', 'x-amz-request-id', 'x-amz-version-id'],
+        maxAge: 86400,
+        allowCredentials: false,
+    },
+    logging: {
+        level: 'info',
+        format: 'text',
+        enabled: true,
+    },
+    limits: {
+        maxObjectSize: 5 * 1024 * 1024 * 1024, // 5GB
+        maxMetadataSize: 2048,
+        requestTimeout: 300000, // 5 minutes
+    },
+    multipart: {
+        expirationDays: 7,
+        cleanupIntervalMinutes: 60,
+    },
+};
+// A fenced import may contain 64 MiB of raw object data encoded as hexadecimal.
+// Keep this aligned with the bounded Rust management-line reader.
+const MAXIMUM_MANAGEMENT_PAYLOAD_BYTES = 144 * 1024 * 1024;
+function assertExactMountedDirectory(directoryArg, fieldArg) {
+    if (directoryArg.length === 0 ||
+        !plugins.path.isAbsolute(directoryArg) ||
+        plugins.path.normalize(directoryArg) !== directoryArg ||
+        plugins.path.resolve(directoryArg) !== directoryArg) {
+        throw new Error(`${fieldArg} must be a non-empty absolute lexically exact mountpoint without '.', '..', duplicate separators, or a trailing separator.`);
+    }
+}
+/**
+ * Merge user config with defaults (deep merge)
+ */
+function mergeConfig(userConfig) {
+    const userStorage = userConfig.storage || {};
+    const defaultDirectory = DEFAULT_CONFIG.storage.directory;
+    const legacyDirectory = userStorage.directory;
+    const configuredPool = userStorage.pool;
+    const configuredMountedPool = configuredPool?.backend.kind === 'mountedFs';
+    if (configuredMountedPool) {
+        assertExactMountedDirectory(configuredPool.directory, 'storage.pool.directory');
+        if (legacyDirectory !== undefined) {
+            assertExactMountedDirectory(legacyDirectory, 'storage.directory');
+            if (legacyDirectory !== configuredPool.directory) {
+                throw new Error('storage.directory and storage.pool.directory must be the same exact mountedFs path.');
+            }
+        }
+    }
+    const effectiveDirectory = configuredPool?.directory || legacyDirectory || defaultDirectory;
+    if (configuredPool &&
+        !configuredMountedPool &&
+        legacyDirectory &&
+        plugins.path.resolve(configuredPool.directory) !==
+            plugins.path.resolve(legacyDirectory)) {
+        throw new Error('storage.directory and storage.pool.directory must resolve to the same path.');
+    }
+    const pool = configuredPool
+        ? {
+            ...configuredPool,
+            directory: plugins.path.resolve(effectiveDirectory),
+            backend: { ...configuredPool.backend },
+        }
+        : {
+            id: 'default',
+            directory: plugins.path.resolve(effectiveDirectory),
+            backend: { kind: 'localFs' },
+        };
+    if (!/^[a-z][a-z0-9-]{0,62}$/.test(pool.id)) {
+        throw new Error('storage.pool.id must start with a lowercase letter and contain at most 63 lowercase letters, digits, or hyphens.');
+    }
+    if (pool.backend.kind === 'mountedFs' &&
+        pool.backend.expectedSource.trim().length === 0) {
+        throw new Error('storage.pool.backend.expectedSource must not be empty for mountedFs.');
+    }
+    if (pool.backend.kind === 'mountedFs' && userStorage.cleanSlate) {
+        throw new Error('storage.cleanSlate is not permitted for mountedFs pools.');
+    }
+    return {
+        server: {
+            ...DEFAULT_CONFIG.server,
+            ...(userConfig.server || {}),
+        },
+        storage: {
+            ...DEFAULT_CONFIG.storage,
+            ...userStorage,
+            directory: pool.directory,
+            pool,
+        },
+        auth: {
+            ...DEFAULT_CONFIG.auth,
+            ...(userConfig.auth || {}),
+        },
+        cors: {
+            ...DEFAULT_CONFIG.cors,
+            ...(userConfig.cors || {}),
+        },
+        logging: {
+            ...DEFAULT_CONFIG.logging,
+            ...(userConfig.logging || {}),
+        },
+        limits: {
+            ...DEFAULT_CONFIG.limits,
+            ...(userConfig.limits || {}),
+        },
+        multipart: {
+            ...DEFAULT_CONFIG.multipart,
+            ...(userConfig.multipart || {}),
+        },
+        ...(userConfig.cluster ? { cluster: userConfig.cluster } : {}),
+    };
+}
+function createAccessKeyId() {
+    return `SS${plugins.crypto.randomBytes(10).toString('hex').toUpperCase()}`;
+}
+function createSecretAccessKey() {
+    return plugins.crypto.randomBytes(32).toString('hex');
+}
+function getRustStorageBinaryNames() {
+    const platformTargetMap = {
+        'linux:x64': 'linux_amd64',
+        'linux:arm64': 'linux_arm64',
+        'darwin:x64': 'macos_amd64',
+        'darwin:arm64': 'macos_arm64',
+    };
+    const platformTarget = platformTargetMap[`${process.platform}:${process.arch}`];
+    return [platformTarget ? `ruststorage_${platformTarget}` : null, 'ruststorage']
+        .filter((binaryNameArg) => Boolean(binaryNameArg));
+}
+/**
+ * Main ObjectStorage class - production-ready S3-compatible storage server
+ */
+export class ObjectStorage {
+    // STATIC
+    static async createAndStart(configArg = {}) {
+        const objectStorageInstance = new ObjectStorage(configArg);
+        await objectStorageInstance.start();
+        return objectStorageInstance;
+    }
+    static async probeStoragePool(poolArg) {
+        const objectStorageInstance = new ObjectStorage({
+            server: { silent: true },
+            storage: {
+                directory: poolArg.directory,
+                cleanSlate: false,
+                pool: poolArg,
+            },
+        });
+        await objectStorageInstance.ensureLocalBinariesExecutable();
+        const spawned = await objectStorageInstance.bridge.spawn();
+        if (!spawned) {
+            throw new Error('Failed to spawn ruststorage binary. Make sure it is compiled (pnpm build).');
+        }
+        try {
+            return await objectStorageInstance.bridge.sendCommand('probeStoragePool', {
+                pool: objectStorageInstance.config.storage
+                    .pool,
+            });
+        }
+        finally {
+            await objectStorageInstance.bridge.terminate();
+        }
+    }
+    // INSTANCE
+    config;
+    localBinaryPaths;
+    bridge;
+    running = false;
+    completedStopResult;
+    startPromise;
+    stopPromise;
+    bridgeOwned = false;
+    stopRequested = false;
+    stopCompleted = false;
+    constructor(configArg = {}) {
+        this.config = mergeConfig(configArg);
+        this.localBinaryPaths = getRustStorageBinaryNames().map((binaryNameArg) => plugins.path.join(paths.packageDir, 'dist_rust', binaryNameArg));
+        this.bridge = new plugins.RustBridge({
+            binaryName: 'ruststorage',
+            localPaths: this.localBinaryPaths,
+            readyTimeoutMs: 30000,
+            requestTimeoutMs: 300000,
+            maxPayloadSize: MAXIMUM_MANAGEMENT_PAYLOAD_BYTES,
+        });
+    }
+    async ensureLocalBinariesExecutable() {
+        for (const localBinaryPath of this.localBinaryPaths) {
+            const binaryStat = await plugins.fs.stat(localBinaryPath).catch((errorArg) => {
+                if (errorArg.code !== 'ENOENT') {
+                    throw errorArg;
+                }
+                return null;
+            });
+            if (!binaryStat || (binaryStat.mode & 0o111) !== 0) {
+                continue;
+            }
+            await plugins.fs.chmod(localBinaryPath, binaryStat.mode | 0o755);
+        }
+    }
+    start() {
+        if (this.stopRequested && !this.stopCompleted) {
+            return Promise.reject(new Error('Storage shutdown must complete before restarting.'));
+        }
+        if (this.startPromise) {
+            return this.startPromise;
+        }
+        if (this.running) {
+            return Promise.resolve();
+        }
+        if (this.bridgeOwned) {
+            return Promise.reject(new Error('Storage startup cleanup must complete before restarting.'));
+        }
+        this.stopRequested = false;
+        this.stopCompleted = false;
+        this.stopPromise = undefined;
+        this.completedStopResult = undefined;
+        const start = this.startInternal();
+        this.startPromise = start;
+        const releaseStart = () => {
+            if (this.startPromise === start) {
+                this.startPromise = undefined;
+            }
+        };
+        start.then(releaseStart, releaseStart);
+        return start;
+    }
+    async startInternal() {
+        try {
+            await this.ensureLocalBinariesExecutable();
+            // A failed spawn can still own a transport whose termination needs retrying.
+            this.bridgeOwned = true;
+            const spawned = await this.bridge.spawn();
+            if (!spawned) {
+                throw new Error('Failed to spawn ruststorage binary. Make sure it is compiled (pnpm build).');
+            }
+            await this.bridge.sendCommand('start', { config: this.config });
+        }
+        catch (error) {
+            try {
+                if (this.bridgeOwned) {
+                    await this.bridge.terminate();
+                    this.bridgeOwned = false;
+                }
+            }
+            catch (terminationError) {
+                throw new AggregateError([error, terminationError], 'Storage startup failed and Rust bridge termination could not be confirmed.', { cause: error });
+            }
+            throw error;
+        }
+        this.running = true;
+        if (!this.config.server.silent) {
+            console.log('storage server is running');
+        }
+    }
+    async getStorageDescriptor(optionsArg) {
+        const cred = this.config.auth.credentials[0] || {
+            accessKeyId: 'STORAGE',
+            secretAccessKey: 'STORAGE',
+        };
+        const descriptor = {
+            endpoint: this.config.server.address === '0.0.0.0' ? 'localhost' : this.config.server.address,
+            port: this.config.server.port,
+            useSsl: false,
+            accessKey: cred.accessKeyId,
+            accessSecret: cred.secretAccessKey,
+            bucketName: '',
+        };
+        return {
+            ...descriptor,
+            ...(optionsArg ? optionsArg : {}),
+        };
+    }
+    getEndpoint() {
+        return this.config.server.address === '0.0.0.0' ? 'localhost' : this.config.server.address;
+    }
+    buildBucketTenantDescriptor(credential, bucketNameArg) {
+        const bucketName = credential.bucketName || bucketNameArg;
+        const region = credential.region || this.config.server.region || 'us-east-1';
+        const endpoint = this.getEndpoint();
+        const port = this.config.server.port;
+        const useSsl = false;
+        const descriptor = {
+            endpoint,
+            port,
+            region,
+            bucket: bucketName,
+            bucketName,
+            accessKeyId: credential.accessKeyId,
+            secretAccessKey: credential.secretAccessKey,
+            accessKey: credential.accessKeyId,
+            accessSecret: credential.secretAccessKey,
+            useSsl,
+            ssl: useSsl,
+            env: {
+                S3_ENDPOINT: endpoint,
+                S3_PORT: String(port),
+                S3_REGION: region,
+                S3_BUCKET: bucketName,
+                S3_ACCESS_KEY_ID: credential.accessKeyId,
+                S3_SECRET_ACCESS_KEY: credential.secretAccessKey,
+                S3_USE_SSL: String(useSsl),
+                AWS_ACCESS_KEY_ID: credential.accessKeyId,
+                AWS_SECRET_ACCESS_KEY: credential.secretAccessKey,
+                AWS_REGION: region,
+            },
+        };
+        if (credential.resourceFence) {
+            descriptor.resourceFence = credential.resourceFence;
+        }
+        if (credential.retention) {
+            descriptor.retention = credential.retention;
+        }
+        return descriptor;
+    }
+    assertTenantAuthEnabled() {
+        if (!this.config.auth.enabled) {
+            throw new Error('Bucket tenant APIs require auth.enabled=true.');
+        }
+    }
+    async createBucket(bucketNameArg) {
+        try {
+            await this.bridge.sendCommand('createBucket', { name: bucketNameArg });
+            return { name: bucketNameArg };
+        }
+        catch (error) {
+            throw normalizeResourceFenceError(error);
+        }
+    }
+    async createBucketTenant(tenantArg) {
+        this.assertTenantAuthEnabled();
+        try {
+            const credential = await this.bridge.sendCommand('createBucketTenant', {
+                bucketName: tenantArg.bucketName,
+                accessKeyId: tenantArg.accessKeyId || createAccessKeyId(),
+                secretAccessKey: tenantArg.secretAccessKey || createSecretAccessKey(),
+                region: tenantArg.region || this.config.server.region,
+                ...(tenantArg.retention ? { retention: tenantArg.retention } : {}),
+            });
+            return this.buildBucketTenantDescriptor(credential, tenantArg.bucketName);
+        }
+        catch (error) {
+            throw normalizeResourceFenceError(error);
+        }
+    }
+    async ensureBucketTenant(tenantArg) {
+        this.assertTenantAuthEnabled();
+        try {
+            const credential = await this.bridge.sendCommand('ensureBucketTenant', {
+                ...tenantArg,
+                region: tenantArg.region || this.config.server.region,
+            });
+            return this.buildBucketTenantDescriptor(credential, tenantArg.bucketName);
+        }
+        catch (error) {
+            throw normalizeResourceFenceError(error);
+        }
+    }
+    async deleteBucketTenant(tenantArg) {
+        this.assertTenantAuthEnabled();
+        try {
+            await this.bridge.sendCommand('deleteBucketTenant', tenantArg);
+        }
+        catch (error) {
+            throw normalizeResourceFenceError(error);
+        }
+    }
+    async rotateBucketTenantCredentials(tenantArg) {
+        this.assertTenantAuthEnabled();
+        try {
+            const credential = await this.bridge.sendCommand('rotateBucketTenantCredentials', {
+                bucketName: tenantArg.bucketName,
+                accessKeyId: tenantArg.accessKeyId || createAccessKeyId(),
+                secretAccessKey: tenantArg.secretAccessKey || createSecretAccessKey(),
+                region: tenantArg.region || this.config.server.region,
+            });
+            return this.buildBucketTenantDescriptor(credential, tenantArg.bucketName);
+        }
+        catch (error) {
+            throw normalizeResourceFenceError(error);
+        }
+    }
+    async listBucketTenants() {
+        this.assertTenantAuthEnabled();
+        return this.bridge.sendCommand('listBucketTenants', {});
+    }
+    async getBucketTenantDescriptor(optionsArg) {
+        this.assertTenantAuthEnabled();
+        const credential = await this.bridge.sendCommand('getBucketTenantCredential', {
+            bucketName: optionsArg.bucketName,
+        });
+        return this.buildBucketTenantDescriptor(credential, optionsArg.bucketName);
+    }
+    async getBucketRetentionCapability() {
+        return this.bridge.sendCommand('getBucketRetentionCapability', {});
+    }
+    async getBucketRetentionReceipt(optionsArg) {
+        return this.bridge.sendCommand('getBucketRetentionReceipt', optionsArg);
+    }
+    async getBucketMigrationCapability() {
+        return this.bridge.sendCommand('getBucketMigrationCapability', {});
+    }
+    async createSourceMigration(optionsArg) {
+        return this.bridge.sendCommand('createSourceMigration', optionsArg);
+    }
+    async createDestinationMigration(optionsArg) {
+        return this.bridge.sendCommand('createDestinationMigration', optionsArg);
+    }
+    async transitionSourceMigration(optionsArg) {
+        return this.bridge.sendCommand('transitionSourceMigration', optionsArg);
+    }
+    async transitionDestinationMigration(optionsArg) {
+        return this.bridge.sendCommand('transitionDestinationMigration', optionsArg);
+    }
+    async cleanupSourceMigration(optionsArg) {
+        try {
+            return await this.bridge.sendCommand('cleanupSourceMigration', optionsArg);
+        }
+        catch (error) {
+            throw normalizeResourceFenceError(error);
+        }
+    }
+    async inspectBucketMigration(optionsArg) {
+        return this.bridge.sendCommand('inspectBucketMigration', optionsArg);
+    }
+    async exportBucket(optionsArg) {
+        return this.bridge.sendCommand('exportBucket', { bucketName: optionsArg.bucketName });
+    }
+    async importBucket(optionsArg) {
+        try {
+            return await this.bridge.sendCommand('importBucket', optionsArg);
+        }
+        catch (error) {
+            throw normalizeResourceFenceError(error);
+        }
+    }
+    async deleteBucket(optionsArg) {
+        try {
+            return await this.bridge.sendCommand('deleteBucket', optionsArg);
+        }
+        catch (error) {
+            throw normalizeResourceFenceError(error);
+        }
+    }
+    async commitResourcePublication(optionsArg) {
+        try {
+            return await this.bridge.sendCommand('commitResourcePublication', optionsArg);
+        }
+        catch (error) {
+            throw normalizeResourceFenceError(error);
+        }
+    }
+    async getResourceFencingCapability() {
+        return this.bridge.sendCommand('getResourceFencingCapability', {});
+    }
+    async getStorageStats() {
+        return this.bridge.sendCommand('getStorageStats', {});
+    }
+    async getStoragePoolDiagnostic() {
+        return this.bridge.sendCommand('getStoragePoolDiagnostic', {});
+    }
+    async listBucketSummaries() {
+        return this.bridge.sendCommand('listBucketSummaries', {});
+    }
+    async listCredentials() {
+        return this.bridge.sendCommand('listCredentials', {});
+    }
+    /**
+     * Trusted process-local administrative override. Resource lifecycle code
+     * must use fenced ensure/delete instead; completed exact receipts fail closed
+     * if this override introduces ownership or credential-material drift.
+     */
+    async replaceCredentials(credentials) {
+        await this.bridge.sendCommand('replaceCredentials', { credentials });
+        this.config.auth.credentials = credentials.map((credential) => ({ ...credential }));
+    }
+    async getClusterHealth() {
+        return this.bridge.sendCommand('getClusterHealth', {});
+    }
+    async getHealth() {
+        if (!this.running) {
+            return {
+                ok: false,
+                running: false,
+                storageDirectory: this.config.storage.directory || paths.bucketsDir,
+                storageLocations: [],
+                auth: {
+                    enabled: this.config.auth.enabled,
+                    credentialCount: this.config.auth.credentials.length,
+                    tenantCredentialCount: 0,
+                },
+                bucketCount: 0,
+                objectCount: 0,
+                totalBytes: 0,
+                cluster: { enabled: false },
+                resourceFencingVersion: 1,
+                resourceFencingSupported: false,
+                resourceFencingRequiresDrain: true,
+                resourcePublicationHoldVersion: 1,
+                resourcePublicationHoldSupported: false,
+                resourcePublicationHoldRequiresExternalDrain: false,
+            };
+        }
+        const [stats, credentials, tenants, cluster, resourceFencing] = await Promise.all([
+            this.getStorageStats(),
+            this.listCredentials(),
+            this.config.auth.enabled ? this.listBucketTenants() : Promise.resolve([]),
+            this.getClusterHealth(),
+            this.getResourceFencingCapability(),
+        ]);
+        return {
+            ok: true,
+            running: true,
+            storageDirectory: stats.storageDirectory,
+            storageLocations: stats.storageLocations || [],
+            auth: {
+                enabled: this.config.auth.enabled,
+                credentialCount: credentials.length,
+                tenantCredentialCount: tenants.length,
+            },
+            bucketCount: stats.bucketCount,
+            objectCount: stats.totalObjectCount,
+            totalBytes: stats.totalStorageBytes,
+            cluster,
+            resourceFencingVersion: resourceFencing.version,
+            resourceFencingSupported: resourceFencing.supported,
+            resourceFencingRequiresDrain: resourceFencing.requiresDrain,
+            resourcePublicationHoldVersion: resourceFencing.publicationHoldVersion,
+            resourcePublicationHoldSupported: resourceFencing.publicationHoldSupported,
+            resourcePublicationHoldRequiresExternalDrain: resourceFencing.publicationHoldRequiresExternalDrain,
+            resourceFencingReason: resourceFencing.reason,
+        };
+    }
+    async getMetrics() {
+        const health = await this.getHealth();
+        const clusterEnabled = health.cluster.enabled;
+        return {
+            bucketCount: health.bucketCount,
+            objectCount: health.objectCount,
+            totalBytes: health.totalBytes,
+            authCredentialCount: health.auth.credentialCount,
+            tenantCredentialCount: health.auth.tenantCredentialCount,
+            clusterEnabled,
+            prometheusText: [
+                '# HELP objectstorage_buckets_total Runtime bucket count.',
+                '# TYPE objectstorage_buckets_total gauge',
+                `objectstorage_buckets_total ${health.bucketCount}`,
+                '# HELP objectstorage_objects_total Runtime object count.',
+                '# TYPE objectstorage_objects_total gauge',
+                `objectstorage_objects_total ${health.objectCount}`,
+                '# HELP objectstorage_storage_bytes_total Runtime storage bytes.',
+                '# TYPE objectstorage_storage_bytes_total gauge',
+                `objectstorage_storage_bytes_total ${health.totalBytes}`,
+                '# HELP objectstorage_tenant_credentials_total Scoped bucket tenant credential count.',
+                '# TYPE objectstorage_tenant_credentials_total gauge',
+                `objectstorage_tenant_credentials_total ${health.auth.tenantCredentialCount}`,
+                '# HELP objectstorage_cluster_enabled Cluster mode enabled.',
+                '# TYPE objectstorage_cluster_enabled gauge',
+                `objectstorage_cluster_enabled ${clusterEnabled ? 1 : 0}`,
+            ].join('\n'),
+        };
+    }
+    /**
+     * Retains the Rust bridge when shutdown is incomplete so a later call can
+     * retry ownership draining. Completed terminal errors kill the bridge before
+     * they are rethrown.
+     */
+    stop() {
+        if (this.stopPromise) {
+            return this.stopPromise;
+        }
+        this.stopRequested = true;
+        const stop = this.stopInternal();
+        this.stopPromise = stop;
+        stop.then(undefined, () => {
+            if (!this.stopCompleted && this.stopPromise === stop) {
+                this.stopPromise = undefined;
+            }
+        });
+        return stop;
+    }
+    async stopInternal() {
+        if (this.startPromise) {
+            // Startup keeps its own rejection; stop joins only its resource ownership.
+            await Promise.allSettled([this.startPromise]);
+        }
+        if (this.bridgeOwned) {
+            if (this.running) {
+                this.completedStopResult ??= await this.bridge.sendCommand('stop', {});
+            }
+            await this.bridge.terminate();
+            this.bridgeOwned = false;
+            this.running = false;
+        }
+        this.stopCompleted = true;
+        if (this.completedStopResult?.terminalError) {
+            throw new Error(`Storage server shutdown completed with terminal errors: ${this.completedStopResult.terminalError}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":"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"}