@lossless.org/nosqldb 8.0.0

package/dist_ts/ts_nosqldb/service-types.d.ts

@@ -0,0 +1,341 @@
+export interface INoSqlDbHealth {
+    running: boolean;
+    storage?: 'memory' | 'file';
+    fileStorageEngine?: 'mvcc';
+    storagePurpose?: 'production' | 'rehearsal';
+    storageRehearsalId?: string | null;
+    storagePath?: string;
+    resourceFencingVersion?: 1;
+    resourceFencingSupported?: boolean;
+    resourceFencingRequiresDrain?: true;
+    allocationFencingVersion?: 1;
+    allocationFencingSupported?: boolean;
+    allocationFencingRequiresDrain?: true;
+    databaseAllocationReadAccessGrantVersion?: 1;
+    databaseAllocationReadAccessGrantSupported?: true;
+    publicationHoldVersion: 1;
+    publicationHoldSupported: boolean;
+    publicationHoldRequiresExternalDrain: boolean;
+    authEnabled?: boolean;
+    authUsers?: number;
+    usersPathConfigured?: boolean;
+    databaseCount: number;
+    collectionCount: number;
+    uptimeSeconds?: number;
+}
+/** Per-operation admission bounds for read-only stopped native storage inspection. */
+export interface ILocalNoSqlDbOfflineInspectionLimits {
+    maximumEntries: number;
+    maximumTotalFileBytes: number;
+    maximumRecords: number;
+    maximumRecordBytes: number;
+    maximumResultBytes: number;
+}
+export interface ILocalNoSqlDbOfflineStringValueInspection {
+    folderPath: string;
+    databaseName: string;
+    collectionName: string;
+    match: {
+        field: string;
+        value: string;
+    };
+    valueField: string;
+    limits: ILocalNoSqlDbOfflineInspectionLimits;
+}
+export type TLocalNoSqlDbOfflineStringValueInspectionResult = {
+    status: 'not-found';
+} | {
+    status: 'found';
+    value: string;
+};
+export interface ILocalNoSqlDbOfflinePhysicalNamespaceInspectionLimits {
+    maximumEntries: number;
+    maximumDatabases: number;
+    maximumCollections: number;
+    maximumIndexes: number;
+    maximumTotalFileBytes: number;
+    maximumRecordsPerCollection: number;
+    maximumRecordBytes: number;
+    maximumResultBytes: number;
+}
+export interface ILocalNoSqlDbOfflinePhysicalNamespaceInspection {
+    folderPath: string;
+    limits: ILocalNoSqlDbOfflinePhysicalNamespaceInspectionLimits;
+}
+export interface ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult {
+    schemaVersion: 1;
+    databases: Array<{
+        name: string;
+        collections: string[];
+    }>;
+}
+export declare const noSqlDbResourceFenceErrorCodes: readonly ["EFENCE_REQUIRED", "EFENCE_STALE", "EFENCE_SCOPE_MISMATCH", "EFENCE_UNSUPPORTED", "EFENCE_MUTATION_MISMATCH", "EFENCE_OWNERSHIP_MISMATCH", "EFENCE_STATE_CORRUPT", "EFENCE_RECEIPT_LIMIT", "EFENCE_BUSY", "EFENCE_PUBLICATION_HELD", "EFENCE_CAPABILITY_MISMATCH", "EFENCE_NOT_HELD", "EALLOCATION_EXPECTED_ABSENT_CONFLICT", "EALLOCATION_REQUIRED", "EALLOCATION_MISMATCH", "EALLOCATION_GENERATION_EXHAUSTED", "EALLOCATION_DEPROVISIONED"];
+export type TNoSqlDbResourceFenceErrorCode = (typeof noSqlDbResourceFenceErrorCodes)[number];
+export interface INoSqlDbResourceFence {
+    version: 1;
+    scopeId: string;
+    token: number;
+    mutationId: string;
+    payloadSha256: string;
+}
+export interface INoSqlDbResourceFenceReceipt extends INoSqlDbResourceFence {
+    kind: 'smartdb.database.replace.v1' | 'smartdb.database.delete.v1' | 'smartdb.database.ensure.v1' | 'smartdb.database.allocate.v1';
+    /** Digest of the canonical payload interpretation derived by NoSQLDB. */
+    effectivePayloadSha256: string;
+    provider?: 'smartdb';
+    resourceIdSha256?: string;
+    holdPublication?: true;
+    publicationState?: 'held' | 'released';
+    bindingSha256?: string;
+    resultSha256?: string;
+    receiptSha256?: string;
+    publicationCapabilitySha256?: string;
+    /** Present only while publication is held; never returned after release. */
+    publicationCapability?: string;
+    allocation?: INoSqlDbDatabaseAllocationIdentity;
+}
+export interface INoSqlDbDatabaseAllocationIdentity {
+    version: 1;
+    provider: 'smartdb';
+    state: 'active';
+    databaseName: string;
+    username: string;
+    allocationId: string;
+    generation: number;
+    principalId: string;
+    resourceIdSha256: string;
+    bindingSha256: string;
+    receiptSha256: string;
+}
+export interface INoSqlDbDatabaseAllocationLifecycle {
+    version: 1;
+    provider: 'smartdb';
+    state: 'allocating' | 'active' | 'deprovisioning' | 'deprovisioned';
+    databaseName: string;
+    username: string;
+    allocationId: string;
+    generation: number;
+    principalId: string;
+    resourceIdSha256: string;
+    bindingSha256: string;
+    receiptSha256: string;
+}
+export interface INoSqlDbDatabaseAllocationReadAccessGrantIdentity {
+    version: 1;
+    grantId: string;
+    principalId: string;
+    generation: number;
+}
+export interface INoSqlDbIssueDatabaseAllocationReadAccessGrantInput {
+    databaseName: string;
+    grantId: string;
+    username: string;
+    password: string;
+    allocation: INoSqlDbDatabaseAllocationIdentity;
+}
+export interface INoSqlDbIssueDatabaseAllocationReadAccessGrantResult {
+    databaseName: string;
+    username: string;
+    roles: ['read'];
+    authSource: string;
+    mongodbUri?: string;
+    allocation: INoSqlDbDatabaseAllocationIdentity;
+    grant: INoSqlDbDatabaseAllocationReadAccessGrantIdentity;
+    issuedAt: number;
+    expiresAt: number;
+}
+export interface INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput {
+    databaseName: string;
+    grantId: string;
+    allocation: INoSqlDbDatabaseAllocationIdentity;
+}
+export interface INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult {
+    databaseName: string;
+    grantId: string;
+    allocation: INoSqlDbDatabaseAllocationIdentity;
+    revoked: true;
+}
+export declare const noSqlDbAllocationReadAccessGrantErrorCodes: readonly ["EGRANT_INVALID_REQUEST", "EGRANT_CREDENTIAL_MISMATCH", "EGRANT_CONFLICT", "EGRANT_REPLAY_CAPACITY", "EGRANT_STATE_UNAVAILABLE"];
+export type TNoSqlDbAllocationReadAccessGrantErrorCode = (typeof noSqlDbAllocationReadAccessGrantErrorCodes)[number];
+export declare class NoSqlDbAllocationReadAccessGrantError extends Error {
+    readonly code: TNoSqlDbAllocationReadAccessGrantErrorCode;
+    constructor(codeArg: TNoSqlDbAllocationReadAccessGrantErrorCode, messageArg: string, causeArg?: unknown);
+}
+export declare const normalizeNoSqlDbAllocationReadAccessGrantError: (errorArg: unknown, codeArg?: unknown) => Error;
+export interface INoSqlDbHeldPublicationReceipt extends INoSqlDbResourceFenceReceipt {
+    provider: 'smartdb';
+    resourceIdSha256: string;
+    holdPublication: true;
+    publicationState: 'held';
+    bindingSha256: string;
+    resultSha256: string;
+    receiptSha256: string;
+    publicationCapabilitySha256: string;
+    publicationCapability: string;
+}
+export interface INoSqlDbCommitDatabasePublicationInput {
+    databaseName: string;
+    resourceFence: INoSqlDbHeldPublicationReceipt;
+}
+/**
+ * Cancellation and deadline ownership for one durable database-management
+ * operation. Aborting or timing out is fail-stop: NoSQLDB terminates the Rust
+ * engine so the operation cannot continue after the caller has released it.
+ */
+export interface INoSqlDbManagementOperationOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface INoSqlDbDatabaseResourceFenceState {
+    version: 1;
+    databaseName: string;
+    resourceIdSha256: string;
+    scopeId: string;
+    highestToken: number;
+    publicationState: 'requested' | 'publishing' | 'held' | 'released';
+    allocation?: INoSqlDbDatabaseAllocationLifecycle;
+}
+export declare class NoSqlDbResourceFenceError extends Error {
+    readonly code: TNoSqlDbResourceFenceErrorCode;
+    constructor(codeArg: TNoSqlDbResourceFenceErrorCode, messageArg: string, causeArg?: unknown);
+}
+export declare const normalizeNoSqlDbResourceFenceError: (errorArg: unknown) => Error;
+export interface INoSqlDbDatabaseTenantInput {
+    databaseName: string;
+    username: string;
+    password: string;
+    roles?: string[];
+}
+export interface INoSqlDbEnsureDatabaseTenantInput extends INoSqlDbDatabaseTenantInput {
+    fence: INoSqlDbResourceFence;
+    allocation?: INoSqlDbDatabaseAllocationIdentity;
+}
+export interface INoSqlDbAttestDatabaseTenantInput {
+    databaseName: string;
+    username: string;
+    roles: string[];
+    password: string;
+}
+export interface INoSqlDbAttestDatabaseTenantResult {
+    matches: boolean;
+}
+export interface INoSqlDbAllocateDatabaseTenantInput extends INoSqlDbDatabaseTenantInput {
+    expectedAbsent: true;
+    fence: INoSqlDbResourceFence;
+}
+export interface INoSqlDbDeleteDatabaseTenantInput {
+    databaseName: string;
+    /**
+     * Exact tenant user to revoke. For a fenced deletion this identity is
+     * included in the durable mutation and is removed idempotently after the
+     * database deletion is durable. Omitting it from a fenced deletion
+     * preserves auth users; an unfenced omission retains the legacy behavior
+     * of deleting every user for the database. If the database exists, a
+     * fenced deletion fails closed unless this exact user currently owns it.
+     */
+    username?: string;
+    fence?: INoSqlDbResourceFence;
+    allocation?: INoSqlDbDatabaseAllocationIdentity;
+    /** Keep the database data plane closed until commitDatabasePublication. */
+    holdPublication?: boolean;
+}
+export interface INoSqlDbRotateDatabaseTenantPasswordInput {
+    username: string;
+    password: string;
+}
+export interface INoSqlDbDatabaseTenantDescriptor {
+    databaseName: string;
+    username: string;
+    roles: string[];
+    authSource: string;
+    mongodbUri?: string;
+    resourceFence?: INoSqlDbResourceFenceReceipt;
+    allocation?: INoSqlDbDatabaseAllocationIdentity;
+}
+export interface INoSqlDbEnsureDatabaseTenantResult extends INoSqlDbDatabaseTenantDescriptor {
+    resourceFence: INoSqlDbResourceFenceReceipt;
+}
+export interface INoSqlDbAllocateDatabaseTenantResult extends INoSqlDbDatabaseTenantDescriptor {
+    resourceFence: INoSqlDbResourceFenceReceipt;
+    allocation: INoSqlDbDatabaseAllocationIdentity;
+}
+export interface INoSqlDbDeleteDatabaseTenantResult {
+    databaseName: string;
+    /**
+     * Users removed during the completing attempt. This can be zero after
+     * crash recovery when the exact user was durably removed by the prior
+     * attempt.
+     */
+    deletedUsers: number;
+    databaseDropped: boolean;
+    /**
+     * Present for fenced calls. False means the bound exact username is now
+     * absent; true means no username was supplied and auth users were preserved.
+     */
+    usersPreserved?: boolean;
+    resourceFence?: INoSqlDbResourceFenceReceipt;
+    allocation?: INoSqlDbDatabaseAllocationIdentity;
+}
+export interface INoSqlDbDatabaseExportCollection {
+    name: string;
+    documents: Record<string, any>[];
+    indexes: Record<string, any>[];
+}
+export interface INoSqlDbDatabaseExportLimits {
+    maxEncodedBytes?: number;
+    maxCollections?: number;
+    maxDocuments?: number;
+    maxIndexes?: number;
+}
+export interface INoSqlDbExportDatabaseInput {
+    databaseName: string;
+    limits?: INoSqlDbDatabaseExportLimits;
+}
+export interface INoSqlDbDatabaseContentDigestLimits {
+    maxScannedBsonBytes?: number;
+    maxCollections?: number;
+    maxDocuments?: number;
+    maxIndexes?: number;
+}
+export interface INoSqlDbGetDatabaseContentDigestInput {
+    databaseName: string;
+    limits?: INoSqlDbDatabaseContentDigestLimits;
+}
+export interface INoSqlDbDatabaseContentDigest {
+    format: 'smartdb.database.content-digest.v1';
+    algorithm: 'sha256';
+    databaseName: string;
+    sha256: string;
+    scannedBsonBytes: number;
+    collections: number;
+    documents: number;
+    indexes: number;
+}
+export interface INoSqlDbDatabaseExport {
+    format: 'smartdb.database.export.v1';
+    databaseName: string;
+    exportedAtMs: number;
+    collections: INoSqlDbDatabaseExportCollection[];
+}
+export interface INoSqlDbImportDatabaseInput {
+    databaseName: string;
+    source: INoSqlDbDatabaseExport;
+    /**
+     * Exact exclusive tenant owner required for this replacement. When used
+     * with a fence, the username is included in the provider-derived mutation
+     * identity. Omission preserves the original version 1 replacement profile.
+     */
+    username?: string;
+    fence?: INoSqlDbResourceFence;
+    allocation?: INoSqlDbDatabaseAllocationIdentity;
+    /** Keep the database data plane closed until commitDatabasePublication. */
+    holdPublication?: boolean;
+}
+export interface INoSqlDbImportDatabaseResult {
+    databaseName: string;
+    collections: number;
+    documents: number;
+    resourceFence?: INoSqlDbResourceFenceReceipt;
+    allocation?: INoSqlDbDatabaseAllocationIdentity;
+}
+export type TNoSqlDbCommitDatabasePublicationResult = INoSqlDbImportDatabaseResult | INoSqlDbDeleteDatabaseTenantResult;

package/dist_ts/ts_nosqldb/service-types.js

@@ -0,0 +1,62 @@
+export const noSqlDbResourceFenceErrorCodes = [
+    'EFENCE_REQUIRED',
+    'EFENCE_STALE',
+    'EFENCE_SCOPE_MISMATCH',
+    'EFENCE_UNSUPPORTED',
+    'EFENCE_MUTATION_MISMATCH',
+    'EFENCE_OWNERSHIP_MISMATCH',
+    'EFENCE_STATE_CORRUPT',
+    'EFENCE_RECEIPT_LIMIT',
+    'EFENCE_BUSY',
+    'EFENCE_PUBLICATION_HELD',
+    'EFENCE_CAPABILITY_MISMATCH',
+    'EFENCE_NOT_HELD',
+    'EALLOCATION_EXPECTED_ABSENT_CONFLICT',
+    'EALLOCATION_REQUIRED',
+    'EALLOCATION_MISMATCH',
+    'EALLOCATION_GENERATION_EXHAUSTED',
+    'EALLOCATION_DEPROVISIONED',
+];
+export const noSqlDbAllocationReadAccessGrantErrorCodes = [
+    'EGRANT_INVALID_REQUEST',
+    'EGRANT_CREDENTIAL_MISMATCH',
+    'EGRANT_CONFLICT',
+    'EGRANT_REPLAY_CAPACITY',
+    'EGRANT_STATE_UNAVAILABLE',
+];
+export class NoSqlDbAllocationReadAccessGrantError extends Error {
+    constructor(codeArg, messageArg, causeArg) {
+        super(`${codeArg}: ${messageArg}`, { cause: causeArg });
+        this.name = 'NoSqlDbAllocationReadAccessGrantError';
+        this.code = codeArg;
+    }
+}
+export const normalizeNoSqlDbAllocationReadAccessGrantError = (errorArg, codeArg) => {
+    const error = errorArg instanceof Error
+        ? errorArg
+        : new Error(String(errorArg));
+    if (typeof codeArg !== 'string'
+        || !noSqlDbAllocationReadAccessGrantErrorCodes.includes(codeArg)) {
+        return error;
+    }
+    return new NoSqlDbAllocationReadAccessGrantError(codeArg, error.message, error);
+};
+export class NoSqlDbResourceFenceError extends Error {
+    constructor(codeArg, messageArg, causeArg) {
+        super(`${codeArg}: ${messageArg}`, { cause: causeArg });
+        this.name = 'NoSqlDbResourceFenceError';
+        this.code = codeArg;
+    }
+}
+export const normalizeNoSqlDbResourceFenceError = (errorArg) => {
+    const error = errorArg instanceof Error
+        ? errorArg
+        : new Error(String(errorArg));
+    const match = /^((?:EFENCE|EALLOCATION)_[A-Z_]+):\s*(.*)$/s.exec(error.message);
+    if (!match ||
+        !noSqlDbResourceFenceErrorCodes.includes(match[1])) {
+        return error;
+    }
+    return new NoSqlDbResourceFenceError(match[1], match[2], error);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_nosqldb/storage-rehearsal.d.ts

@@ -0,0 +1,103 @@
+import type { INoSqlDbServerOptions } from './server/classes.nosqldbserver.js';
+export declare const noSqlDbStorageRehearsalErrorCodes: readonly ["INVALID_REQUEST", "UNSUPPORTED", "BUSY", "NOT_FOUND", "DESTINATION_CONFLICT", "IDENTITY_MISMATCH", "STATE_CORRUPT", "SOURCE_CHANGED", "CAPACITY", "CANCELLED", "IO", "RECOVERY_REQUIRED", "BINARY_UNAVAILABLE"];
+export type TNoSqlDbStorageRehearsalErrorCode = typeof noSqlDbStorageRehearsalErrorCodes[number];
+/** Errors deliberately contain neither persisted values nor nested engine errors. */
+export declare class NoSqlDbStorageRehearsalError extends Error {
+    readonly code: TNoSqlDbStorageRehearsalErrorCode;
+    constructor(code: TNoSqlDbStorageRehearsalErrorCode);
+}
+export interface INoSqlDbStorageRehearsalOptions {
+    /** Exact executable, with SmartRust's exclusive non-mutating selection contract. */
+    binaryPath?: string;
+}
+export interface INoSqlDbStorageRehearsalInput {
+    /** Absolute canonical path of an already initialized, stopped source. */
+    sourceFolderPath: string;
+    /** Absent destination; its existing parent must be private and on the source filesystem. */
+    destinationFolderPath: string;
+    /** Optional previously attested provider identity. The engine always verifies source ownership and bindings. */
+    expectedSourceProviderRootId?: string;
+    /** Stable caller operation ID. Every retry must retain the same request. */
+    operationId: string;
+    limits?: {
+        /** Source files plus directories, including the root. Default/maximum: 100,000. */
+        maximumEntries: number;
+        /** Total source file bytes. Default/maximum: 1 TiB. */
+        maximumBytes: number;
+    };
+}
+/** Counts include retained historical records separately from live contents. */
+export interface INoSqlDbStorageRehearsalPreservation {
+    files: number;
+    bytes: number;
+    databases: number;
+    collections: number;
+    documents: number;
+    indexes: number;
+    indexAliases: number;
+    users: number;
+    principalIdentities: number;
+    retiredDatabases: number;
+    retiredCollections: number;
+    retiredDocuments: number;
+    retiredIndexes: number;
+    retiredPrincipals: number;
+    allocationReplays: number;
+    resources: number;
+    receipts: number;
+    maximumFencingToken: string;
+    publicationHolds: number;
+    activeAllocations: number;
+    retiredAllocations: number;
+    sessions: number;
+    retiringSessions: number;
+    retryOutcomes: number;
+    transactionOutcomes: number;
+    obsoleteOutcomes: number;
+    records: number;
+    encodedRecordBytes: number;
+}
+/** Immutable creation evidence. Completed retries replay this receipt even after isolated writes. */
+export interface INoSqlDbStorageRehearsalReceipt {
+    format: 'smartdb.storage-rehearsal.receipt.v2';
+    operationId: string;
+    requestSha256: string;
+    storageProfile: 'native-mvcc-authenticated-v1';
+    sourceFolderPath: string;
+    destinationFolderPath: string;
+    sourceProviderRootId: string;
+    destinationProviderRootId: string;
+    sourceStorageRootSha256: string;
+    sourceSnapshotSha256: string;
+    destinationDevice: string;
+    destinationInode: string;
+    groupId: string;
+    timelineId: string;
+    sourceLsn: string;
+    destinationLsn: string;
+    sourceRecordsSha256: string;
+    preservedRecordsSha256: string;
+    scramIterations: number;
+    preservation: INoSqlDbStorageRehearsalPreservation;
+    sourceUnchanged: true;
+    contentsAndIndexesPreserved: true;
+    namespacesPreserved: true;
+    authenticationPreserved: true;
+    historicalFencingPreserved: true;
+    outcomesPreserved: true;
+    filesystemBindingsVerified: true;
+    productionAuthority: false;
+    promotionSupported: false;
+    receiptSha256: string;
+}
+export type TNormalizedNoSqlDbStorageRehearsalInput = INoSqlDbStorageRehearsalInput & {
+    limits: NonNullable<INoSqlDbStorageRehearsalInput['limits']>;
+};
+export declare const normalizeNoSqlDbStorageRehearsalOptions: (value: unknown) => INoSqlDbStorageRehearsalOptions;
+export declare const normalizeNoSqlDbStorageRehearsalOperationOptions: (value: unknown) => {
+    timeoutMs: number;
+    signal?: AbortSignal;
+};
+export declare const normalizeNoSqlDbStorageRehearsalInput: (value: unknown) => TNormalizedNoSqlDbStorageRehearsalInput;
+export declare const normalizeNoSqlDbStorageRehearsalReceipt: (value: unknown, input: TNormalizedNoSqlDbStorageRehearsalInput) => INoSqlDbStorageRehearsalReceipt;
+export declare const validateNoSqlDbStorageRehearsalStartup: (options: INoSqlDbServerOptions) => void;

package/dist_ts/ts_nosqldb/storage-rehearsal.js

@@ -0,0 +1,131 @@
+import * as plugins from './plugins.js';
+export const noSqlDbStorageRehearsalErrorCodes = [
+    'INVALID_REQUEST', 'UNSUPPORTED', 'BUSY', 'NOT_FOUND', 'DESTINATION_CONFLICT',
+    'IDENTITY_MISMATCH', 'STATE_CORRUPT', 'SOURCE_CHANGED', 'CAPACITY', 'CANCELLED',
+    'IO', 'RECOVERY_REQUIRED', 'BINARY_UNAVAILABLE',
+];
+/** Errors deliberately contain neither persisted values nor nested engine errors. */
+export class NoSqlDbStorageRehearsalError extends Error {
+    constructor(code) {
+        super(`NoSQLDB storage rehearsal failed with code ${code}`);
+        this.code = code;
+        this.name = 'NoSqlDbStorageRehearsalError';
+    }
+}
+const fail = (code = 'INVALID_REQUEST') => {
+    throw new NoSqlDbStorageRehearsalError(code);
+};
+const object = (value) => {
+    try {
+        if (value === null || typeof value !== 'object' || Array.isArray(value)
+            || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+            return false;
+        return Reflect.ownKeys(value).every((key) => {
+            const property = Object.getOwnPropertyDescriptor(value, key);
+            return typeof key === 'string' && property?.enumerable === true && Object.hasOwn(property, 'value');
+        });
+    }
+    catch {
+        return false;
+    }
+};
+const digest = (value) => typeof value === 'string' && /^[0-9a-f]{64}$/.test(value);
+const identifier = (value) => typeof value === 'string'
+    && /^[A-Za-z0-9][A-Za-z0-9._:@-]{0,127}$/.test(value);
+const canonicalPath = (value) => typeof value === 'string'
+    && value.startsWith('/') && value !== '/' && plugins.buffer.Buffer.byteLength(value) <= 4095
+    && !/[\p{Cc}\p{Cs}]/u.test(value) && !value.endsWith('/') && !value.includes('//')
+    && value.split('/').every((part) => part !== '.' && part !== '..' && !part.startsWith('.smartdb-rehearsal-'));
+const integer = (value, minimum, maximum) => typeof value === 'number' && Number.isSafeInteger(value) && value >= minimum && value <= maximum;
+const exactKeys = (value, required, optional = []) => required.every((key) => Object.hasOwn(value, key)) && Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
+const sha256 = (domain, value) => plugins.crypto.createHash('sha256').update(domain).update(JSON.stringify(value)).digest('hex');
+export const normalizeNoSqlDbStorageRehearsalOptions = (value) => {
+    try {
+        if (!object(value) || !exactKeys(value, [], ['binaryPath'])
+            || (value.binaryPath !== undefined && (typeof value.binaryPath !== 'string' || value.binaryPath.length === 0)))
+            return fail();
+        return { binaryPath: value.binaryPath };
+    }
+    catch {
+        return fail();
+    }
+};
+export const normalizeNoSqlDbStorageRehearsalOperationOptions = (value) => {
+    try {
+        if (value === undefined)
+            return { timeoutMs: 3_600_000 };
+        if (!object(value) || !exactKeys(value, [], ['timeoutMs', 'signal'])
+            || (value.timeoutMs !== undefined && !integer(value.timeoutMs, 1, 86_400_000))
+            || (value.signal !== undefined && !(value.signal instanceof AbortSignal)))
+            return fail();
+        return { timeoutMs: value.timeoutMs ?? 3_600_000, signal: value.signal };
+    }
+    catch {
+        return fail();
+    }
+};
+export const normalizeNoSqlDbStorageRehearsalInput = (value) => {
+    if (!object(value) || !exactKeys(value, ['sourceFolderPath', 'destinationFolderPath', 'operationId'], ['expectedSourceProviderRootId', 'limits'])
+        || !canonicalPath(value.sourceFolderPath) || !canonicalPath(value.destinationFolderPath)
+        || value.sourceFolderPath === value.destinationFolderPath
+        || value.sourceFolderPath.startsWith(`${value.destinationFolderPath}/`)
+        || value.destinationFolderPath.startsWith(`${value.sourceFolderPath}/`)
+        || (value.expectedSourceProviderRootId !== undefined && !digest(value.expectedSourceProviderRootId))
+        || !identifier(value.operationId))
+        return fail();
+    const limits = value.limits === undefined ? { maximumEntries: 100_000, maximumBytes: 1024 ** 4 } : value.limits;
+    if (!object(limits) || !exactKeys(limits, ['maximumEntries', 'maximumBytes'])
+        || !integer(limits.maximumEntries, 1, 100_000) || !integer(limits.maximumBytes, 1, 1024 ** 4))
+        return fail();
+    return {
+        sourceFolderPath: value.sourceFolderPath,
+        destinationFolderPath: value.destinationFolderPath,
+        ...(value.expectedSourceProviderRootId === undefined ? {} : { expectedSourceProviderRootId: value.expectedSourceProviderRootId }),
+        operationId: value.operationId,
+        limits: { maximumEntries: limits.maximumEntries, maximumBytes: limits.maximumBytes },
+    };
+};
+const preservationKeys = ['files', 'bytes', 'databases', 'collections', 'documents', 'indexes', 'indexAliases', 'users', 'principalIdentities', 'retiredDatabases', 'retiredCollections', 'retiredDocuments', 'retiredIndexes', 'retiredPrincipals', 'allocationReplays', 'resources', 'receipts', 'maximumFencingToken', 'publicationHolds', 'activeAllocations', 'retiredAllocations', 'sessions', 'retiringSessions', 'retryOutcomes', 'transactionOutcomes', 'obsoleteOutcomes', 'records', 'encodedRecordBytes'];
+const receiptKeys = ['format', 'operationId', 'requestSha256', 'storageProfile', 'sourceFolderPath', 'destinationFolderPath', 'sourceProviderRootId', 'destinationProviderRootId', 'sourceStorageRootSha256', 'sourceSnapshotSha256', 'destinationDevice', 'destinationInode', 'groupId', 'timelineId', 'sourceLsn', 'destinationLsn', 'sourceRecordsSha256', 'preservedRecordsSha256', 'scramIterations', 'preservation', 'sourceUnchanged', 'contentsAndIndexesPreserved', 'namespacesPreserved', 'authenticationPreserved', 'historicalFencingPreserved', 'outcomesPreserved', 'filesystemBindingsVerified', 'productionAuthority', 'promotionSupported', 'receiptSha256'];
+const unsigned = (value) => typeof value === 'string'
+    && /^(0|[1-9][0-9]{0,19})$/.test(value) && BigInt(value) <= 0xffffffffffffffffn;
+export const normalizeNoSqlDbStorageRehearsalReceipt = (value, input) => {
+    if (!object(value) || !exactKeys(value, receiptKeys) || !object(value.preservation)
+        || !exactKeys(value.preservation, preservationKeys)
+        || !preservationKeys.every((key) => key === 'maximumFencingToken'
+            ? unsigned(value.preservation[key])
+            : integer(value.preservation[key], 0, Number.MAX_SAFE_INTEGER))
+        || value.format !== 'smartdb.storage-rehearsal.receipt.v2' || value.storageProfile !== 'native-mvcc-authenticated-v1'
+        || value.operationId !== input.operationId || value.sourceFolderPath !== input.sourceFolderPath
+        || value.destinationFolderPath !== input.destinationFolderPath
+        || (input.expectedSourceProviderRootId !== undefined && value.sourceProviderRootId !== input.expectedSourceProviderRootId)
+        || !['sourceProviderRootId', 'destinationProviderRootId', 'sourceSnapshotSha256', 'sourceRecordsSha256', 'preservedRecordsSha256', 'receiptSha256'].every((key) => digest(value[key]))
+        || value.sourceProviderRootId === value.destinationProviderRootId
+        || value.sourceStorageRootSha256 !== plugins.crypto.createHash('sha256').update(`${input.sourceFolderPath}/.__rustdb_mvcc/data`).digest('hex')
+        || value.requestSha256 !== sha256('smartdb.storage-rehearsal.request.v2\0', input)
+        || !integer(value.scramIterations, 4096, 0xffff_ffff)
+        || ![value.destinationDevice, value.destinationInode, value.sourceLsn, value.destinationLsn].every(unsigned)
+        || BigInt(value.sourceLsn) < 1n || BigInt(value.sourceLsn) + 1n !== BigInt(value.destinationLsn)
+        || !identifier(value.groupId) || !identifier(value.timelineId)
+        || !['sourceUnchanged', 'contentsAndIndexesPreserved', 'namespacesPreserved', 'authenticationPreserved', 'historicalFencingPreserved', 'outcomesPreserved', 'filesystemBindingsVerified'].every((key) => value[key] === true)
+        || value.productionAuthority !== false || value.promotionSupported !== false)
+        return fail('STATE_CORRUPT');
+    const preservation = Object.fromEntries(preservationKeys.map((key) => [key, value.preservation[key]]));
+    const normalized = Object.fromEntries(receiptKeys.map((key) => [key,
+        key === 'preservation' ? preservation : key === 'receiptSha256' ? '' : value[key]]));
+    if (sha256('smartdb.storage-rehearsal.receipt.v2\0', normalized) !== value.receiptSha256)
+        return fail('STATE_CORRUPT');
+    normalized.receiptSha256 = value.receiptSha256;
+    return normalized;
+};
+export const validateNoSqlDbStorageRehearsalStartup = (options) => {
+    if (options.storageRehearsalId === undefined)
+        return;
+    if (!identifier(options.storageRehearsalId) || options.storage !== 'file'
+        || (options.fileStorageStartup !== undefined && options.fileStorageStartup !== 'current-format-only') || !canonicalPath(options.storagePath)
+        || !canonicalPath(options.socketPath) || options.socketPath.startsWith(`${options.storagePath}/`)
+        || options.auth?.enabled !== true || (options.auth.users?.length ?? 0) !== 0
+        || !integer(options.auth.scramIterations, 4096, 0xffff_ffff))
+        return fail();
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage-rehearsal.js","sourceRoot":"","sources":["../../ts/ts_nosqldb/storage-rehearsal.ts"],"names":[],"mappings":"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"}