@push.rocks/smartdb 2.15.4 → 2.17.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartdb',
-    version: '2.15.4',
+    version: '2.17.0',
     description: 'A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHFIQUFxSDtDQUNuSSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -1,7 +1,7 @@
 import { commitinfo } from './00_commitinfo_data.js';
 export * from './ts_smartdb/index.js';
 export { LocalSmartDb } from './ts_local/index.js';
-export type { ILocalSmartDbOptions, ILocalSmartDbConnectionInfo } from './ts_local/index.js';
+export type { ILocalSmartDbOptions, ILocalSmartDbConnectionInfo, ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, } from './ts_local/index.js';
 export { AuthMetadataMigrationRunner, StorageMigrator, type IAuthMetadataPermissionMigrationBridge, type TAuthMetadataMigrationRunnerStatus, } from './ts_migration/index.js';
 export { commitinfo };
 export type { IOpLogEntry, IOpLogResult, IOpLogStats, IRevertResult, ICollectionInfo, IDocumentsResult, ISmartDbMetrics, ISmartDbHealth, ISmartDbResourceFence, ISmartDbResourceFenceReceipt, ISmartDbHeldPublicationReceipt, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, TSmartDbCommitDatabasePublicationResult, TSmartDbResourceFenceErrorCode, ISmartDbDatabaseTenantInput, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseExportCollection, ISmartDbDatabaseExport, ISmartDbDatabaseExportLimits, ISmartDbExportDatabaseInput, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, TSmartDbEffectivePayloadInputV1, } from './ts_smartdb/index.js';

package/dist_ts/index.js

@@ -8,4 +8,4 @@ export { AuthMetadataMigrationRunner, StorageMigrator, } from './ts_migration/in
 // Export commitinfo
 export { commitinfo };
 export { SmartDbResourceFenceError, normalizeSmartDbResourceFenceError, smartDbResourceFenceErrorCodes, createSmartDbEffectivePayloadSha256V1, } from './ts_smartdb/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFckQsNkJBQTZCO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsc0JBQXNCO0FBQ3RCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUduRCxtQkFBbUI7QUFDbkIsT0FBTyxFQUNMLDJCQUEyQixFQUMzQixlQUFlLEdBR2hCLE1BQU0seUJBQXlCLENBQUM7QUFFakMsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxVQUFVLEVBQUUsQ0FBQztBQW1DdEIsT0FBTyxFQUNMLHlCQUF5QixFQUN6QixrQ0FBa0MsRUFDbEMsOEJBQThCLEVBQzlCLHFDQUFxQyxHQUN0QyxNQUFNLHVCQUF1QixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFckQsNkJBQTZCO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsc0JBQXNCO0FBQ3RCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQVNuRCxtQkFBbUI7QUFDbkIsT0FBTyxFQUNMLDJCQUEyQixFQUMzQixlQUFlLEdBR2hCLE1BQU0seUJBQXlCLENBQUM7QUFFakMsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxVQUFVLEVBQUUsQ0FBQztBQW1DdEIsT0FBTyxFQUNMLHlCQUF5QixFQUN6QixrQ0FBa0MsRUFDbEMsOEJBQThCLEVBQzlCLHFDQUFxQyxHQUN0QyxNQUFNLHVCQUF1QixDQUFDIn0=

package/dist_ts/ts_local/classes.localsmartdb.d.ts

@@ -1,4 +1,4 @@
-import { SmartdbServer } from '../ts_smartdb/index.js';
+import { SmartdbServer, type ILocalSmartDbOfflineStringValueInspection, type ISmartDbManagementOperationOptions, type TLocalSmartDbOfflineStringValueInspectionResult } from '../ts_smartdb/index.js';
 /**
  * Connection information returned by LocalSmartDb.start()
  */
@@ -47,6 +47,12 @@ export declare class LocalSmartDb {
     private server;
     private generatedSocketPath;
     constructor(options: ILocalSmartDbOptions);
+    private static createOfflineInspectionBridge;
+    /**
+     * Inspect one exact string value while the owning LocalSmartDb engine is stopped.
+     * This starts only the Rust management sidecar and never initializes storage.
+     */
+    static inspectOfflineStringValue(inputArg: ILocalSmartDbOfflineStringValueInspection, optionsArg?: ISmartDbManagementOperationOptions): Promise<TLocalSmartDbOfflineStringValueInspectionResult>;
     /**
      * Generate a unique socket path in /tmp
      */

package/dist_ts/ts_local/classes.localsmartdb.js

@@ -3,8 +3,9 @@ import * as fs from 'fs/promises';
 import * as net from 'net';
 import * as path from 'path';
 import * as os from 'os';
-import { SmartdbServer } from '../ts_smartdb/index.js';
+import { RustDbBridge, SmartdbServer, } from '../ts_smartdb/index.js';
 import { StorageMigrator } from '../ts_migration/index.js';
+import { normalizeLocalSmartDbOfflineInspectionInput, validateSmartDbManagementOperationOptions, } from '../ts_smartdb/offline-inspection.js';
 /**
  * LocalSmartDb - Lightweight local MongoDB-compatible database using Unix sockets
  *
@@ -39,6 +40,75 @@ export class LocalSmartDb {
         this.generatedSocketPath = null;
         this.options = options;
     }
+    static createOfflineInspectionBridge() {
+        return new RustDbBridge();
+    }
+    /**
+     * Inspect one exact string value while the owning LocalSmartDb engine is stopped.
+     * This starts only the Rust management sidecar and never initializes storage.
+     */
+    static async inspectOfflineStringValue(inputArg, optionsArg) {
+        const validatedInput = normalizeLocalSmartDbOfflineInspectionInput(inputArg);
+        validateSmartDbManagementOperationOptions(optionsArg);
+        optionsArg?.signal?.throwIfAborted();
+        const input = normalizeLocalSmartDbOfflineInspectionInput({
+            ...validatedInput,
+            folderPath: path.resolve(validatedInput.folderPath),
+        });
+        const deadline = optionsArg?.timeoutMs === undefined
+            ? undefined
+            : Date.now() + optionsArg.timeoutMs;
+        const bridge = LocalSmartDb.createOfflineInspectionBridge();
+        let operationFailed = false;
+        let operationError;
+        let result;
+        try {
+            let spawnOptions = optionsArg;
+            if (deadline !== undefined) {
+                const remainingMs = deadline - Date.now();
+                if (remainingMs <= 0) {
+                    throw new Error('SmartDB offline inspection timed out before sidecar spawn');
+                }
+                spawnOptions = {
+                    signal: optionsArg?.signal,
+                    timeoutMs: remainingMs,
+                };
+            }
+            if (!await bridge.spawn(spawnOptions)) {
+                throw new Error('smartdb Rust binary not found. Set SMARTDB_RUST_BINARY env var, ' +
+                    'install the platform package, or build locally with `tsrust`.');
+            }
+            let commandOptions = optionsArg;
+            if (deadline !== undefined) {
+                const remainingMs = deadline - Date.now();
+                if (remainingMs <= 0) {
+                    throw new Error('SmartDB offline inspection timed out while starting the sidecar');
+                }
+                commandOptions = {
+                    signal: optionsArg?.signal,
+                    timeoutMs: remainingMs,
+                };
+            }
+            result = await bridge.inspectOfflineStringValue(input, commandOptions);
+        }
+        catch (error) {
+            operationFailed = true;
+            operationError = error;
+        }
+        try {
+            await bridge.terminate({ gracePeriodMs: 0 });
+        }
+        catch (terminationError) {
+            if (operationFailed) {
+                throw new AggregateError([operationError, terminationError], 'SmartDB offline inspection failed and sidecar termination was incomplete', { cause: operationError });
+            }
+            throw terminationError;
+        }
+        if (operationFailed) {
+            throw operationError;
+        }
+        return result;
+    }
     /**
      * Generate a unique socket path in /tmp
      */
@@ -166,4 +236,4 @@ export class LocalSmartDb {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_local/index.d.ts

@@ -1,2 +1,3 @@
 export { LocalSmartDb } from './classes.localsmartdb.js';
 export type { ILocalSmartDbOptions, ILocalSmartDbConnectionInfo } from './classes.localsmartdb.js';
+export type { ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, } from '../ts_smartdb/service-types.js';

package/dist_ts/ts_smartdb/index.d.ts

@@ -2,7 +2,7 @@ export { SmartdbServer } from './server/SmartdbServer.js';
 export type { ISmartdbAuthOptions, ISmartdbAuthUser, ISmartdbOplogOptions, ISmartdbServerOptions, ISmartdbTlsOptions, } from './server/SmartdbServer.js';
 export { RustDbBridge, SmartDbManagementOperationTerminationError, } from './rust-db-bridge.js';
 export type { IOpLogEntry, IOpLogResult, IOpLogStats, IRevertResult, ICollectionInfo, IDocumentsResult, ISmartDbMetrics, } from './rust-db-bridge.js';
-export type { ISmartDbHealth, ISmartDbResourceFence, ISmartDbResourceFenceReceipt, ISmartDbHeldPublicationReceipt, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, TSmartDbCommitDatabasePublicationResult, TSmartDbResourceFenceErrorCode, ISmartDbDatabaseTenantInput, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseExportCollection, ISmartDbDatabaseExport, ISmartDbDatabaseExportLimits, ISmartDbExportDatabaseInput, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, } from './service-types.js';
+export type { ISmartDbHealth, ISmartDbResourceFence, ISmartDbResourceFenceReceipt, ISmartDbHeldPublicationReceipt, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, TSmartDbCommitDatabasePublicationResult, TSmartDbResourceFenceErrorCode, ISmartDbDatabaseTenantInput, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseExportCollection, ISmartDbDatabaseExport, ISmartDbDatabaseExportLimits, ISmartDbExportDatabaseInput, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, } from './service-types.js';
 export { SmartDbResourceFenceError, normalizeSmartDbResourceFenceError, smartDbResourceFenceErrorCodes, } from './service-types.js';
 export type { TSmartDbEffectivePayloadInputV1 } from './resource-fencing.js';
 export { createSmartDbEffectivePayloadSha256V1 } from './resource-fencing.js';

package/dist_ts/ts_smartdb/index.js

@@ -5,4 +5,4 @@ export { SmartdbServer } from './server/SmartdbServer.js';
 export { RustDbBridge, SmartDbManagementOperationTerminationError, } from './rust-db-bridge.js';
 export { SmartDbResourceFenceError, normalizeSmartDbResourceFenceError, smartDbResourceFenceErrorCodes, } from './service-types.js';
 export { createSmartDbEffectivePayloadSha256V1 } from './resource-fencing.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19zbWFydGRiL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhEQUE4RDtBQUU5RCx5REFBeUQ7QUFDekQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBUzFELHNFQUFzRTtBQUN0RSxPQUFPLEVBQ0wsWUFBWSxFQUNaLDBDQUEwQyxHQUMzQyxNQUFNLHFCQUFxQixDQUFDO0FBc0M3QixPQUFPLEVBQ0wseUJBQXlCLEVBQ3pCLGtDQUFrQyxFQUNsQyw4QkFBOEIsR0FDL0IsTUFBTSxvQkFBb0IsQ0FBQztBQUU1QixPQUFPLEVBQUUscUNBQXFDLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19zbWFydGRiL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhEQUE4RDtBQUU5RCx5REFBeUQ7QUFDekQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBUzFELHNFQUFzRTtBQUN0RSxPQUFPLEVBQ0wsWUFBWSxFQUNaLDBDQUEwQyxHQUMzQyxNQUFNLHFCQUFxQixDQUFDO0FBeUM3QixPQUFPLEVBQ0wseUJBQXlCLEVBQ3pCLGtDQUFrQyxFQUNsQyw4QkFBOEIsR0FDL0IsTUFBTSxvQkFBb0IsQ0FBQztBQUU1QixPQUFPLEVBQUUscUNBQXFDLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQyJ9

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

@@ -0,0 +1,33 @@
+import type { ILocalSmartDbOfflineStringValueInspection, ISmartDbManagementOperationOptions } from './service-types.js';
+export declare const localSmartDbOfflineInspectionBounds: {
+    readonly maximumFolderPathBytes: 4096;
+    readonly maximumNamespaceComponentBytes: 255;
+    readonly maximumFieldNameBytes: 255;
+    readonly maximumMatchValueBytes: number;
+    readonly maximumRequestBytes: number;
+    readonly maximumTimeoutMs: 2147483647;
+    readonly limits: {
+        readonly maximumDataFileBytes: {
+            readonly minimum: 64;
+            readonly maximum: number;
+        };
+        readonly maximumWalFileBytes: {
+            readonly minimum: 64;
+            readonly maximum: number;
+        };
+        readonly maximumRecords: {
+            readonly minimum: 1;
+            readonly maximum: 1000000;
+        };
+        readonly maximumRecordBytes: {
+            readonly minimum: 22;
+            readonly maximum: number;
+        };
+        readonly maximumResultBytes: {
+            readonly minimum: 1;
+            readonly maximum: number;
+        };
+    };
+};
+export declare const normalizeLocalSmartDbOfflineInspectionInput: (inputArg: ILocalSmartDbOfflineStringValueInspection) => ILocalSmartDbOfflineStringValueInspection;
+export declare const validateSmartDbManagementOperationOptions: (optionsArg?: ISmartDbManagementOperationOptions) => void;

package/dist_ts/ts_smartdb/offline-inspection.js

@@ -0,0 +1,187 @@
+import * as plugins from './plugins.js';
+export const localSmartDbOfflineInspectionBounds = {
+    maximumFolderPathBytes: 4096,
+    maximumNamespaceComponentBytes: 255,
+    maximumFieldNameBytes: 255,
+    maximumMatchValueBytes: 1024 * 1024,
+    maximumRequestBytes: 2 * 1024 * 1024,
+    maximumTimeoutMs: 2_147_483_647,
+    limits: {
+        maximumDataFileBytes: { minimum: 64, maximum: 256 * 1024 * 1024 },
+        maximumWalFileBytes: { minimum: 64, maximum: 64 * 1024 * 1024 },
+        maximumRecords: { minimum: 1, maximum: 1_000_000 },
+        maximumRecordBytes: { minimum: 22, maximum: 17 * 1024 * 1024 },
+        maximumResultBytes: { minimum: 1, maximum: 16 * 1024 * 1024 },
+    },
+};
+const inputKeys = new Set([
+    'folderPath',
+    'databaseName',
+    'collectionName',
+    'match',
+    'valueField',
+    'limits',
+]);
+const matchKeys = new Set(['field', 'value']);
+const limitKeys = [
+    'maximumDataFileBytes',
+    'maximumWalFileBytes',
+    'maximumRecords',
+    'maximumRecordBytes',
+    'maximumResultBytes',
+];
+const limitKeySet = new Set(limitKeys);
+const requestStructuralBytes = plugins.buffer.Buffer.byteLength('{"folderPath":,"databaseName":,"collectionName":,"match":{"field":,"value":},"valueField":,"limits":{"maximumDataFileBytes":,"maximumWalFileBytes":,"maximumRecords":,"maximumRecordBytes":,"maximumResultBytes":}}', 'utf8');
+const requestEnvelopeBytes = plugins.buffer.Buffer.byteLength('{"id":"req_9007199254740991","method":"inspectOfflineStringValue","params":}', 'utf8');
+const isRecord = (valueArg) => typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+const rejectUnknownEnumerableKeys = (valueArg, allowedKeysArg, labelArg) => {
+    for (const key in valueArg) {
+        if (!allowedKeysArg.has(key)) {
+            throw new TypeError(`LocalSmartDb 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(`LocalSmartDb offline inspection ${labelArg} must be a string`);
+    }
+    const bytes = plugins.buffer.Buffer.byteLength(valueArg, 'utf8');
+    if (bytes < minimumBytesArg || bytes > maximumBytesArg) {
+        throw new RangeError(`LocalSmartDb 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(`LocalSmartDb offline inspection ${labelArg} must not contain control characters`);
+            }
+        }
+    }
+};
+export const normalizeLocalSmartDbOfflineInspectionInput = (inputArg) => {
+    if (!isRecord(inputArg)) {
+        throw new TypeError('LocalSmartDb offline inspection input must be an object');
+    }
+    rejectUnknownEnumerableKeys(inputArg, inputKeys, 'input');
+    const inputRecord = inputArg;
+    const match = inputRecord.match;
+    if (!isRecord(match)) {
+        throw new TypeError('LocalSmartDb offline inspection match must be an object');
+    }
+    rejectUnknownEnumerableKeys(match, matchKeys, 'match');
+    const limits = inputRecord.limits;
+    if (!isRecord(limits)) {
+        throw new TypeError('LocalSmartDb 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: {
+            maximumDataFileBytes: limits.maximumDataFileBytes,
+            maximumWalFileBytes: limits.maximumWalFileBytes,
+            maximumRecords: limits.maximumRecords,
+            maximumRecordBytes: limits.maximumRecordBytes,
+            maximumResultBytes: limits.maximumResultBytes,
+        },
+    };
+    const bounds = localSmartDbOfflineInspectionBounds;
+    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(`LocalSmartDb 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(`LocalSmartDb 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('LocalSmartDb offline inspection match.value must not exceed limits.maximumRecordBytes');
+    }
+    let requestBytes = 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(`LocalSmartDb offline inspection request exceeds the ${bounds.maximumRequestBytes}-byte serialized limit`);
+    }
+    return normalized;
+};
+export const validateSmartDbManagementOperationOptions = (optionsArg) => {
+    if (optionsArg === undefined)
+        return;
+    if (!isRecord(optionsArg)) {
+        throw new TypeError('SmartDB management operation options must be an object');
+    }
+    if (optionsArg.timeoutMs !== undefined
+        && (!Number.isSafeInteger(optionsArg.timeoutMs)
+            || optionsArg.timeoutMs <= 0
+            || optionsArg.timeoutMs > localSmartDbOfflineInspectionBounds.maximumTimeoutMs)) {
+        throw new RangeError(`SmartDB management operation timeoutMs must be an integer between 1 and ${localSmartDbOfflineInspectionBounds.maximumTimeoutMs}`);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"offline-inspection.js","sourceRoot":"","sources":["../../ts/ts_smartdb/offline-inspection.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts_smartdb/rust-db-bridge.d.ts

@@ -1,7 +1,7 @@
 import * as plugins from './plugins.js';
 import { EventEmitter } from 'events';
-import type { ISmartDbHealth, ISmartDbDatabaseTenantInput, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseExport, ISmartDbExportDatabaseInput, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, TSmartDbCommitDatabasePublicationResult } from './service-types.js';
-export type { ISmartDbHealth, ISmartDbDatabaseTenantInput, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseExportCollection, ISmartDbDatabaseExport, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, ISmartDbHeldPublicationReceipt, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, TSmartDbCommitDatabasePublicationResult, } from './service-types.js';
+import type { ISmartDbHealth, ISmartDbDatabaseTenantInput, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseExport, ISmartDbExportDatabaseInput, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, TSmartDbCommitDatabasePublicationResult } from './service-types.js';
+export type { ISmartDbHealth, ISmartDbDatabaseTenantInput, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseExportCollection, ISmartDbDatabaseExport, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, ISmartDbHeldPublicationReceipt, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, TSmartDbCommitDatabasePublicationResult, } from './service-types.js';
 /**
  * A single oplog entry returned from the Rust engine.
  */
@@ -130,7 +130,7 @@ export declare class RustDbBridge extends EventEmitter {
      * Spawn the Rust binary in management mode.
      * Returns true if the binary was found and spawned successfully.
      */
-    spawn(): Promise<boolean>;
+    spawn(optionsArg?: ISmartDbManagementOperationOptions): Promise<boolean>;
     /**
      * Kill the Rust process and clean up.
      */
@@ -145,6 +145,7 @@ export declare class RustDbBridge extends EventEmitter {
     get running(): boolean;
     get ownershipReleased(): boolean;
     private awaitManagementOperationTermination;
+    inspectOfflineStringValue(inputArg: ILocalSmartDbOfflineStringValueInspection, optionsArg?: ISmartDbManagementOperationOptions): Promise<TLocalSmartDbOfflineStringValueInspectionResult>;
     transitionAuthMetadataPermissions(usersPathArg: string, expectedModeArg: number, targetModeArg: number): Promise<TAuthMetadataPermissionTransitionStatus>;
     startDb(config: ISmartDbRustConfig): Promise<{
         connectionUri: string;

package/dist_ts/ts_smartdb/rust-db-bridge.js

@@ -3,6 +3,7 @@ import * as path from 'path';
 import * as url from 'url';
 import { EventEmitter } from 'events';
 import { normalizeSmartDbResourceFenceError } from './service-types.js';
+import { normalizeLocalSmartDbOfflineInspectionInput, validateSmartDbManagementOperationOptions, } from './offline-inspection.js';
 export class SmartDbManagementOperationTerminationError extends AggregateError {
     constructor(operationErrorArg, terminationErrorArg) {
         super([operationErrorArg, terminationErrorArg], 'SmartDB management operation failed and Rust engine termination was incomplete', { cause: operationErrorArg });
@@ -81,13 +82,63 @@ export class RustDbBridge extends EventEmitter {
      * Spawn the Rust binary in management mode.
      * Returns true if the binary was found and spawned successfully.
      */
-    async spawn() {
-        const spawned = await this.bridge.spawn();
-        if (spawned) {
-            this.terminationConfirmed = false;
-            this.terminationFailure = undefined;
+    async spawn(optionsArg) {
+        validateSmartDbManagementOperationOptions(optionsArg);
+        if (optionsArg?.signal?.aborted) {
+            throw new plugins.smartrust.RustBridgeRequestError('SmartDB Rust sidecar spawn was aborted before it started', {
+                code: 'ERR_RUST_BRIDGE_REQUEST_ABORTED',
+                method: 'spawn',
+                cause: optionsArg.signal.reason,
+            });
+        }
+        this.terminationConfirmed = false;
+        this.terminationFailure = undefined;
+        const spawnPromise = this.bridge.spawn();
+        let timeout;
+        let abortHandler;
+        const cancellationPromise = new Promise((_resolveArg, rejectArg) => {
+            if (optionsArg?.timeoutMs !== undefined) {
+                timeout = setTimeout(() => {
+                    rejectArg(new plugins.smartrust.RustBridgeRequestError(`SmartDB Rust sidecar spawn timed out after ${optionsArg.timeoutMs}ms`, {
+                        code: 'ERR_RUST_BRIDGE_REQUEST_TIMEOUT',
+                        method: 'spawn',
+                    }));
+                }, optionsArg.timeoutMs);
+            }
+            if (optionsArg?.signal) {
+                abortHandler = () => {
+                    rejectArg(new plugins.smartrust.RustBridgeRequestError('SmartDB Rust sidecar spawn was aborted', {
+                        code: 'ERR_RUST_BRIDGE_REQUEST_ABORTED',
+                        method: 'spawn',
+                        cause: optionsArg.signal.reason,
+                    }));
+                };
+                optionsArg.signal.addEventListener('abort', abortHandler, { once: true });
+            }
+        });
+        try {
+            const spawned = await Promise.race([spawnPromise, cancellationPromise]);
+            if (!spawned) {
+                await this.terminate({ gracePeriodMs: 0 });
+            }
+            return spawned;
+        }
+        catch (error) {
+            try {
+                await this.terminate({ gracePeriodMs: 0 });
+            }
+            catch (terminationError) {
+                throw new SmartDbManagementOperationTerminationError(error, terminationError);
+            }
+            throw error;
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+            if (abortHandler && optionsArg?.signal) {
+                optionsArg.signal.removeEventListener('abort', abortHandler);
+            }
         }
-        return spawned;
     }
     /**
      * Kill the Rust process and clean up.
@@ -154,6 +205,17 @@ export class RustDbBridge extends EventEmitter {
         }
     }
     // --- Convenience methods for each management command ---
+    async inspectOfflineStringValue(inputArg, optionsArg) {
+        const input = normalizeLocalSmartDbOfflineInspectionInput(inputArg);
+        validateSmartDbManagementOperationOptions(optionsArg);
+        try {
+            return await this.bridge.sendCommand('inspectOfflineStringValue', input, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw error;
+        }
+    }
     async transitionAuthMetadataPermissions(usersPathArg, expectedModeArg, targetModeArg) {
         const result = await this.bridge.sendCommand('transitionAuthMetadataPermissions', {
             usersPath: usersPathArg,
@@ -272,4 +334,4 @@ export class RustDbBridge extends EventEmitter {
         return this.bridge.sendCommand('getDocuments', { db, collection, limit, skip });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-db-bridge.js","sourceRoot":"","sources":["../../ts/ts_smartdb/rust-db-bridge.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-db-bridge.js","sourceRoot":"","sources":["../../ts/ts_smartdb/rust-db-bridge.ts"],"names":[],"mappings":"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"}