@lossless.org/nosqldb 8.0.0

package/dist_ts/ts_nosqldb/index.d.ts

@@ -0,0 +1,14 @@
+export { NoSqlDbStorageRehearsal } from './classes.storagerehearsal.js';
+export { NoSqlDbStorageRehearsalError, noSqlDbStorageRehearsalErrorCodes } from './storage-rehearsal.js';
+export type { INoSqlDbStorageRehearsalOptions, INoSqlDbStorageRehearsalInput, INoSqlDbStorageRehearsalReceipt, INoSqlDbStorageRehearsalPreservation, TNoSqlDbStorageRehearsalErrorCode, } from './storage-rehearsal.js';
+export { NoSqlDbServer } from './server/classes.nosqldbserver.js';
+export type { TNoSqlDbFileStorageStartup } from './file-storage-startup.js';
+export type { INoSqlDbAuthOptions, INoSqlDbAuthUser, INoSqlDbOplogOptions, INoSqlDbServerOptions, INoSqlDbTlsOptions, } from './server/classes.nosqldbserver.js';
+export { RustDbBridge, NoSqlDbManagementOperationTerminationError, } from './rust-db-bridge.js';
+export type { IRustDbBridgeOptions, INoSqlDbQueryOptions, IOpLogEntry, IOpLogResult, IOpLogStats, IRevertResult, ICollectionInfo, IDocumentsResult, INoSqlDbMetrics, } from './rust-db-bridge.js';
+export type { INoSqlDbHealth, INoSqlDbResourceFence, INoSqlDbResourceFenceReceipt, INoSqlDbHeldPublicationReceipt, INoSqlDbCommitDatabasePublicationInput, INoSqlDbManagementOperationOptions, INoSqlDbDatabaseResourceFenceState, INoSqlDbDatabaseAllocationIdentity, INoSqlDbDatabaseAllocationLifecycle, INoSqlDbDatabaseAllocationReadAccessGrantIdentity, INoSqlDbIssueDatabaseAllocationReadAccessGrantInput, INoSqlDbIssueDatabaseAllocationReadAccessGrantResult, INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput, INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult, ILocalNoSqlDbOfflineInspectionLimits, ILocalNoSqlDbOfflinePhysicalNamespaceInspectionLimits, ILocalNoSqlDbOfflinePhysicalNamespaceInspection, ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult, ILocalNoSqlDbOfflineStringValueInspection, TLocalNoSqlDbOfflineStringValueInspectionResult, TNoSqlDbCommitDatabasePublicationResult, TNoSqlDbResourceFenceErrorCode, TNoSqlDbAllocationReadAccessGrantErrorCode, INoSqlDbDatabaseTenantInput, INoSqlDbAttestDatabaseTenantInput, INoSqlDbAttestDatabaseTenantResult, INoSqlDbEnsureDatabaseTenantInput, INoSqlDbEnsureDatabaseTenantResult, INoSqlDbAllocateDatabaseTenantInput, INoSqlDbAllocateDatabaseTenantResult, INoSqlDbDeleteDatabaseTenantInput, INoSqlDbRotateDatabaseTenantPasswordInput, INoSqlDbDatabaseTenantDescriptor, INoSqlDbDeleteDatabaseTenantResult, INoSqlDbDatabaseExportCollection, INoSqlDbDatabaseExport, INoSqlDbDatabaseExportLimits, INoSqlDbExportDatabaseInput, INoSqlDbDatabaseContentDigestLimits, INoSqlDbGetDatabaseContentDigestInput, INoSqlDbDatabaseContentDigest, INoSqlDbImportDatabaseInput, INoSqlDbImportDatabaseResult, } from './service-types.js';
+export { NoSqlDbAllocationReadAccessGrantError, normalizeNoSqlDbAllocationReadAccessGrantError, noSqlDbAllocationReadAccessGrantErrorCodes, NoSqlDbResourceFenceError, normalizeNoSqlDbResourceFenceError, noSqlDbResourceFenceErrorCodes, } from './service-types.js';
+export type { ILocalNoSqlDbStoppedStorageRootRelocationInput, ILocalNoSqlDbStoppedStorageRootRelocationReceipt, TLocalNoSqlDbStorageRootRelocationErrorCode, } from './storage-root-relocation.js';
+export { LocalNoSqlDbStorageRootRelocationError, localNoSqlDbStorageRootRelocationErrorCodes, } from './storage-root-relocation.js';
+export type { TNoSqlDbEffectivePayloadInputV1 } from './resource-fencing.js';
+export { createNoSqlDbEffectivePayloadSha256V1 } from './resource-fencing.js';

package/dist_ts/ts_nosqldb/index.js

@@ -0,0 +1,11 @@
+// NoSQLDB - Wire protocol compatible embedded database server
+export { NoSqlDbStorageRehearsal } from './classes.storagerehearsal.js';
+export { NoSqlDbStorageRehearsalError, noSqlDbStorageRehearsalErrorCodes } from './storage-rehearsal.js';
+// Export server (the main entry point for using NoSQLDB)
+export { NoSqlDbServer } from './server/classes.nosqldbserver.js';
+// Export bridge for advanced usage and its fail-stop ownership error.
+export { RustDbBridge, NoSqlDbManagementOperationTerminationError, } from './rust-db-bridge.js';
+export { NoSqlDbAllocationReadAccessGrantError, normalizeNoSqlDbAllocationReadAccessGrantError, noSqlDbAllocationReadAccessGrantErrorCodes, NoSqlDbResourceFenceError, normalizeNoSqlDbResourceFenceError, noSqlDbResourceFenceErrorCodes, } from './service-types.js';
+export { LocalNoSqlDbStorageRootRelocationError, localNoSqlDbStorageRootRelocationErrorCodes, } from './storage-root-relocation.js';
+export { createNoSqlDbEffectivePayloadSha256V1 } from './resource-fencing.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19ub3NxbGRiL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhEQUE4RDtBQUM5RCxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN4RSxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsaUNBQWlDLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQU96Ryx5REFBeUQ7QUFDekQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBVWxFLHNFQUFzRTtBQUN0RSxPQUFPLEVBQ0wsWUFBWSxFQUNaLDBDQUEwQyxHQUMzQyxNQUFNLHFCQUFxQixDQUFDO0FBNkQ3QixPQUFPLEVBQ0wscUNBQXFDLEVBQ3JDLDhDQUE4QyxFQUM5QywwQ0FBMEMsRUFDMUMseUJBQXlCLEVBQ3pCLGtDQUFrQyxFQUNsQyw4QkFBOEIsR0FDL0IsTUFBTSxvQkFBb0IsQ0FBQztBQU01QixPQUFPLEVBQ0wsc0NBQXNDLEVBQ3RDLDJDQUEyQyxHQUM1QyxNQUFNLDhCQUE4QixDQUFDO0FBRXRDLE9BQU8sRUFBRSxxQ0FBcUMsRUFBRSxNQUFNLHVCQUF1QixDQUFDIn0=

package/dist_ts/ts_nosqldb/offline-inspection.d.ts

@@ -0,0 +1,72 @@
+import type { ILocalNoSqlDbOfflinePhysicalNamespaceInspection, ILocalNoSqlDbOfflineStringValueInspection, INoSqlDbManagementOperationOptions } from './service-types.js';
+export declare const localNoSqlDbOfflineInspectionBounds: {
+    readonly maximumFolderPathBytes: 4095;
+    readonly maximumNamespaceComponentBytes: 255;
+    readonly maximumFieldNameBytes: 255;
+    readonly maximumMatchValueBytes: number;
+    readonly maximumRequestBytes: number;
+    readonly maximumTimeoutMs: 2147483647;
+    readonly limits: {
+        readonly maximumEntries: {
+            readonly minimum: 1;
+            readonly maximum: 100000;
+        };
+        readonly maximumTotalFileBytes: {
+            readonly minimum: 1;
+            readonly maximum: number;
+        };
+        readonly maximumRecords: {
+            readonly minimum: 1;
+            readonly maximum: 1000000000;
+        };
+        readonly maximumRecordBytes: {
+            readonly minimum: 5;
+            readonly maximum: number;
+        };
+        readonly maximumResultBytes: {
+            readonly minimum: 1;
+            readonly maximum: number;
+        };
+    };
+};
+export declare const localNoSqlDbOfflinePhysicalNamespaceInspectionBounds: {
+    readonly maximumFolderPathBytes: 4095;
+    readonly maximumRequestBytes: number;
+    readonly limits: {
+        readonly maximumDatabases: {
+            readonly minimum: 1;
+            readonly maximum: 1000000;
+        };
+        readonly maximumCollections: {
+            readonly minimum: 1;
+            readonly maximum: 1000000;
+        };
+        readonly maximumIndexes: {
+            readonly minimum: 1;
+            readonly maximum: 1000000;
+        };
+        readonly maximumEntries: {
+            readonly minimum: 1;
+            readonly maximum: 100000;
+        };
+        readonly maximumTotalFileBytes: {
+            readonly minimum: 1;
+            readonly maximum: number;
+        };
+        readonly maximumRecordsPerCollection: {
+            readonly minimum: 1;
+            readonly maximum: 1000000000;
+        };
+        readonly maximumRecordBytes: {
+            readonly minimum: 5;
+            readonly maximum: number;
+        };
+        readonly maximumResultBytes: {
+            readonly minimum: 32;
+            readonly maximum: number;
+        };
+    };
+};
+export declare const normalizeLocalNoSqlDbOfflineInspectionInput: (inputArg: ILocalNoSqlDbOfflineStringValueInspection) => ILocalNoSqlDbOfflineStringValueInspection;
+export declare const normalizeLocalNoSqlDbOfflinePhysicalNamespaceInspectionInput: (inputArg: ILocalNoSqlDbOfflinePhysicalNamespaceInspection) => ILocalNoSqlDbOfflinePhysicalNamespaceInspection;
+export declare const validateNoSqlDbManagementOperationOptions: (optionsArg?: INoSqlDbManagementOperationOptions) => void;

package/dist_ts/ts_nosqldb/offline-inspection.js

@@ -0,0 +1,282 @@
+import * as plugins from './plugins.js';
+export const localNoSqlDbOfflineInspectionBounds = {
+    maximumFolderPathBytes: 4095,
+    maximumNamespaceComponentBytes: 255,
+    maximumFieldNameBytes: 255,
+    maximumMatchValueBytes: 1024 * 1024,
+    maximumRequestBytes: 2 * 1024 * 1024,
+    maximumTimeoutMs: 2_147_483_647,
+    limits: {
+        maximumEntries: { minimum: 1, maximum: 100_000 },
+        maximumTotalFileBytes: { minimum: 1, maximum: 1024 ** 4 },
+        maximumRecords: { minimum: 1, maximum: 1_000_000_000 },
+        maximumRecordBytes: { minimum: 5, maximum: 16 * 1024 * 1024 },
+        maximumResultBytes: { minimum: 1, maximum: 16 * 1024 * 1024 },
+    },
+};
+export const localNoSqlDbOfflinePhysicalNamespaceInspectionBounds = {
+    maximumFolderPathBytes: 4095,
+    maximumRequestBytes: 2 * 1024 * 1024,
+    limits: {
+        maximumDatabases: { minimum: 1, maximum: 1_000_000 },
+        maximumCollections: { minimum: 1, maximum: 1_000_000 },
+        maximumIndexes: { minimum: 1, maximum: 1_000_000 },
+        maximumEntries: { minimum: 1, maximum: 100_000 },
+        maximumTotalFileBytes: { minimum: 1, maximum: 1024 * 1024 * 1024 * 1024 },
+        maximumRecordsPerCollection: { minimum: 1, maximum: 1_000_000_000 },
+        maximumRecordBytes: { minimum: 5, maximum: 16 * 1024 * 1024 },
+        maximumResultBytes: { minimum: 32, maximum: 16 * 1024 * 1024 },
+    },
+};
+const inputKeys = new Set([
+    'folderPath',
+    'databaseName',
+    'collectionName',
+    'match',
+    'valueField',
+    'limits',
+]);
+const matchKeys = new Set(['field', 'value']);
+const limitKeys = [
+    'maximumEntries',
+    'maximumTotalFileBytes',
+    'maximumRecords',
+    'maximumRecordBytes',
+    'maximumResultBytes',
+];
+const limitKeySet = new Set(limitKeys);
+const requestStructuralBytes = plugins.buffer.Buffer.byteLength('{"folderPath":,"databaseName":,"collectionName":,"match":{"field":,"value":},"valueField":,"limits":{"maximumEntries":,"maximumTotalFileBytes":,"maximumRecords":,"maximumRecordBytes":,"maximumResultBytes":}}', 'utf8');
+const requestEnvelopeBytes = plugins.buffer.Buffer.byteLength('{"id":"req_9007199254740991","method":"inspectOfflineStringValue","params":}', 'utf8');
+const physicalNamespaceInputKeys = new Set(['folderPath', 'limits']);
+const physicalNamespaceLimitKeys = [
+    'maximumDatabases',
+    'maximumCollections',
+    'maximumIndexes',
+    'maximumEntries',
+    'maximumTotalFileBytes',
+    'maximumRecordsPerCollection',
+    'maximumRecordBytes',
+    'maximumResultBytes',
+];
+const physicalNamespaceLimitKeySet = new Set(physicalNamespaceLimitKeys);
+const isRecord = (valueArg) => typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+const requirePhysicalNamespacePlainObject = (valueArg, allowedKeysArg, labelArg) => {
+    if (!isRecord(valueArg)) {
+        throw new TypeError(`LocalNoSqlDb offline physical namespace inspection ${labelArg} must be a plain object`);
+    }
+    for (const key in valueArg) {
+        if (!allowedKeysArg.has(key)) {
+            throw new TypeError(`LocalNoSqlDb offline physical namespace inspection ${labelArg} contains unknown key '${key}'`);
+        }
+    }
+    if (Object.getPrototypeOf(valueArg) !== Object.prototype) {
+        throw new TypeError(`LocalNoSqlDb offline physical namespace inspection ${labelArg} must be a plain object`);
+    }
+    for (const key of allowedKeysArg) {
+        if (!Object.prototype.propertyIsEnumerable.call(valueArg, key)) {
+            throw new TypeError(`LocalNoSqlDb offline physical namespace inspection ${labelArg} must contain own enumerable key '${key}'`);
+        }
+    }
+    return valueArg;
+};
+const rejectUnknownEnumerableKeys = (valueArg, allowedKeysArg, labelArg) => {
+    for (const key in valueArg) {
+        if (!allowedKeysArg.has(key)) {
+            throw new TypeError(`LocalNoSqlDb offline inspection ${labelArg} contains unknown key '${key}'`);
+        }
+    }
+};
+const encodedJsonStringBytes = (valueArg) => {
+    let bytes = 2;
+    for (let index = 0; index < valueArg.length; index++) {
+        const code = valueArg.charCodeAt(index);
+        if (code === 0x22
+            || code === 0x5c
+            || code === 0x08
+            || code === 0x09
+            || code === 0x0a
+            || code === 0x0c
+            || code === 0x0d) {
+            bytes += 2;
+        }
+        else if (code <= 0x1f) {
+            bytes += 6;
+        }
+        else if (code <= 0x7f) {
+            bytes += 1;
+        }
+        else if (code <= 0x7ff) {
+            bytes += 2;
+        }
+        else if (code >= 0xd800 && code <= 0xdbff) {
+            const next = valueArg.charCodeAt(index + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                bytes += 4;
+                index++;
+            }
+            else {
+                bytes += 6;
+            }
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            bytes += 6;
+        }
+        else {
+            bytes += 3;
+        }
+    }
+    return bytes;
+};
+const validateString = (valueArg, labelArg, minimumBytesArg, maximumBytesArg, rejectControlsArg) => {
+    if (typeof valueArg !== 'string') {
+        throw new TypeError(`LocalNoSqlDb offline inspection ${labelArg} must be a string`);
+    }
+    const bytes = plugins.buffer.Buffer.byteLength(valueArg, 'utf8');
+    if (bytes < minimumBytesArg || bytes > maximumBytesArg) {
+        throw new RangeError(`LocalNoSqlDb offline inspection ${labelArg} must be between ${minimumBytesArg} and ${maximumBytesArg} UTF-8 bytes`);
+    }
+    if (rejectControlsArg) {
+        for (const character of valueArg) {
+            if (/\p{Cc}/u.test(character)) {
+                throw new TypeError(`LocalNoSqlDb offline inspection ${labelArg} must not contain control characters`);
+            }
+        }
+    }
+};
+export const normalizeLocalNoSqlDbOfflineInspectionInput = (inputArg) => {
+    if (!isRecord(inputArg)) {
+        throw new TypeError('LocalNoSqlDb offline inspection input must be an object');
+    }
+    rejectUnknownEnumerableKeys(inputArg, inputKeys, 'input');
+    const inputRecord = inputArg;
+    const match = inputRecord.match;
+    if (!isRecord(match)) {
+        throw new TypeError('LocalNoSqlDb offline inspection match must be an object');
+    }
+    rejectUnknownEnumerableKeys(match, matchKeys, 'match');
+    const limits = inputRecord.limits;
+    if (!isRecord(limits)) {
+        throw new TypeError('LocalNoSqlDb offline inspection limits must be an object');
+    }
+    rejectUnknownEnumerableKeys(limits, limitKeySet, 'limits');
+    const normalized = {
+        folderPath: inputRecord.folderPath,
+        databaseName: inputRecord.databaseName,
+        collectionName: inputRecord.collectionName,
+        match: {
+            field: match.field,
+            value: match.value,
+        },
+        valueField: inputRecord.valueField,
+        limits: {
+            maximumEntries: limits.maximumEntries,
+            maximumTotalFileBytes: limits.maximumTotalFileBytes,
+            maximumRecords: limits.maximumRecords,
+            maximumRecordBytes: limits.maximumRecordBytes,
+            maximumResultBytes: limits.maximumResultBytes,
+        },
+    };
+    const bounds = localNoSqlDbOfflineInspectionBounds;
+    validateString(normalized.folderPath, 'folderPath', 1, bounds.maximumFolderPathBytes, true);
+    for (const [label, value] of [
+        ['databaseName', normalized.databaseName],
+        ['collectionName', normalized.collectionName],
+    ]) {
+        validateString(value, label, 1, bounds.maximumNamespaceComponentBytes, true);
+        if (value === '.' || value === '..' || value.includes('/') || value.includes('\\')) {
+            throw new TypeError(`LocalNoSqlDb offline inspection ${label} must be one canonical path component`);
+        }
+    }
+    validateString(normalized.match.field, 'match.field', 1, bounds.maximumFieldNameBytes, true);
+    validateString(normalized.valueField, 'valueField', 1, bounds.maximumFieldNameBytes, true);
+    validateString(normalized.match.value, 'match.value', 0, bounds.maximumMatchValueBytes, false);
+    for (const key of limitKeys) {
+        const value = normalized.limits[key];
+        const range = bounds.limits[key];
+        if (!Number.isSafeInteger(value) || value < range.minimum || value > range.maximum) {
+            throw new RangeError(`LocalNoSqlDb offline inspection limits.${key} must be a safe integer between ${range.minimum} and ${range.maximum}`);
+        }
+    }
+    if (plugins.buffer.Buffer.byteLength(normalized.match.value, 'utf8') > normalized.limits.maximumRecordBytes) {
+        throw new RangeError('LocalNoSqlDb offline inspection match.value must not exceed limits.maximumRecordBytes');
+    }
+    let requestBytes = 32 // Reserve the optional native deadline field.
+        + requestEnvelopeBytes
+        + requestStructuralBytes
+        + encodedJsonStringBytes(normalized.folderPath)
+        + encodedJsonStringBytes(normalized.databaseName)
+        + encodedJsonStringBytes(normalized.collectionName)
+        + encodedJsonStringBytes(normalized.match.field)
+        + encodedJsonStringBytes(normalized.match.value)
+        + encodedJsonStringBytes(normalized.valueField);
+    for (const key of limitKeys) {
+        requestBytes += String(normalized.limits[key]).length;
+    }
+    if (requestBytes > bounds.maximumRequestBytes) {
+        throw new RangeError(`LocalNoSqlDb offline inspection request exceeds the ${bounds.maximumRequestBytes}-byte serialized limit`);
+    }
+    return normalized;
+};
+export const normalizeLocalNoSqlDbOfflinePhysicalNamespaceInspectionInput = (inputArg) => {
+    const inputRecord = requirePhysicalNamespacePlainObject(inputArg, physicalNamespaceInputKeys, 'input');
+    const limits = requirePhysicalNamespacePlainObject(inputRecord.limits, physicalNamespaceLimitKeySet, 'limits');
+    const normalized = {
+        folderPath: inputRecord.folderPath,
+        limits: {
+            maximumDatabases: limits.maximumDatabases,
+            maximumCollections: limits.maximumCollections,
+            maximumIndexes: limits.maximumIndexes,
+            maximumEntries: limits.maximumEntries,
+            maximumTotalFileBytes: limits.maximumTotalFileBytes,
+            maximumRecordsPerCollection: limits.maximumRecordsPerCollection,
+            maximumRecordBytes: limits.maximumRecordBytes,
+            maximumResultBytes: limits.maximumResultBytes,
+        },
+    };
+    const bounds = localNoSqlDbOfflinePhysicalNamespaceInspectionBounds;
+    if (typeof normalized.folderPath !== 'string') {
+        throw new TypeError('LocalNoSqlDb offline physical namespace inspection folderPath must be a string');
+    }
+    const folderPathBytes = plugins.buffer.Buffer.byteLength(normalized.folderPath, 'utf8');
+    if (folderPathBytes < 1 || folderPathBytes > bounds.maximumFolderPathBytes) {
+        throw new RangeError(`LocalNoSqlDb offline physical namespace inspection folderPath must be between 1 and ${bounds.maximumFolderPathBytes} UTF-8 bytes`);
+    }
+    for (const character of normalized.folderPath) {
+        if (/\p{Cc}/u.test(character)) {
+            throw new TypeError('LocalNoSqlDb offline physical namespace inspection folderPath must not contain control characters');
+        }
+    }
+    for (const key of physicalNamespaceLimitKeys) {
+        const value = normalized.limits[key];
+        const range = bounds.limits[key];
+        if (!Number.isSafeInteger(value) || value < range.minimum || value > range.maximum) {
+            throw new RangeError(`LocalNoSqlDb offline physical namespace inspection limits.${key} must be a safe integer between ${range.minimum} and ${range.maximum}`);
+        }
+    }
+    const requestBytes = plugins.buffer.Buffer.byteLength(JSON.stringify({
+        id: 'req_9007199254740991',
+        method: 'inspectOfflinePhysicalNamespaces',
+        params: {
+            folderPath: normalized.folderPath,
+            ...normalized.limits,
+        },
+    }), 'utf8');
+    if (requestBytes > bounds.maximumRequestBytes) {
+        throw new RangeError(`LocalNoSqlDb offline physical namespace inspection request exceeds the ${bounds.maximumRequestBytes}-byte serialized limit`);
+    }
+    return normalized;
+};
+export const validateNoSqlDbManagementOperationOptions = (optionsArg) => {
+    if (optionsArg === undefined)
+        return;
+    if (!isRecord(optionsArg)) {
+        throw new TypeError('NoSQLDB management operation options must be an object');
+    }
+    if (optionsArg.timeoutMs !== undefined
+        && (!Number.isSafeInteger(optionsArg.timeoutMs)
+            || optionsArg.timeoutMs <= 0
+            || optionsArg.timeoutMs > localNoSqlDbOfflineInspectionBounds.maximumTimeoutMs)) {
+        throw new RangeError(`NoSQLDB management operation timeoutMs must be an integer between 1 and ${localNoSqlDbOfflineInspectionBounds.maximumTimeoutMs}`);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"offline-inspection.js","sourceRoot":"","sources":["../../ts/ts_nosqldb/offline-inspection.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts_nosqldb/plugins.d.ts

@@ -0,0 +1,7 @@
+import * as buffer from 'node:buffer';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+export { buffer, crypto, fs, path };
+import * as smartrust from '@push.rocks/smartrust';
+export { smartrust };

package/dist_ts/ts_nosqldb/plugins.js

@@ -0,0 +1,10 @@
+// node native scope
+import * as buffer from 'node:buffer';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+export { buffer, crypto, fs, path };
+// @push.rocks scope
+import * as smartrust from '@push.rocks/smartrust';
+export { smartrust };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3RzX25vc3FsZGIvcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEtBQUssSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUVsQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFFcEMsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUFFLFNBQVMsRUFBRSxDQUFDIn0=

package/dist_ts/ts_nosqldb/resource-fencing.d.ts

@@ -0,0 +1,39 @@
+import type { INoSqlDbDatabaseAllocationIdentity, INoSqlDbDatabaseExport } from './service-types.js';
+export type TNoSqlDbEffectivePayloadInputV1 = {
+    version: 1;
+    kind: 'smartdb.database.replace.v1';
+    databaseName: string;
+    source: INoSqlDbDatabaseExport;
+    /** Exact exclusive tenant owner; omission retains the legacy v1 digest. */
+    username?: string;
+    allocation?: INoSqlDbDatabaseAllocationIdentity;
+    holdPublication?: boolean;
+} | {
+    version: 1;
+    kind: 'smartdb.database.delete.v1';
+    databaseName: string;
+    username?: string;
+    allocation?: INoSqlDbDatabaseAllocationIdentity;
+    holdPublication?: boolean;
+} | {
+    version: 1;
+    kind: 'smartdb.database.ensure.v1';
+    databaseName: string;
+    username: string;
+    password: string;
+    roles?: string[];
+    allocation?: INoSqlDbDatabaseAllocationIdentity;
+} | {
+    version: 1;
+    kind: 'smartdb.database.allocate.v1';
+    databaseName: string;
+    expectedAbsent: true;
+    username: string;
+    password: string;
+    roles?: string[];
+};
+/**
+ * Computes the provider-derived SHA-256 identity for NoSQLDB's version 1
+ * fenced replace, exact-user delete, and exact-user ensure payload profiles.
+ */
+export declare const createNoSqlDbEffectivePayloadSha256V1: (inputArg: TNoSqlDbEffectivePayloadInputV1) => string;