@push.rocks/smartdb 4.1.0 → 4.2.0

package/dist_ts/00_commitinfo_data.js

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

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, ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, } from './ts_local/index.js';
+export type { ILocalSmartDbOptions, ILocalSmartDbConnectionInfo, ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits, ILocalSmartDbOfflinePhysicalNamespaceInspection, ILocalSmartDbOfflinePhysicalNamespaceInspectionResult, 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, ISmartDbDatabaseAllocationIdentity, ISmartDbDatabaseAllocationLifecycle, ISmartDbDatabaseAllocationReadAccessGrantIdentity, ISmartDbIssueDatabaseAllocationReadAccessGrantInput, ISmartDbIssueDatabaseAllocationReadAccessGrantResult, ISmartDbRevokeDatabaseAllocationReadAccessGrantInput, ISmartDbRevokeDatabaseAllocationReadAccessGrantResult, TSmartDbCommitDatabasePublicationResult, TSmartDbResourceFenceErrorCode, TSmartDbAllocationReadAccessGrantErrorCode, ISmartDbDatabaseTenantInput, ISmartDbAttestDatabaseTenantInput, ISmartDbAttestDatabaseTenantResult, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbAllocateDatabaseTenantInput, ISmartDbAllocateDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseExportCollection, ISmartDbDatabaseExport, ISmartDbDatabaseExportLimits, ISmartDbExportDatabaseInput, ISmartDbDatabaseContentDigestLimits, ISmartDbGetDatabaseContentDigestInput, ISmartDbDatabaseContentDigest, 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 { SmartDbAllocationReadAccessGrantError, normalizeSmartDbAllocationReadAccessGrantError, smartDbAllocationReadAccessGrantErrorCodes, SmartDbResourceFenceError, normalizeSmartDbResourceFenceError, smartDbResourceFenceErrorCodes, createSmartDbEffectivePayloadSha256V1, } from './ts_smartdb/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFckQsNkJBQTZCO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsc0JBQXNCO0FBQ3RCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQVNuRCxtQkFBbUI7QUFDbkIsT0FBTyxFQUNMLDJCQUEyQixFQUMzQixlQUFlLEdBR2hCLE1BQU0seUJBQXlCLENBQUM7QUFFakMsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxVQUFVLEVBQUUsQ0FBQztBQWtEdEIsT0FBTyxFQUNMLHFDQUFxQyxFQUNyQyw4Q0FBOEMsRUFDOUMsMENBQTBDLEVBQzFDLHlCQUF5QixFQUN6QixrQ0FBa0MsRUFDbEMsOEJBQThCLEVBQzlCLHFDQUFxQyxHQUN0QyxNQUFNLHVCQUF1QixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFckQsNkJBQTZCO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsc0JBQXNCO0FBQ3RCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQVluRCxtQkFBbUI7QUFDbkIsT0FBTyxFQUNMLDJCQUEyQixFQUMzQixlQUFlLEdBR2hCLE1BQU0seUJBQXlCLENBQUM7QUFFakMsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxVQUFVLEVBQUUsQ0FBQztBQWtEdEIsT0FBTyxFQUNMLHFDQUFxQyxFQUNyQyw4Q0FBOEMsRUFDOUMsMENBQTBDLEVBQzFDLHlCQUF5QixFQUN6QixrQ0FBa0MsRUFDbEMsOEJBQThCLEVBQzlCLHFDQUFxQyxHQUN0QyxNQUFNLHVCQUF1QixDQUFDIn0=

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

@@ -1,4 +1,4 @@
-import { SmartdbServer, type ILocalSmartDbOfflineStringValueInspection, type ISmartDbManagementOperationOptions, type TLocalSmartDbOfflineStringValueInspectionResult } from '../ts_smartdb/index.js';
+import { SmartdbServer, type ILocalSmartDbOfflinePhysicalNamespaceInspection, type ILocalSmartDbOfflinePhysicalNamespaceInspectionResult, type ILocalSmartDbOfflineStringValueInspection, type ISmartDbManagementOperationOptions, type TLocalSmartDbOfflineStringValueInspectionResult } from '../ts_smartdb/index.js';
 /**
  * Connection information returned by LocalSmartDb.start()
  */
@@ -48,6 +48,12 @@ export declare class LocalSmartDb {
     private generatedSocketPath;
     constructor(options: ILocalSmartDbOptions);
     private static createOfflineInspectionBridge;
+    private static runOfflineInspection;
+    /**
+     * Inspect physical database and collection names while the owning engine is stopped.
+     * This starts only the Rust management sidecar and never initializes storage.
+     */
+    static inspectOfflinePhysicalNamespaces(inputArg: ILocalSmartDbOfflinePhysicalNamespaceInspection, optionsArg?: ISmartDbManagementOperationOptions): Promise<ILocalSmartDbOfflinePhysicalNamespaceInspectionResult>;
     /**
      * Inspect one exact string value while the owning LocalSmartDb engine is stopped.
      * This starts only the Rust management sidecar and never initializes storage.

package/dist_ts/ts_local/classes.localsmartdb.js

@@ -5,7 +5,7 @@ import * as path from 'path';
 import * as os from 'os';
 import { RustDbBridge, SmartdbServer, } from '../ts_smartdb/index.js';
 import { StorageMigrator } from '../ts_migration/index.js';
-import { normalizeLocalSmartDbOfflineInspectionInput, validateSmartDbManagementOperationOptions, } from '../ts_smartdb/offline-inspection.js';
+import { normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput, normalizeLocalSmartDbOfflineInspectionInput, validateSmartDbManagementOperationOptions, } from '../ts_smartdb/offline-inspection.js';
 /**
  * LocalSmartDb - Lightweight local MongoDB-compatible database using Unix sockets
  *
@@ -43,15 +43,11 @@ export class LocalSmartDb {
     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);
+    static async runOfflineInspection(inputArg, optionsArg, normalizeInputArg, inspectArg) {
+        const validatedInput = normalizeInputArg(inputArg);
         validateSmartDbManagementOperationOptions(optionsArg);
         optionsArg?.signal?.throwIfAborted();
-        const input = normalizeLocalSmartDbOfflineInspectionInput({
+        const input = normalizeInputArg({
             ...validatedInput,
             folderPath: path.resolve(validatedInput.folderPath),
         });
@@ -89,7 +85,7 @@ export class LocalSmartDb {
                     timeoutMs: remainingMs,
                 };
             }
-            result = await bridge.inspectOfflineStringValue(input, commandOptions);
+            result = await inspectArg(bridge, input, commandOptions);
         }
         catch (error) {
             operationFailed = true;
@@ -109,6 +105,20 @@ export class LocalSmartDb {
         }
         return result;
     }
+    /**
+     * Inspect physical database and collection names while the owning engine is stopped.
+     * This starts only the Rust management sidecar and never initializes storage.
+     */
+    static async inspectOfflinePhysicalNamespaces(inputArg, optionsArg) {
+        return LocalSmartDb.runOfflineInspection(inputArg, optionsArg, normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput, (bridgeArg, input, commandOptions) => bridgeArg.inspectOfflinePhysicalNamespaces(input, commandOptions));
+    }
+    /**
+     * 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) {
+        return LocalSmartDb.runOfflineInspection(inputArg, optionsArg, normalizeLocalSmartDbOfflineInspectionInput, (bridgeArg, input, commandOptions) => bridgeArg.inspectOfflineStringValue(input, commandOptions));
+    }
     /**
      * Generate a unique socket path in /tmp
      */
@@ -236,4 +246,4 @@ export class LocalSmartDb {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.localsmartdb.js","sourceRoot":"","sources":["../../ts/ts_local/classes.localsmartdb.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts_local/index.d.ts

@@ -1,3 +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';
+export type { ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits, ILocalSmartDbOfflinePhysicalNamespaceInspection, ILocalSmartDbOfflinePhysicalNamespaceInspectionResult, 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, ISmartDbDatabaseAllocationIdentity, ISmartDbDatabaseAllocationLifecycle, ISmartDbDatabaseAllocationReadAccessGrantIdentity, ISmartDbIssueDatabaseAllocationReadAccessGrantInput, ISmartDbIssueDatabaseAllocationReadAccessGrantResult, ISmartDbRevokeDatabaseAllocationReadAccessGrantInput, ISmartDbRevokeDatabaseAllocationReadAccessGrantResult, ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, TSmartDbCommitDatabasePublicationResult, TSmartDbResourceFenceErrorCode, TSmartDbAllocationReadAccessGrantErrorCode, ISmartDbDatabaseTenantInput, ISmartDbAttestDatabaseTenantInput, ISmartDbAttestDatabaseTenantResult, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbAllocateDatabaseTenantInput, ISmartDbAllocateDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseExportCollection, ISmartDbDatabaseExport, ISmartDbDatabaseExportLimits, ISmartDbExportDatabaseInput, ISmartDbDatabaseContentDigestLimits, ISmartDbGetDatabaseContentDigestInput, ISmartDbDatabaseContentDigest, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, } from './service-types.js';
+export type { ISmartDbHealth, ISmartDbResourceFence, ISmartDbResourceFenceReceipt, ISmartDbHeldPublicationReceipt, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, ISmartDbDatabaseAllocationIdentity, ISmartDbDatabaseAllocationLifecycle, ISmartDbDatabaseAllocationReadAccessGrantIdentity, ISmartDbIssueDatabaseAllocationReadAccessGrantInput, ISmartDbIssueDatabaseAllocationReadAccessGrantResult, ISmartDbRevokeDatabaseAllocationReadAccessGrantInput, ISmartDbRevokeDatabaseAllocationReadAccessGrantResult, ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits, ILocalSmartDbOfflinePhysicalNamespaceInspection, ILocalSmartDbOfflinePhysicalNamespaceInspectionResult, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, TSmartDbCommitDatabasePublicationResult, TSmartDbResourceFenceErrorCode, TSmartDbAllocationReadAccessGrantErrorCode, ISmartDbDatabaseTenantInput, ISmartDbAttestDatabaseTenantInput, ISmartDbAttestDatabaseTenantResult, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbAllocateDatabaseTenantInput, ISmartDbAllocateDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseExportCollection, ISmartDbDatabaseExport, ISmartDbDatabaseExportLimits, ISmartDbExportDatabaseInput, ISmartDbDatabaseContentDigestLimits, ISmartDbGetDatabaseContentDigestInput, ISmartDbDatabaseContentDigest, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, } from './service-types.js';
 export { SmartDbAllocationReadAccessGrantError, normalizeSmartDbAllocationReadAccessGrantError, smartDbAllocationReadAccessGrantErrorCodes, 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 { SmartDbAllocationReadAccessGrantError, normalizeSmartDbAllocationReadAccessGrantError, smartDbAllocationReadAccessGrantErrorCodes, SmartDbResourceFenceError, normalizeSmartDbResourceFenceError, smartDbResourceFenceErrorCodes, } from './service-types.js';
 export { createSmartDbEffectivePayloadSha256V1 } from './resource-fencing.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19zbWFydGRiL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhEQUE4RDtBQUU5RCx5REFBeUQ7QUFDekQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBUzFELHNFQUFzRTtBQUN0RSxPQUFPLEVBQ0wsWUFBWSxFQUNaLDBDQUEwQyxHQUMzQyxNQUFNLHFCQUFxQixDQUFDO0FBd0Q3QixPQUFPLEVBQ0wscUNBQXFDLEVBQ3JDLDhDQUE4QyxFQUM5QywwQ0FBMEMsRUFDMUMseUJBQXlCLEVBQ3pCLGtDQUFrQyxFQUNsQyw4QkFBOEIsR0FDL0IsTUFBTSxvQkFBb0IsQ0FBQztBQUU1QixPQUFPLEVBQUUscUNBQXFDLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19zbWFydGRiL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhEQUE4RDtBQUU5RCx5REFBeUQ7QUFDekQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBUzFELHNFQUFzRTtBQUN0RSxPQUFPLEVBQ0wsWUFBWSxFQUNaLDBDQUEwQyxHQUMzQyxNQUFNLHFCQUFxQixDQUFDO0FBMkQ3QixPQUFPLEVBQ0wscUNBQXFDLEVBQ3JDLDhDQUE4QyxFQUM5QywwQ0FBMEMsRUFDMUMseUJBQXlCLEVBQ3pCLGtDQUFrQyxFQUNsQyw4QkFBOEIsR0FDL0IsTUFBTSxvQkFBb0IsQ0FBQztBQUU1QixPQUFPLEVBQUUscUNBQXFDLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQyJ9

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

@@ -1,4 +1,4 @@
-import type { ILocalSmartDbOfflineStringValueInspection, ISmartDbManagementOperationOptions } from './service-types.js';
+import type { ILocalSmartDbOfflinePhysicalNamespaceInspection, ILocalSmartDbOfflineStringValueInspection, ISmartDbManagementOperationOptions } from './service-types.js';
 export declare const localSmartDbOfflineInspectionBounds: {
     readonly maximumFolderPathBytes: 4096;
     readonly maximumNamespaceComponentBytes: 255;
@@ -29,5 +29,56 @@ export declare const localSmartDbOfflineInspectionBounds: {
         };
     };
 };
+export declare const localSmartDbOfflinePhysicalNamespaceInspectionBounds: {
+    readonly maximumFolderPathBytes: 4096;
+    readonly maximumRequestBytes: number;
+    readonly limits: {
+        readonly maximumEntries: {
+            readonly minimum: 1;
+            readonly maximum: 100000;
+        };
+        readonly maximumDatabases: {
+            readonly minimum: 1;
+            readonly maximum: 4096;
+        };
+        readonly maximumCollections: {
+            readonly minimum: 1;
+            readonly maximum: 10000;
+        };
+        readonly maximumIndexes: {
+            readonly minimum: 1;
+            readonly maximum: 100000;
+        };
+        readonly maximumDataFileBytes: {
+            readonly minimum: 64;
+            readonly maximum: number;
+        };
+        readonly maximumWalFileBytes: {
+            readonly minimum: 64;
+            readonly maximum: number;
+        };
+        readonly maximumIndexFileBytes: {
+            readonly minimum: 2;
+            readonly maximum: number;
+        };
+        readonly maximumTotalFileBytes: {
+            readonly minimum: 1;
+            readonly maximum: number;
+        };
+        readonly maximumRecordsPerCollection: {
+            readonly minimum: 1;
+            readonly maximum: 1000000;
+        };
+        readonly maximumRecordBytes: {
+            readonly minimum: 22;
+            readonly maximum: number;
+        };
+        readonly maximumResultBytes: {
+            readonly minimum: 32;
+            readonly maximum: number;
+        };
+    };
+};
 export declare const normalizeLocalSmartDbOfflineInspectionInput: (inputArg: ILocalSmartDbOfflineStringValueInspection) => ILocalSmartDbOfflineStringValueInspection;
+export declare const normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput: (inputArg: ILocalSmartDbOfflinePhysicalNamespaceInspection) => ILocalSmartDbOfflinePhysicalNamespaceInspection;
 export declare const validateSmartDbManagementOperationOptions: (optionsArg?: ISmartDbManagementOperationOptions) => void;

package/dist_ts/ts_smartdb/offline-inspection.js

@@ -14,6 +14,23 @@ export const localSmartDbOfflineInspectionBounds = {
         maximumResultBytes: { minimum: 1, maximum: 16 * 1024 * 1024 },
     },
 };
+export const localSmartDbOfflinePhysicalNamespaceInspectionBounds = {
+    maximumFolderPathBytes: 4096,
+    maximumRequestBytes: 2 * 1024 * 1024,
+    limits: {
+        maximumEntries: { minimum: 1, maximum: 100_000 },
+        maximumDatabases: { minimum: 1, maximum: 4096 },
+        maximumCollections: { minimum: 1, maximum: 10_000 },
+        maximumIndexes: { minimum: 1, maximum: 100_000 },
+        maximumDataFileBytes: { minimum: 64, maximum: 256 * 1024 * 1024 },
+        maximumWalFileBytes: { minimum: 64, maximum: 64 * 1024 * 1024 },
+        maximumIndexFileBytes: { minimum: 2, maximum: 16 * 1024 * 1024 },
+        maximumTotalFileBytes: { minimum: 1, maximum: 1024 * 1024 * 1024 * 1024 },
+        maximumRecordsPerCollection: { minimum: 1, maximum: 1_000_000 },
+        maximumRecordBytes: { minimum: 22, maximum: 17 * 1024 * 1024 },
+        maximumResultBytes: { minimum: 32, maximum: 16 * 1024 * 1024 },
+    },
+};
 const inputKeys = new Set([
     'folderPath',
     'databaseName',
@@ -33,7 +50,41 @@ const limitKeys = [
 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 physicalNamespaceInputKeys = new Set(['folderPath', 'limits']);
+const physicalNamespaceLimitKeys = [
+    'maximumEntries',
+    'maximumDatabases',
+    'maximumCollections',
+    'maximumIndexes',
+    'maximumDataFileBytes',
+    'maximumWalFileBytes',
+    'maximumIndexFileBytes',
+    '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(`LocalSmartDb offline physical namespace inspection ${labelArg} must be a plain object`);
+    }
+    for (const key in valueArg) {
+        if (!allowedKeysArg.has(key)) {
+            throw new TypeError(`LocalSmartDb offline physical namespace inspection ${labelArg} contains unknown key '${key}'`);
+        }
+    }
+    if (Object.getPrototypeOf(valueArg) !== Object.prototype) {
+        throw new TypeError(`LocalSmartDb 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(`LocalSmartDb 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)) {
@@ -171,6 +222,58 @@ export const normalizeLocalSmartDbOfflineInspectionInput = (inputArg) => {
     }
     return normalized;
 };
+export const normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput = (inputArg) => {
+    const inputRecord = requirePhysicalNamespacePlainObject(inputArg, physicalNamespaceInputKeys, 'input');
+    const limits = requirePhysicalNamespacePlainObject(inputRecord.limits, physicalNamespaceLimitKeySet, 'limits');
+    const normalized = {
+        folderPath: inputRecord.folderPath,
+        limits: {
+            maximumEntries: limits.maximumEntries,
+            maximumDatabases: limits.maximumDatabases,
+            maximumCollections: limits.maximumCollections,
+            maximumIndexes: limits.maximumIndexes,
+            maximumDataFileBytes: limits.maximumDataFileBytes,
+            maximumWalFileBytes: limits.maximumWalFileBytes,
+            maximumIndexFileBytes: limits.maximumIndexFileBytes,
+            maximumTotalFileBytes: limits.maximumTotalFileBytes,
+            maximumRecordsPerCollection: limits.maximumRecordsPerCollection,
+            maximumRecordBytes: limits.maximumRecordBytes,
+            maximumResultBytes: limits.maximumResultBytes,
+        },
+    };
+    const bounds = localSmartDbOfflinePhysicalNamespaceInspectionBounds;
+    if (typeof normalized.folderPath !== 'string') {
+        throw new TypeError('LocalSmartDb 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(`LocalSmartDb 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('LocalSmartDb 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(`LocalSmartDb 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(`LocalSmartDb offline physical namespace inspection request exceeds the ${bounds.maximumRequestBytes}-byte serialized limit`);
+    }
+    return normalized;
+};
 export const validateSmartDbManagementOperationOptions = (optionsArg) => {
     if (optionsArg === undefined)
         return;
@@ -184,4 +287,4 @@ export const validateSmartDbManagementOperationOptions = (optionsArg) => {
         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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"}
+//# 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, ISmartDbAttestDatabaseTenantInput, ISmartDbAttestDatabaseTenantResult, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbAllocateDatabaseTenantInput, ISmartDbAllocateDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbIssueDatabaseAllocationReadAccessGrantInput, ISmartDbIssueDatabaseAllocationReadAccessGrantResult, ISmartDbRevokeDatabaseAllocationReadAccessGrantInput, ISmartDbRevokeDatabaseAllocationReadAccessGrantResult, ISmartDbDatabaseExport, ISmartDbExportDatabaseInput, ISmartDbDatabaseContentDigest, ISmartDbGetDatabaseContentDigestInput, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, TSmartDbCommitDatabasePublicationResult } from './service-types.js';
-export type { ISmartDbHealth, ISmartDbDatabaseTenantInput, ISmartDbAttestDatabaseTenantInput, ISmartDbAttestDatabaseTenantResult, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbAllocateDatabaseTenantInput, ISmartDbAllocateDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseAllocationReadAccessGrantIdentity, ISmartDbIssueDatabaseAllocationReadAccessGrantInput, ISmartDbIssueDatabaseAllocationReadAccessGrantResult, ISmartDbRevokeDatabaseAllocationReadAccessGrantInput, ISmartDbRevokeDatabaseAllocationReadAccessGrantResult, ISmartDbDatabaseExportCollection, ISmartDbDatabaseExport, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, ISmartDbHeldPublicationReceipt, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, TSmartDbCommitDatabasePublicationResult, } from './service-types.js';
+import type { ISmartDbHealth, ISmartDbDatabaseTenantInput, ISmartDbAttestDatabaseTenantInput, ISmartDbAttestDatabaseTenantResult, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbAllocateDatabaseTenantInput, ISmartDbAllocateDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbIssueDatabaseAllocationReadAccessGrantInput, ISmartDbIssueDatabaseAllocationReadAccessGrantResult, ISmartDbRevokeDatabaseAllocationReadAccessGrantInput, ISmartDbRevokeDatabaseAllocationReadAccessGrantResult, ISmartDbDatabaseExport, ISmartDbExportDatabaseInput, ISmartDbDatabaseContentDigest, ISmartDbGetDatabaseContentDigestInput, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, ILocalSmartDbOfflinePhysicalNamespaceInspection, ILocalSmartDbOfflinePhysicalNamespaceInspectionResult, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, TSmartDbCommitDatabasePublicationResult } from './service-types.js';
+export type { ISmartDbHealth, ISmartDbDatabaseTenantInput, ISmartDbAttestDatabaseTenantInput, ISmartDbAttestDatabaseTenantResult, ISmartDbEnsureDatabaseTenantInput, ISmartDbEnsureDatabaseTenantResult, ISmartDbAllocateDatabaseTenantInput, ISmartDbAllocateDatabaseTenantResult, ISmartDbDeleteDatabaseTenantInput, ISmartDbRotateDatabaseTenantPasswordInput, ISmartDbDatabaseTenantDescriptor, ISmartDbDeleteDatabaseTenantResult, ISmartDbDatabaseAllocationReadAccessGrantIdentity, ISmartDbIssueDatabaseAllocationReadAccessGrantInput, ISmartDbIssueDatabaseAllocationReadAccessGrantResult, ISmartDbRevokeDatabaseAllocationReadAccessGrantInput, ISmartDbRevokeDatabaseAllocationReadAccessGrantResult, ISmartDbDatabaseExportCollection, ISmartDbDatabaseExport, ISmartDbImportDatabaseInput, ISmartDbImportDatabaseResult, ISmartDbHeldPublicationReceipt, ISmartDbCommitDatabasePublicationInput, ISmartDbManagementOperationOptions, ISmartDbDatabaseResourceFenceState, ILocalSmartDbOfflineInspectionLimits, ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits, ILocalSmartDbOfflinePhysicalNamespaceInspection, ILocalSmartDbOfflinePhysicalNamespaceInspectionResult, ILocalSmartDbOfflineStringValueInspection, TLocalSmartDbOfflineStringValueInspectionResult, TSmartDbCommitDatabasePublicationResult, } from './service-types.js';
 /**
  * A single oplog entry returned from the Rust engine.
  */
@@ -145,6 +145,7 @@ export declare class RustDbBridge extends EventEmitter {
     get running(): boolean;
     get ownershipReleased(): boolean;
     private awaitManagementOperationTermination;
+    inspectOfflinePhysicalNamespaces(inputArg: ILocalSmartDbOfflinePhysicalNamespaceInspection, optionsArg?: ISmartDbManagementOperationOptions): Promise<ILocalSmartDbOfflinePhysicalNamespaceInspectionResult>;
     inspectOfflineStringValue(inputArg: ILocalSmartDbOfflineStringValueInspection, optionsArg?: ISmartDbManagementOperationOptions): Promise<TLocalSmartDbOfflineStringValueInspectionResult>;
     transitionAuthMetadataPermissions(usersPathArg: string, expectedModeArg: number, targetModeArg: number, optionsArg?: ISmartDbManagementOperationOptions): Promise<TAuthMetadataPermissionTransitionStatus>;
     startDb(config: ISmartDbRustConfig, optionsArg?: ISmartDbManagementOperationOptions): Promise<{

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

@@ -3,7 +3,7 @@ import * as path from 'path';
 import * as url from 'url';
 import { EventEmitter } from 'events';
 import { normalizeSmartDbAllocationReadAccessGrantError, normalizeSmartDbResourceFenceError, } from './service-types.js';
-import { normalizeLocalSmartDbOfflineInspectionInput, validateSmartDbManagementOperationOptions, } from './offline-inspection.js';
+import { normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput, 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 });
@@ -205,6 +205,21 @@ export class RustDbBridge extends EventEmitter {
         }
     }
     // --- Convenience methods for each management command ---
+    async inspectOfflinePhysicalNamespaces(inputArg, optionsArg) {
+        const input = normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput(inputArg);
+        validateSmartDbManagementOperationOptions(optionsArg);
+        const params = {
+            folderPath: input.folderPath,
+            ...input.limits,
+        };
+        try {
+            return await this.bridge.sendCommand('inspectOfflinePhysicalNamespaces', params, optionsArg);
+        }
+        catch (error) {
+            await this.awaitManagementOperationTermination(error);
+            throw error;
+        }
+    }
     async inspectOfflineStringValue(inputArg, optionsArg) {
         const input = normalizeLocalSmartDbOfflineInspectionInput(inputArg);
         validateSmartDbManagementOperationOptions(optionsArg);
@@ -397,4 +412,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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"}

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

@@ -44,6 +44,30 @@ export type TLocalSmartDbOfflineStringValueInspectionResult = {
     status: 'found';
     value: string;
 };
+export interface ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits {
+    maximumEntries: number;
+    maximumDatabases: number;
+    maximumCollections: number;
+    maximumIndexes: number;
+    maximumDataFileBytes: number;
+    maximumWalFileBytes: number;
+    maximumIndexFileBytes: number;
+    maximumTotalFileBytes: number;
+    maximumRecordsPerCollection: number;
+    maximumRecordBytes: number;
+    maximumResultBytes: number;
+}
+export interface ILocalSmartDbOfflinePhysicalNamespaceInspection {
+    folderPath: string;
+    limits: ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits;
+}
+export interface ILocalSmartDbOfflinePhysicalNamespaceInspectionResult {
+    schemaVersion: 1;
+    databases: Array<{
+        name: string;
+        collections: string[];
+    }>;
+}
 export declare const smartDbResourceFenceErrorCodes: 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 TSmartDbResourceFenceErrorCode = (typeof smartDbResourceFenceErrorCodes)[number];
 export interface ISmartDbResourceFence {

package/dist_ts/ts_smartdb/service-types.js

@@ -59,4 +59,4 @@ export const normalizeSmartDbResourceFenceError = (errorArg) => {
     }
     return new SmartDbResourceFenceError(match[1], match[2], error);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartdb",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "private": false,
   "description": "A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.",
   "exports": {

package/readme.md

@@ -540,6 +540,7 @@ const db = new LocalSmartDb({
 | `getServer()` | `SmartdbServer` | Access the underlying server |
 | `running` | `boolean` | Whether the server is running |
 | `LocalSmartDb.inspectOfflineStringValue(input, options?)` | `Promise<TLocalSmartDbOfflineStringValueInspectionResult>` | Read one exact top-level string value from stopped file storage without starting or mutating the engine |
+| `LocalSmartDb.inspectOfflinePhysicalNamespaces(input, options?)` | `Promise<ILocalSmartDbOfflinePhysicalNamespaceInspectionResult>` | Validate stopped physical file storage and return only deterministic database and collection names |
 
 #### Offline String-Value Inspection
 
@@ -593,6 +594,67 @@ The TypeScript API enforces these bounds before creating the sidecar or serializ
 
 All numeric limits must be positive safe integers. The caller must stop and retain external ownership of the `LocalSmartDb` daemon for the full call. Current storage roots additionally enforce this through SmartDB's storage-owner lock. Roots created before that lock existed rely on the caller's external single-owner coordination plus descriptor and stability validation. One `timeoutMs` budget covers sidecar lookup/spawn, readiness, and the command. Cancellation or timeout kills and reaps the disposable sidecar before the call rejects.
 
+#### Offline Physical Namespace Inspection
+
+`inspectOfflinePhysicalNamespaces()` is a Linux-only management API for validating and listing the physical database and collection namespaces in a stopped SmartDB file-storage root. It uses Linux `openat2` descriptor traversal and starts only the disposable Rust management sidecar. It never calls `SmartdbServer.start()`, opens a database listener, initializes the storage adapter, runs migration or recovery, repairs a tail, truncates a WAL, compacts data, or persists a hint.
+
+```typescript
+import { LocalSmartDb } from '@push.rocks/smartdb';
+
+const namespaces = await LocalSmartDb.inspectOfflinePhysicalNamespaces({
+  folderPath: '/var/lib/myapp/smartdb',
+  limits: {
+    maximumEntries: 100_000,
+    maximumDatabases: 4096,
+    maximumCollections: 10_000,
+    maximumIndexes: 100_000,
+    maximumDataFileBytes: 256 * 1024 * 1024,
+    maximumWalFileBytes: 64 * 1024 * 1024,
+    maximumIndexFileBytes: 16 * 1024 * 1024,
+    maximumTotalFileBytes: 1024 * 1024 * 1024 * 1024,
+    maximumRecordsPerCollection: 1_000_000,
+    maximumRecordBytes: 17 * 1024 * 1024,
+    maximumResultBytes: 16 * 1024 * 1024,
+  },
+}, {
+  timeoutMs: 30_000,
+});
+
+// {
+//   schemaVersion: 1,
+//   databases: [
+//     { name: 'myapp', collections: ['MetadataDoc', 'system.views'] },
+//   ],
+// }
+```
+
+The result is exactly `{ schemaVersion: 1, databases: Array<{ name, collections }> }`. Databases and each database's collections are sorted by physical name, empty database directories are retained, and no documents, index definitions, record identifiers, or values cross the management boundary.
+
+The accepted root must contain the current `.__rustdb_internal/storage-owner.lock`; legacy roots without that lock are rejected. The sidecar takes the shared owner lock, so an active engine causes the call to fail. Every reported collection must have the canonical complete profile of regular `data.rdb`, `wal.rdb`, and `indexes.json` files. A regular `keydir.hint` is optional and is treated only as an allowed cache file. Missing canonical files, unexpected collection entries, malformed index metadata, invalid data or WAL records, symlinks, cross-filesystem traversal, resource-limit exhaustion, and changes observed during inspection fail the complete operation. No partial result is returned and the storage tree is not mutated.
+
+Inspection performs two full bounded passes and returns only if their namespace results and retained filesystem observations agree. The entry, database, collection, index, file-byte, and record limits are enforced independently on each pass, so total validation work is at most twice the corresponding caller cap. The result-size cap applies to the single serialized result. This is a contract for the current owner-locked canonical SmartDB file-storage profile, not a claim of compatibility with arbitrary MongoDB layouts, legacy SmartDB roots, or unspecified future storage formats.
+
+All limits are required; this API supplies no defaults or compatibility aliases. TypeScript validates the following bounds before creating the sidecar and revalidates `folderPath` after resolving it to an absolute path:
+
+| Input | Enforced range |
+|---|---|
+| `folderPath` | 1 to 4096 UTF-8 bytes before and after absolute resolution; no control characters |
+| Complete serialized request | At most 2,097,152 bytes |
+| `timeoutMs` | 1 to 2,147,483,647 milliseconds |
+| `maximumEntries` | 1 to 100,000 directory entries per pass |
+| `maximumDatabases` | 1 to 4,096 databases per pass |
+| `maximumCollections` | 1 to 10,000 collections per pass |
+| `maximumIndexes` | 1 to 100,000 index definitions per pass |
+| `maximumDataFileBytes` | 64 to 268,435,456 bytes per data file |
+| `maximumWalFileBytes` | 64 to 67,108,864 bytes per WAL file |
+| `maximumIndexFileBytes` | 2 to 16,777,216 bytes per index file |
+| `maximumTotalFileBytes` | 1 to 1,099,511,627,776 aggregate canonical collection-file bytes per pass |
+| `maximumRecordsPerCollection` | 1 to 1,000,000 data records plus WAL records/commit markers per collection per pass |
+| `maximumRecordBytes` | 22 to 17,825,792 bytes per record |
+| `maximumResultBytes` | 32 to 16,777,216 serialized result bytes |
+
+Every numeric value must be a safe integer. One optional `timeoutMs` budget and `AbortSignal` cover sidecar lookup/spawn, readiness, both inspection passes, and response delivery; timeout or cancellation kills and reaps the sidecar before rejection. For a point-in-time ownership proof, the caller must exclude every engine start and other storage lifecycle change continuously from before invocation through acceptance or handoff of the returned result. The owner lock proves that the engine was stopped during inspection, but it cannot replace that caller-held lifecycle exclusion after the sidecar releases its lock.
+
 ### SmartdbDebugServer
 
 Web-based debug dashboard served via `@api.global/typedserver`. Import from the `debugserver` subpath:

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartdb',
-  version: '4.1.0',
+  version: '4.2.0',
   description: 'A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.'
 }

package/ts/index.ts

@@ -9,6 +9,9 @@ export type {
   ILocalSmartDbOptions,
   ILocalSmartDbConnectionInfo,
   ILocalSmartDbOfflineInspectionLimits,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits,
+  ILocalSmartDbOfflinePhysicalNamespaceInspection,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionResult,
   ILocalSmartDbOfflineStringValueInspection,
   TLocalSmartDbOfflineStringValueInspectionResult,
 } from './ts_local/index.js';

package/ts/ts_local/classes.localsmartdb.ts

@@ -6,12 +6,15 @@ import * as os from 'os';
 import {
   RustDbBridge,
   SmartdbServer,
+  type ILocalSmartDbOfflinePhysicalNamespaceInspection,
+  type ILocalSmartDbOfflinePhysicalNamespaceInspectionResult,
   type ILocalSmartDbOfflineStringValueInspection,
   type ISmartDbManagementOperationOptions,
   type TLocalSmartDbOfflineStringValueInspectionResult,
 } from '../ts_smartdb/index.js';
 import { StorageMigrator } from '../ts_migration/index.js';
 import {
+  normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput,
   normalizeLocalSmartDbOfflineInspectionInput,
   validateSmartDbManagementOperationOptions,
 } from '../ts_smartdb/offline-inspection.js';
@@ -74,19 +77,24 @@ export class LocalSmartDb {
     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.
-   */
-  public static async inspectOfflineStringValue(
-    inputArg: ILocalSmartDbOfflineStringValueInspection,
-    optionsArg?: ISmartDbManagementOperationOptions,
-  ): Promise<TLocalSmartDbOfflineStringValueInspectionResult> {
-    const validatedInput = normalizeLocalSmartDbOfflineInspectionInput(inputArg);
+  private static async runOfflineInspection<
+    TInput extends { folderPath: string },
+    TResult,
+  >(
+    inputArg: TInput,
+    optionsArg: ISmartDbManagementOperationOptions | undefined,
+    normalizeInputArg: (inputArg: TInput) => TInput,
+    inspectArg: (
+      bridgeArg: RustDbBridge,
+      inputArg: TInput,
+      optionsArg?: ISmartDbManagementOperationOptions,
+    ) => Promise<TResult>,
+  ): Promise<TResult> {
+    const validatedInput = normalizeInputArg(inputArg);
     validateSmartDbManagementOperationOptions(optionsArg);
     optionsArg?.signal?.throwIfAborted();
 
-    const input = normalizeLocalSmartDbOfflineInspectionInput({
+    const input = normalizeInputArg({
       ...validatedInput,
       folderPath: path.resolve(validatedInput.folderPath),
     });
@@ -96,7 +104,7 @@ export class LocalSmartDb {
     const bridge = LocalSmartDb.createOfflineInspectionBridge();
     let operationFailed = false;
     let operationError: unknown;
-    let result: TLocalSmartDbOfflineStringValueInspectionResult | undefined;
+    let result: TResult | undefined;
     try {
       let spawnOptions = optionsArg;
       if (deadline !== undefined) {
@@ -126,7 +134,7 @@ export class LocalSmartDb {
           timeoutMs: remainingMs,
         };
       }
-      result = await bridge.inspectOfflineStringValue(input, commandOptions);
+      result = await inspectArg(bridge, input, commandOptions);
     } catch (error) {
       operationFailed = true;
       operationError = error;
@@ -147,7 +155,41 @@ export class LocalSmartDb {
     if (operationFailed) {
       throw operationError;
     }
-    return result as TLocalSmartDbOfflineStringValueInspectionResult;
+    return result as TResult;
+  }
+
+  /**
+   * Inspect physical database and collection names while the owning engine is stopped.
+   * This starts only the Rust management sidecar and never initializes storage.
+   */
+  public static async inspectOfflinePhysicalNamespaces(
+    inputArg: ILocalSmartDbOfflinePhysicalNamespaceInspection,
+    optionsArg?: ISmartDbManagementOperationOptions,
+  ): Promise<ILocalSmartDbOfflinePhysicalNamespaceInspectionResult> {
+    return LocalSmartDb.runOfflineInspection(
+      inputArg,
+      optionsArg,
+      normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput,
+      (bridgeArg, input, commandOptions) =>
+        bridgeArg.inspectOfflinePhysicalNamespaces(input, commandOptions),
+    );
+  }
+
+  /**
+   * Inspect one exact string value while the owning LocalSmartDb engine is stopped.
+   * This starts only the Rust management sidecar and never initializes storage.
+   */
+  public static async inspectOfflineStringValue(
+    inputArg: ILocalSmartDbOfflineStringValueInspection,
+    optionsArg?: ISmartDbManagementOperationOptions,
+  ): Promise<TLocalSmartDbOfflineStringValueInspectionResult> {
+    return LocalSmartDb.runOfflineInspection(
+      inputArg,
+      optionsArg,
+      normalizeLocalSmartDbOfflineInspectionInput,
+      (bridgeArg, input, commandOptions) =>
+        bridgeArg.inspectOfflineStringValue(input, commandOptions),
+    );
   }
 
   /**

package/ts/ts_local/index.ts

@@ -2,6 +2,9 @@ export { LocalSmartDb } from './classes.localsmartdb.js';
 export type { ILocalSmartDbOptions, ILocalSmartDbConnectionInfo } from './classes.localsmartdb.js';
 export type {
   ILocalSmartDbOfflineInspectionLimits,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits,
+  ILocalSmartDbOfflinePhysicalNamespaceInspection,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionResult,
   ILocalSmartDbOfflineStringValueInspection,
   TLocalSmartDbOfflineStringValueInspectionResult,
 } from '../ts_smartdb/service-types.js';

package/ts/ts_smartdb/index.ts

@@ -44,6 +44,9 @@ export type {
   ISmartDbRevokeDatabaseAllocationReadAccessGrantInput,
   ISmartDbRevokeDatabaseAllocationReadAccessGrantResult,
   ILocalSmartDbOfflineInspectionLimits,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits,
+  ILocalSmartDbOfflinePhysicalNamespaceInspection,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionResult,
   ILocalSmartDbOfflineStringValueInspection,
   TLocalSmartDbOfflineStringValueInspectionResult,
   TSmartDbCommitDatabasePublicationResult,

package/ts/ts_smartdb/offline-inspection.ts

@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
 import type {
+  ILocalSmartDbOfflinePhysicalNamespaceInspection,
   ILocalSmartDbOfflineStringValueInspection,
   ISmartDbManagementOperationOptions,
 } from './service-types.js';
@@ -20,6 +21,24 @@ export const localSmartDbOfflineInspectionBounds = {
   },
 } as const;
 
+export const localSmartDbOfflinePhysicalNamespaceInspectionBounds = {
+  maximumFolderPathBytes: 4096,
+  maximumRequestBytes: 2 * 1024 * 1024,
+  limits: {
+    maximumEntries: { minimum: 1, maximum: 100_000 },
+    maximumDatabases: { minimum: 1, maximum: 4096 },
+    maximumCollections: { minimum: 1, maximum: 10_000 },
+    maximumIndexes: { minimum: 1, maximum: 100_000 },
+    maximumDataFileBytes: { minimum: 64, maximum: 256 * 1024 * 1024 },
+    maximumWalFileBytes: { minimum: 64, maximum: 64 * 1024 * 1024 },
+    maximumIndexFileBytes: { minimum: 2, maximum: 16 * 1024 * 1024 },
+    maximumTotalFileBytes: { minimum: 1, maximum: 1024 * 1024 * 1024 * 1024 },
+    maximumRecordsPerCollection: { minimum: 1, maximum: 1_000_000 },
+    maximumRecordBytes: { minimum: 22, maximum: 17 * 1024 * 1024 },
+    maximumResultBytes: { minimum: 32, maximum: 16 * 1024 * 1024 },
+  },
+} as const;
+
 const inputKeys = new Set([
   'folderPath',
   'databaseName',
@@ -46,9 +65,57 @@ const requestEnvelopeBytes = plugins.buffer.Buffer.byteLength(
   'utf8',
 );
 
+const physicalNamespaceInputKeys = new Set(['folderPath', 'limits']);
+const physicalNamespaceLimitKeys = [
+  'maximumEntries',
+  'maximumDatabases',
+  'maximumCollections',
+  'maximumIndexes',
+  'maximumDataFileBytes',
+  'maximumWalFileBytes',
+  'maximumIndexFileBytes',
+  'maximumTotalFileBytes',
+  'maximumRecordsPerCollection',
+  'maximumRecordBytes',
+  'maximumResultBytes',
+] as const;
+const physicalNamespaceLimitKeySet = new Set<string>(physicalNamespaceLimitKeys);
+
 const isRecord = (valueArg: unknown): valueArg is Record<string, unknown> =>
   typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
 
+const requirePhysicalNamespacePlainObject = (
+  valueArg: unknown,
+  allowedKeysArg: Set<string>,
+  labelArg: string,
+): Record<string, unknown> => {
+  if (!isRecord(valueArg)) {
+    throw new TypeError(
+      `LocalSmartDb offline physical namespace inspection ${labelArg} must be a plain object`,
+    );
+  }
+  for (const key in valueArg) {
+    if (!allowedKeysArg.has(key)) {
+      throw new TypeError(
+        `LocalSmartDb offline physical namespace inspection ${labelArg} contains unknown key '${key}'`,
+      );
+    }
+  }
+  if (Object.getPrototypeOf(valueArg) !== Object.prototype) {
+    throw new TypeError(
+      `LocalSmartDb 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(
+        `LocalSmartDb offline physical namespace inspection ${labelArg} must contain own enumerable key '${key}'`,
+      );
+    }
+  }
+  return valueArg;
+};
+
 const rejectUnknownEnumerableKeys = (
   valueArg: object,
   allowedKeysArg: Set<string>,
@@ -219,6 +286,81 @@ export const normalizeLocalSmartDbOfflineInspectionInput = (
   return normalized;
 };
 
+export const normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput = (
+  inputArg: ILocalSmartDbOfflinePhysicalNamespaceInspection,
+): ILocalSmartDbOfflinePhysicalNamespaceInspection => {
+  const inputRecord = requirePhysicalNamespacePlainObject(
+    inputArg,
+    physicalNamespaceInputKeys,
+    'input',
+  );
+  const limits = requirePhysicalNamespacePlainObject(
+    inputRecord.limits,
+    physicalNamespaceLimitKeySet,
+    'limits',
+  );
+  const normalized: ILocalSmartDbOfflinePhysicalNamespaceInspection = {
+    folderPath: inputRecord.folderPath as string,
+    limits: {
+      maximumEntries: limits.maximumEntries as number,
+      maximumDatabases: limits.maximumDatabases as number,
+      maximumCollections: limits.maximumCollections as number,
+      maximumIndexes: limits.maximumIndexes as number,
+      maximumDataFileBytes: limits.maximumDataFileBytes as number,
+      maximumWalFileBytes: limits.maximumWalFileBytes as number,
+      maximumIndexFileBytes: limits.maximumIndexFileBytes as number,
+      maximumTotalFileBytes: limits.maximumTotalFileBytes as number,
+      maximumRecordsPerCollection: limits.maximumRecordsPerCollection as number,
+      maximumRecordBytes: limits.maximumRecordBytes as number,
+      maximumResultBytes: limits.maximumResultBytes as number,
+    },
+  };
+  const bounds = localSmartDbOfflinePhysicalNamespaceInspectionBounds;
+  if (typeof normalized.folderPath !== 'string') {
+    throw new TypeError(
+      'LocalSmartDb 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(
+      `LocalSmartDb 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(
+        'LocalSmartDb 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(
+        `LocalSmartDb 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(
+      `LocalSmartDb offline physical namespace inspection request exceeds the ${bounds.maximumRequestBytes}-byte serialized limit`,
+    );
+  }
+  return normalized;
+};
+
 export const validateSmartDbManagementOperationOptions = (
   optionsArg?: ISmartDbManagementOperationOptions,
 ): void => {

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

@@ -7,6 +7,7 @@ import {
   normalizeSmartDbResourceFenceError,
 } from './service-types.js';
 import {
+  normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput,
   normalizeLocalSmartDbOfflineInspectionInput,
   validateSmartDbManagementOperationOptions,
 } from './offline-inspection.js';
@@ -36,6 +37,8 @@ import type {
   ISmartDbCommitDatabasePublicationInput,
   ISmartDbManagementOperationOptions,
   ISmartDbDatabaseResourceFenceState,
+  ILocalSmartDbOfflinePhysicalNamespaceInspection,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionResult,
   ILocalSmartDbOfflineStringValueInspection,
   TLocalSmartDbOfflineStringValueInspectionResult,
   TSmartDbCommitDatabasePublicationResult,
@@ -68,6 +71,9 @@ export type {
   ISmartDbManagementOperationOptions,
   ISmartDbDatabaseResourceFenceState,
   ILocalSmartDbOfflineInspectionLimits,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits,
+  ILocalSmartDbOfflinePhysicalNamespaceInspection,
+  ILocalSmartDbOfflinePhysicalNamespaceInspectionResult,
   ILocalSmartDbOfflineStringValueInspection,
   TLocalSmartDbOfflineStringValueInspectionResult,
   TSmartDbCommitDatabasePublicationResult,
@@ -169,7 +175,15 @@ export interface ISmartDbMetrics {
 /**
  * Type-safe command definitions for the RustDb IPC protocol.
  */
+type TOfflinePhysicalNamespaceInspectionCommandParams = {
+  folderPath: string;
+} & ILocalSmartDbOfflinePhysicalNamespaceInspection['limits'];
+
 type TSmartDbCommands = {
+  inspectOfflinePhysicalNamespaces: {
+    params: TOfflinePhysicalNamespaceInspectionCommandParams;
+    result: ILocalSmartDbOfflinePhysicalNamespaceInspectionResult;
+  };
   inspectOfflineStringValue: {
     params: ILocalSmartDbOfflineStringValueInspection;
     result: TLocalSmartDbOfflineStringValueInspectionResult;
@@ -543,6 +557,28 @@ export class RustDbBridge extends EventEmitter {
 
   // --- Convenience methods for each management command ---
 
+  public async inspectOfflinePhysicalNamespaces(
+    inputArg: ILocalSmartDbOfflinePhysicalNamespaceInspection,
+    optionsArg?: ISmartDbManagementOperationOptions,
+  ): Promise<ILocalSmartDbOfflinePhysicalNamespaceInspectionResult> {
+    const input = normalizeLocalSmartDbOfflinePhysicalNamespaceInspectionInput(inputArg);
+    validateSmartDbManagementOperationOptions(optionsArg);
+    const params: TOfflinePhysicalNamespaceInspectionCommandParams = {
+      folderPath: input.folderPath,
+      ...input.limits,
+    };
+    try {
+      return await this.bridge.sendCommand(
+        'inspectOfflinePhysicalNamespaces',
+        params,
+        optionsArg,
+      ) as ILocalSmartDbOfflinePhysicalNamespaceInspectionResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw error;
+    }
+  }
+
   public async inspectOfflineStringValue(
     inputArg: ILocalSmartDbOfflineStringValueInspection,
     optionsArg?: ISmartDbManagementOperationOptions,

package/ts/ts_smartdb/service-types.ts

@@ -45,6 +45,33 @@ export type TLocalSmartDbOfflineStringValueInspectionResult =
   | { status: 'not-found' }
   | { status: 'found'; value: string };
 
+export interface ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits {
+  maximumEntries: number;
+  maximumDatabases: number;
+  maximumCollections: number;
+  maximumIndexes: number;
+  maximumDataFileBytes: number;
+  maximumWalFileBytes: number;
+  maximumIndexFileBytes: number;
+  maximumTotalFileBytes: number;
+  maximumRecordsPerCollection: number;
+  maximumRecordBytes: number;
+  maximumResultBytes: number;
+}
+
+export interface ILocalSmartDbOfflinePhysicalNamespaceInspection {
+  folderPath: string;
+  limits: ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits;
+}
+
+export interface ILocalSmartDbOfflinePhysicalNamespaceInspectionResult {
+  schemaVersion: 1;
+  databases: Array<{
+    name: string;
+    collections: string[];
+  }>;
+}
+
 export const smartDbResourceFenceErrorCodes = [
   'EFENCE_REQUIRED',
   'EFENCE_STALE',