@lossless.org/nosqldb 10.10.0 → 11.0.0

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

@@ -9,6 +9,85 @@ import { normalizeNoSqlDbStorageRehearsalInput, } from './storage-rehearsal.js';
 import { normalizeNoSqlDbAllocationReadAccessGrantError, normalizeNoSqlDbResourceFenceError, } from './service-types.js';
 import { normalizeLocalNoSqlDbOfflinePhysicalNamespaceInspectionInput, normalizeLocalNoSqlDbOfflineInspectionInput, validateNoSqlDbManagementOperationOptions, } from './offline-inspection.js';
 import { normalizeLocalNoSqlDbStoppedStorageRootRelocationInput, } from './storage-root-relocation.js';
+/**
+ * Bounds of the engine standard-error tail that start failures, unexpected
+ * engine exits and failed management calls carry: the engine's last 64 lines.
+ * A longer line keeps its first 1,024 characters, followed by
+ * ` [<n> more characters]`.
+ */
+export const noSqlDbEngineStderrTailLimits = Object.freeze({ lines: 64, lineCharacters: 1024 });
+/**
+ * Attach the engine's last standard-error lines to an error as its own field
+ * `engineStderrTail`, leaving its message and cause unchanged. Values that
+ * cannot carry a field (primitives, frozen objects) are left as they are.
+ */
+export function attachNoSqlDbEngineStderrTail(errorArg, tailArg) {
+    if (errorArg === null || (typeof errorArg !== 'object' && typeof errorArg !== 'function'))
+        return;
+    if (!Object.isExtensible(errorArg) && !Object.prototype.hasOwnProperty.call(errorArg, 'engineStderrTail'))
+        return;
+    try {
+        Object.defineProperty(errorArg, 'engineStderrTail', {
+            value: Object.freeze([...tailArg]),
+            enumerable: true,
+            configurable: true,
+            writable: false,
+        });
+    }
+    catch {
+        // A non-configurable field of the same name stays as the caller made it.
+    }
+}
+/**
+ * The engine process exited with a non-zero status or by a signal while its
+ * server was running and no stop was in progress. `engineStderrTail` holds
+ * its last standard-error lines.
+ */
+export class NoSqlDbEngineExitError extends Error {
+    constructor(exitCode, signal, engineStderrTailArg) {
+        super(`nosqldb Rust process exited unexpectedly (code=${exitCode}, signal=${signal})`);
+        this.exitCode = exitCode;
+        this.signal = signal;
+        this.name = 'NoSqlDbEngineExitError';
+        this.engineStderrTail = Object.freeze([...engineStderrTailArg]);
+    }
+}
+/**
+ * A start that the engine refused because the storage root, or a feature it
+ * carries, comes from a later NoSQLDB release than this one: the engine's
+ * management reply carried the code `UNKNOWN_ROOT`. The engine wrote nothing
+ * into the root (storage-root-names-and-start.md, "Roots of later releases";
+ * requirements A300 and A319). `code` holds the code, and `cause` the
+ * management error that carried it.
+ */
+export class NoSqlDbUnknownRootError extends Error {
+    constructor(options) {
+        super('NoSQLDB refuses this storage root: the root, or a feature it carries, comes from a later NoSQLDB release than this one', options);
+        this.code = 'UNKNOWN_ROOT';
+        this.responseErrorCode = 'UNKNOWN_ROOT';
+        this.name = 'NoSqlDbUnknownRootError';
+    }
+}
+/** The bounded record of one engine process's last standard-error lines. */
+class EngineStderrTail {
+    constructor() {
+        this.lines = [];
+    }
+    add(lineArg) {
+        const limit = noSqlDbEngineStderrTailLimits.lineCharacters;
+        this.lines.push(lineArg.length > limit
+            ? `${lineArg.slice(0, limit)} [${lineArg.length - limit} more characters]`
+            : lineArg);
+        if (this.lines.length > noSqlDbEngineStderrTailLimits.lines)
+            this.lines.shift();
+    }
+    clear() {
+        this.lines = [];
+    }
+    snapshot() {
+        return [...this.lines];
+    }
+}
 export class NoSqlDbManagementOperationTerminationError extends AggregateError {
     constructor(operationErrorArg, terminationErrorArg) {
         super([operationErrorArg, terminationErrorArg], 'NoSQLDB management operation failed and Rust engine termination was incomplete', { cause: operationErrorArg });
@@ -28,8 +107,8 @@ function getPackageRoot() {
     return path.resolve(thisDir, '..', '..');
 }
 /**
- * Map Node.js process.platform/process.arch to tsrust's friendly name suffix.
- * tsrust names cross-compiled binaries as: rustdb_linux_amd64, rustdb_linux_arm64, etc.
+ * Map Node.js process.platform/process.arch to rsrepo's friendly name suffix.
+ * rsrepo names cross-compiled binaries as: rustdb_linux_amd64, rustdb_linux_arm64, etc.
  */
 function getTsrustPlatformSuffix() {
     const archMap = { x64: 'amd64', arm64: 'arm64' };
@@ -44,13 +123,13 @@ function getTsrustPlatformSuffix() {
 }
 /**
  * Build local search paths for the Rust binary, including dist_rust/ candidates
- * (built by tsrust) and local development build paths.
+ * (built by rsrepo) and local development build paths.
  */
 function buildLocalPaths() {
     const packageRoot = getPackageRoot();
     const suffix = getTsrustPlatformSuffix();
     const paths = [];
-    // dist_rust/ candidates (tsrust cross-compiled output)
+    // dist_rust/ candidates (rsrepo cross-compiled output)
     if (suffix) {
         paths.push(path.join(packageRoot, 'dist_rust', `rustdb_${suffix}`));
     }
@@ -60,11 +139,23 @@ function buildLocalPaths() {
     paths.push(path.resolve(process.cwd(), 'rust', 'target', 'debug', 'rustdb'));
     return paths;
 }
-export function getRustDbAllocatorEnv(environment = process.env) {
-    return {
-        MIMALLOC_ARENA_EAGER_COMMIT: environment.MIMALLOC_ARENA_EAGER_COMMIT ?? '0',
-        MIMALLOC_ALLOW_LARGE_OS_PAGES: environment.MIMALLOC_ALLOW_LARGE_OS_PAGES ?? '0',
-    };
+const binaryHelp = 'Set NOSQLDB_RUST_BINARY env var, install the platform package, or build locally with `rsrepo`.';
+/**
+ * What a spawn() that returned false after `waitedMs` means, stating only what
+ * is known. Smartrust refuses a `binaryPath` that does not pass its validation
+ * before spawn() can return false, so with one the engine there passed
+ * Smartrust's validation and did not report ready within the bridge's limit,
+ * and its path is given as the caller gave it.
+ * Without one, whatever NOSQLDB_RUST_BINARY holds (one of the places that
+ * Smartrust's search looks), either the search found no engine or the engine
+ * it found did not report ready, and nothing tells which.
+ */
+export function describeRefusedSpawn(binaryPath, waitedMs) {
+    if (binaryPath !== undefined) {
+        return `the nosqldb engine at ${binaryPath} did not report ready within the bridge's limit: it waited ${waitedMs} ms`;
+    }
+    return `the nosqldb engine did not start: spawn() returned false after ${waitedMs} ms, which means either that no nosqldb Rust binary `
+        + `was found (${binaryHelp}) or that the engine found did not report ready within the bridge's limit`;
 }
 /**
  * Bridge between TypeScript NoSqlDbServer and the Rust binary.
@@ -77,12 +168,89 @@ export class RustDbBridge extends EventEmitter {
      * termination, or when the bridge is connected to an external process.
      */
     get processId() {
+        return this.childProcess?.pid;
+    }
+    /** The engine child process of the latest spawn, while the bridge holds it. */
+    get childProcess() {
         const transport = this.bridge.transport;
-        return transport?.childProcess?.pid;
+        return transport?.childProcess ?? undefined;
+    }
+    /** Records the exit of the engine process that a spawn has just started. */
+    watchEngineExit() {
+        const child = this.childProcess;
+        if (!child)
+            return;
+        this.engineExitPromise = new Promise((resolveArg) => {
+            const record = (code, signal) => {
+                this.engineExit = { code, signal };
+                resolveArg();
+            };
+            if (child.exitCode !== null || child.signalCode !== null)
+                record(child.exitCode, child.signalCode);
+            else
+                child.once('exit', record);
+        });
+    }
+    /**
+     * The exit code and signal of the engine process of the latest spawn, as its
+     * process exit reported them, each null where it reported none; or null
+     * while that process has not exited, or no spawn started one.
+     */
+    get lastEngineExit() {
+        return this.engineExit;
+    }
+    /** Whether the engine process of the latest spawn exists and has not exited. */
+    get engineProcessAlive() {
+        return this.engineExitPromise !== undefined && this.engineExit === null;
+    }
+    /** Waits up to `timeoutMs` for the engine process to exit by itself; resolves whether it has. */
+    async waitForEngineExit(timeoutMs) {
+        if (!this.engineExitPromise)
+            return false;
+        let timer;
+        await Promise.race([
+            this.engineExitPromise,
+            new Promise((resolveArg) => { timer = setTimeout(resolveArg, timeoutMs); }),
+        ]);
+        if (timer)
+            clearTimeout(timer);
+        return this.engineExit !== null;
+    }
+    /**
+     * Closes the engine's management input, the end of the management protocol
+     * after an acknowledged `stop`, on which the engine exits by itself. This is
+     * neither a signal nor a kill. Returns whether there was an input to close.
+     */
+    endManagementInput() {
+        const input = this.childProcess?.stdin;
+        if (!input || input.writableEnded)
+            return false;
+        input.end();
+        return true;
+    }
+    /**
+     * Why Smartrust's spawn() returned false, as far as the bridge knows. Each
+     * spawn() clears it as it starts, and sets it when Smartrust's spawn()
+     * returns false before this spawn()'s own `timeoutMs` or `signal` cuts it
+     * short, before the engine is ended. That spawn() then returns false, or
+     * throws if ending the engine fails. After any other spawn() it is
+     * undefined, including one cut short by its own `timeoutMs` or `signal`.
+     * Smartrust's spawn() returns false both when it finds no engine and when
+     * the engine it starts does not report ready within its limit; a
+     * `binaryPath` tells the two apart, as Smartrust refuses one that does not
+     * pass its validation with RustBinaryLocatorError before spawn() can return
+     * false.
+     */
+    get spawnFailureMessage() {
+        return this.spawnRefusal;
     }
     constructor(options = {}) {
         super();
+        /** How the engine process of the latest spawn exited, once it has. */
+        this.engineExit = null;
         this.terminationConfirmed = true;
+        this.stderrTail = new EngineStderrTail();
+        this.binaryPath = options.binaryPath;
         this.bridge = new plugins.smartrust.RustBridge({
             binaryName: 'rustdb',
             binaryPath: options.binaryPath,
@@ -90,7 +258,14 @@ export class RustDbBridge extends EventEmitter {
             platformPackagePrefix: '@lossless.org/nosqldb',
             localPaths: buildLocalPaths(),
             maxPayloadSize: 100 * 1024 * 1024, // database exports/imports can be larger than command replies
-            env: getRustDbAllocatorEnv(),
+        });
+        // Smartrust delivers the engine's standard error one line at a time.
+        const engineLog = options.engineLog;
+        this.bridge.on('stderr', (line) => {
+            this.stderrTail.add(line);
+            // Microtasks run in order, so the lines keep their order.
+            if (engineLog)
+                queueMicrotask(() => engineLog(line));
         });
         // Forward events from the inner bridge
         this.bridge.on('exit', (code, signal) => {
@@ -98,11 +273,39 @@ export class RustDbBridge extends EventEmitter {
             this.emit('exit', code, signal);
         });
     }
+    /**
+     * The last standard-error lines of the running or most recently spawned
+     * engine process, within `noSqlDbEngineStderrTailLimits`.
+     */
+    get engineStderrTail() {
+        return this.stderrTail.snapshot();
+    }
+    /**
+     * Send one management command. A failure while no engine runs (it exited
+     * or never started) carries the engine's last standard-error lines.
+     */
+    async send(methodArg, paramsArg, optionsArg) {
+        try {
+            return await this.bridge.sendCommand(methodArg, paramsArg, optionsArg);
+        }
+        catch (error) {
+            if (!this.bridge.running)
+                attachNoSqlDbEngineStderrTail(error, this.stderrTail.snapshot());
+            throw error;
+        }
+    }
     /**
      * Spawn the Rust binary in management mode.
-     * Returns true if the binary was found and spawned successfully.
+     * Returns true once the engine reported ready. Returns false when
+     * Smartrust's spawn() returned false: no engine was found, or the one found
+     * did not report ready within the bridge's limit. spawnFailureMessage then
+     * says what that means, as far as the bridge knows, and still says it if
+     * ending that engine fails and this throws instead. After any other
+     * outcome, including a throw on this spawn()'s own `timeoutMs` or `signal`,
+     * spawnFailureMessage is undefined.
      */
     async spawn(optionsArg) {
+        this.spawnRefusal = undefined;
         validateNoSqlDbManagementOperationOptions(optionsArg);
         if (optionsArg?.signal?.aborted) {
             throw new plugins.smartrust.RustBridgeRequestError('NoSQLDB Rust sidecar spawn was aborted before it started', {
@@ -113,6 +316,11 @@ export class RustDbBridge extends EventEmitter {
         }
         this.terminationConfirmed = false;
         this.terminationFailure = undefined;
+        this.stderrTail.clear();
+        const spawnStartedAt = performance.now();
+        // The previous engine's exit belongs to it, also when this spawn fails.
+        this.engineExit = null;
+        this.engineExitPromise = undefined;
         const spawnPromise = this.bridge.spawn();
         let timeout;
         let abortHandler;
@@ -138,7 +346,10 @@ export class RustDbBridge extends EventEmitter {
         });
         try {
             const spawned = await Promise.race([spawnPromise, cancellationPromise]);
+            if (spawned)
+                this.watchEngineExit();
             if (!spawned) {
+                this.spawnRefusal = describeRefusedSpawn(this.binaryPath, Math.round(performance.now() - spawnStartedAt));
                 await this.terminate({ gracePeriodMs: 0 });
             }
             return spawned;
@@ -229,7 +440,7 @@ export class RustDbBridge extends EventEmitter {
         const request = normalizeNoSqlDbStorageRehearsalInput(inputArg);
         validateNoSqlDbManagementOperationOptions(optionsArg);
         try {
-            return await this.bridge.sendCommand('createStoppedStorageRehearsal', { request, timeoutMs: optionsArg.timeoutMs }, optionsArg);
+            return await this.send('createStoppedStorageRehearsal', { request, timeoutMs: optionsArg.timeoutMs }, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -240,7 +451,7 @@ export class RustDbBridge extends EventEmitter {
         const input = normalizeLocalNoSqlDbStoppedStorageRootRelocationInput(inputArg);
         validateNoSqlDbManagementOperationOptions(optionsArg);
         try {
-            return await this.bridge.sendCommand('relocateStoppedStorageRoot', { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+            return await this.send('relocateStoppedStorageRoot', { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -257,7 +468,7 @@ export class RustDbBridge extends EventEmitter {
         const input = normalizeStoppedStorageRootAlignmentInput(inputArg);
         validateNoSqlDbManagementOperationOptions(optionsArg);
         try {
-            return await this.bridge.sendCommand(method, { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+            return await this.send(method, { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -268,7 +479,7 @@ export class RustDbBridge extends EventEmitter {
         const input = normalizeStoppedStorageRootInspectionInput(inputArg);
         validateNoSqlDbManagementOperationOptions(optionsArg);
         try {
-            return await this.bridge.sendCommand('inspectStoppedStorageRoot', { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+            return await this.send('inspectStoppedStorageRoot', { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -284,7 +495,7 @@ export class RustDbBridge extends EventEmitter {
             timeoutMs: optionsArg?.timeoutMs,
         };
         try {
-            return await this.bridge.sendCommand('inspectOfflinePhysicalNamespaces', params, optionsArg);
+            return await this.send('inspectOfflinePhysicalNamespaces', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -295,7 +506,7 @@ export class RustDbBridge extends EventEmitter {
         const input = normalizeLocalNoSqlDbOfflineInspectionInput(inputArg);
         validateNoSqlDbManagementOperationOptions(optionsArg);
         try {
-            return await this.bridge.sendCommand('inspectOfflineStringValue', { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+            return await this.send('inspectOfflineStringValue', { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -306,25 +517,29 @@ export class RustDbBridge extends EventEmitter {
         normalizeNoSqlDbFileStorageOptions(config);
         validateNoSqlDbManagementOperationOptions(optionsArg);
         try {
-            return await this.bridge.sendCommand('start', { config, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+            return await this.send('start', { config, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
+            // The unknown-root refusal is told apart by its code, never by its message.
+            if (error instanceof Error && 'responseErrorCode' in error && error.responseErrorCode === 'UNKNOWN_ROOT') {
+                throw new NoSqlDbUnknownRootError({ cause: error });
+            }
             throw error;
         }
     }
     async stopDb() {
-        await this.bridge.sendCommand('stop', {});
+        await this.send('stop', {});
     }
     async getStatus() {
-        return await this.bridge.sendCommand('getStatus', {});
+        return await this.send('getStatus', {});
     }
     async getMetrics() {
-        return this.bridge.sendCommand('getMetrics', {});
+        return this.send('getMetrics', {});
     }
     async getHealth(optionsArg) {
         try {
-            return await this.bridge.sendCommand('getHealth', {}, optionsArg);
+            return await this.send('getHealth', {}, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -333,7 +548,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async createDatabaseTenant(params) {
         try {
-            return await this.bridge.sendCommand('createDatabaseTenant', params);
+            return await this.send('createDatabaseTenant', params);
         }
         catch (error) {
             throw normalizeNoSqlDbResourceFenceError(error);
@@ -341,7 +556,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async ensureDatabaseTenant(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('ensureDatabaseTenant', params, optionsArg);
+            return await this.send('ensureDatabaseTenant', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -350,7 +565,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async attestDatabaseTenant(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('attestDatabaseTenant', params, optionsArg);
+            return await this.send('attestDatabaseTenant', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -359,7 +574,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async allocateDatabaseTenant(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('allocateDatabaseTenant', params, optionsArg);
+            return await this.send('allocateDatabaseTenant', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -368,7 +583,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async deleteDatabaseTenant(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('deleteDatabaseTenant', params, optionsArg);
+            return await this.send('deleteDatabaseTenant', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -377,7 +592,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async issueDatabaseAllocationReadAccessGrant(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('issueDatabaseAllocationReadAccessGrant', params, optionsArg);
+            return await this.send('issueDatabaseAllocationReadAccessGrant', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -388,7 +603,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async revokeDatabaseAllocationReadAccessGrant(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('revokeDatabaseAllocationReadAccessGrant', params, optionsArg);
+            return await this.send('revokeDatabaseAllocationReadAccessGrant', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -398,18 +613,18 @@ export class RustDbBridge extends EventEmitter {
         }
     }
     async rotateDatabaseTenantPassword(params) {
-        return this.bridge.sendCommand('rotateDatabaseTenantPassword', params);
+        return this.send('rotateDatabaseTenantPassword', params);
     }
     async listDatabaseTenants() {
-        const result = await this.bridge.sendCommand('listDatabaseTenants', {});
+        const result = await this.send('listDatabaseTenants', {});
         return result.tenants;
     }
     async getDatabaseTenantDescriptor(params) {
-        return this.bridge.sendCommand('getDatabaseTenantDescriptor', params);
+        return this.send('getDatabaseTenantDescriptor', params);
     }
     async getDatabaseResourceFenceState(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('getDatabaseResourceFenceState', params, optionsArg);
+            return await this.send('getDatabaseResourceFenceState', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -418,7 +633,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async exportDatabase(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('exportDatabase', params, optionsArg);
+            return await this.send('exportDatabase', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -427,7 +642,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async exportHeldDatabase(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('exportHeldDatabase', params, optionsArg);
+            return await this.send('exportHeldDatabase', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -436,7 +651,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async getDatabaseContentDigest(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('getDatabaseContentDigest', params, optionsArg);
+            return await this.send('getDatabaseContentDigest', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -445,7 +660,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async importDatabase(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('importDatabase', { ...params, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+            return await this.send('importDatabase', { ...params, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -454,7 +669,7 @@ export class RustDbBridge extends EventEmitter {
     }
     async commitDatabasePublication(params, optionsArg) {
         try {
-            return await this.bridge.sendCommand('commitDatabasePublication', params, optionsArg);
+            return await this.send('commitDatabasePublication', params, optionsArg);
         }
         catch (error) {
             await this.awaitManagementOperationTermination(error);
@@ -462,23 +677,23 @@ export class RustDbBridge extends EventEmitter {
         }
     }
     async getOpLog(params = {}) {
-        return this.bridge.sendCommand('getOpLog', params);
+        return this.send('getOpLog', params);
     }
     async getCommittedWrites(params) {
-        return this.bridge.sendCommand('getCommittedWrites', params);
+        return this.send('getCommittedWrites', params);
     }
     async getOpLogStats() {
-        return this.bridge.sendCommand('getOpLogStats', {});
+        return this.send('getOpLogStats', {});
     }
     async revertToSeq(seq, dryRun = false) {
-        return this.bridge.sendCommand('revertToSeq', { seq, dryRun });
+        return this.send('revertToSeq', { seq, dryRun });
     }
     async getCollections(db) {
-        const result = await this.bridge.sendCommand('getCollections', db ? { db } : {});
+        const result = await this.send('getCollections', db ? { db } : {});
         return result.collections;
     }
     async getDocuments(db, collection, limit = 50, skip = 0) {
-        return this.bridge.sendCommand('getDocuments', { db, collection, limit, skip });
+        return this.send('getDocuments', { db, collection, limit, skip });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-db-bridge.js","sourceRoot":"","sources":["../../ts/ts_nosqldb/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_nosqldb/rust-db-bridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yCAAyC,EAAqK,MAAM,6BAA6B,CAAC;AAC3P,OAAO,EAAE,0CAA0C,EAAE,sCAAsC,EAAuG,MAAM,sBAAsB,CAAC;AAC/N,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAExC,OAAO,EAAE,kCAAkC,EAAE,MAAM,2BAA2B,CAAC;AAE/E,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EACL,qCAAqC,GAItC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,8CAA8C,EAC9C,kCAAkC,GACnC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,4DAA4D,EAC5D,2CAA2C,EAC3C,yCAAyC,GAC1C,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,sDAAsD,GAGvD,MAAM,8BAA8B,CAAC;AAyItC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC,CAAC;AAEhG;;;;GAIG;AACH,MAAM,UAAU,6BAA6B,CAAC,QAAiB,EAAE,OAA0B;IACzF,IAAI,QAAQ,KAAK,IAAI,IAAI,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK,UAAU,CAAC;QAAE,OAAO;IAClG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,kBAAkB,CAAC;QAAE,OAAO;IAClH,IAAI,CAAC;QACH,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,kBAAkB,EAAE;YAClD,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;YAClC,UAAU,EAAE,IAAI;YAChB,YAAY,EAAE,IAAI;YAClB,QAAQ,EAAE,KAAK;SAChB,CAAC,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;IAC3E,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAG/C,YACkB,QAAuB,EACvB,MAAqB,EACrC,mBAAsC;QAEtC,KAAK,CAAC,kDAAkD,QAAQ,YAAY,MAAM,GAAG,CAAC,CAAC;wBAJvE,QAAQ;sBACR,MAAM;QAItB,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;QACrC,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC;IAClE,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IAIhD,YAAY,OAA6B;QACvC,KAAK,CAAC,wHAAwH,EAAE,OAAO,CAAC,CAAC;QAJ3H,SAAI,GAAG,cAAuB,CAAC;QAC/B,sBAAiB,GAAG,cAAuB,CAAC;QAI1D,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF;AAED,4EAA4E;AAC5E,MAAM,gBAAgB;IAAtB;QACU,UAAK,GAAa,EAAE,CAAC;IAiB/B,CAAC;IAfQ,GAAG,CAAC,OAAe;QACxB,MAAM,KAAK,GAAG,6BAA6B,CAAC,cAAc,CAAC;QAC3D,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,KAAK;YACpC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,OAAO,CAAC,MAAM,GAAG,KAAK,mBAAmB;YAC1E,CAAC,CAAC,OAAO,CAAC,CAAC;QACb,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,6BAA6B,CAAC,KAAK;YAAE,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IAClF,CAAC;IAEM,KAAK;QACV,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;IAClB,CAAC;IAEM,QAAQ;QACb,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;CACF;AAED,MAAM,OAAO,0CAA2C,SAAQ,cAAc;IAC5E,YAAY,iBAA0B,EAAE,mBAA4B;QAClE,KAAK,CACH,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,EACxC,gFAAgF,EAChF,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAC7B,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,4CAA4C,CAAC;IAC3D,CAAC;CACF;AA4BD,MAAM,CAAC,MAAM,gCAAgC,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAC/E,MAAM,CAAC,MAAM,qCAAqC,GAAG,MAAM,CAAC,2BAA2B,CAAC,CAAC;AAqHzF,MAAM,CAAC,MAAM,iCAAiC,GAAG,MAAM,CACrD,0CAA0C,CAC3C,CAAC;AACF,MAAM,CAAC,MAAM,4BAA4B,GAAG,MAAM,CAAC,oCAAoC,CAAC,CAAC;AAmEzF;;;GAGG;AACH,SAAS,cAAc;IACrB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACjE,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC;AAED;;;GAGG;AACH,SAAS,uBAAuB;IAC9B,MAAM,OAAO,GAA2B,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IACzE,MAAM,KAAK,GAA2B,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IAC1E,MAAM,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACnC,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;QACf,6EAA6E;QAC7E,OAAO,GAAG,EAAE,IAAI,IAAI,GAAG,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IACzD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,SAAS,eAAe;IACtB,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IACrC,MAAM,MAAM,GAAG,uBAAuB,EAAE,CAAC;IACzC,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,uDAAuD;IACvD,IAAI,MAAM,EAAE,CAAC;QACX,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,MAAM,EAAE,CAAC,CAAC,CAAC;IACtE,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;IAE1D,wBAAwB;IACxB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC/E,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;IAE7E,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,GAAG,gGAAgG,CAAC;AAEpH;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAAC,UAA8B,EAAE,QAAgB;IACnF,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,yBAAyB,UAAU,8DAA8D,QAAQ,KAAK,CAAC;IACxH,CAAC;IACD,OAAO,kEAAkE,QAAQ,sDAAsD;UACnI,cAAc,UAAU,2EAA2E,CAAC;AAC1G,CAAC;AAiBD;;;GAGG;AACH,MAAM,OAAO,YAAa,SAAQ,YAAY;IAG5C;;;;OAIG;IACH,IAAW,SAAS;QAClB,OAAO,IAAI,CAAC,YAAY,EAAE,GAAG,CAAC;IAChC,CAAC;IAED,+EAA+E;IAC/E,IAAY,YAAY;QACtB,MAAM,SAAS,GAAI,IAAI,CAAC,MAEtB,CAAC,SAAS,CAAC;QACb,OAAO,SAAS,EAAE,YAAY,IAAI,SAAS,CAAC;IAC9C,CAAC;IAMD,4EAA4E;IACpE,eAAe;QACrB,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC;QAChC,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,IAAI,CAAC,iBAAiB,GAAG,IAAI,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE;YAClD,MAAM,MAAM,GAAG,CAAC,IAAmB,EAAE,MAAqB,EAAE,EAAE;gBAC5D,IAAI,CAAC,UAAU,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;gBACnC,UAAU,EAAE,CAAC;YACf,CAAC,CAAC;YACF,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI,IAAI,KAAK,CAAC,UAAU,KAAK,IAAI;gBAAE,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;;gBAC9F,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,IAAW,cAAc;QACvB,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,gFAAgF;IAChF,IAAW,kBAAkB;QAC3B,OAAO,IAAI,CAAC,iBAAiB,KAAK,SAAS,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,CAAC;IAC1E,CAAC;IAED,iGAAiG;IAC1F,KAAK,CAAC,iBAAiB,CAAC,SAAiB;QAC9C,IAAI,CAAC,IAAI,CAAC,iBAAiB;YAAE,OAAO,KAAK,CAAC;QAC1C,IAAI,KAAgD,CAAC;QACrD,MAAM,OAAO,CAAC,IAAI,CAAC;YACjB,IAAI,CAAC,iBAAiB;YACtB,IAAI,OAAO,CAAO,CAAC,UAAU,EAAE,EAAE,GAAG,KAAK,GAAG,UAAU,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;SAClF,CAAC,CAAC;QACH,IAAI,KAAK;YAAE,YAAY,CAAC,KAAK,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC,UAAU,KAAK,IAAI,CAAC;IAClC,CAAC;IAED;;;;OAIG;IACI,kBAAkB;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC;QACvC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,aAAa;YAAE,OAAO,KAAK,CAAC;QAChD,KAAK,CAAC,GAAG,EAAE,CAAC;QACZ,OAAO,IAAI,CAAC;IACd,CAAC;IASD;;;;;;;;;;;;OAYG;IACH,IAAW,mBAAmB;QAC5B,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,YAAY,OAAO,GAAyB,EAAE;QAC5C,KAAK,EAAE,CAAC;QAjFV,sEAAsE;QAC9D,eAAU,GAA0D,IAAI,CAAC;QAsDzE,yBAAoB,GAAG,IAAI,CAAC;QAGnB,eAAU,GAAG,IAAI,gBAAgB,EAAE,CAAC;QAwBnD,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;QAErC,IAAI,CAAC,MAAM,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,UAAU,CAAmB;YAC/D,UAAU,EAAE,QAAQ;YACpB,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,UAAU,EAAE,qBAAqB;YACjC,qBAAqB,EAAE,uBAAuB;YAC9C,UAAU,EAAE,eAAe,EAAE;YAC7B,cAAc,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI,EAAE,8DAA8D;SAClG,CAAC,CAAC;QAEH,qEAAqE;QACrE,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACpC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAY,EAAE,EAAE;YACxC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAC1B,0DAA0D;YAC1D,IAAI,SAAS;gBAAE,cAAc,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;QAEH,uCAAuC;QACvC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAmB,EAAE,MAAqB,EAAE,EAAE;YACpE,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;YACjC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,IAAW,gBAAgB;QACzB,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IACpC,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,IAAI,CAChB,SAAkB,EAClB,SAA8C,EAC9C,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QACzE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO;gBAAE,6BAA6B,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;YAC3F,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACI,KAAK,CAAC,KAAK,CAAC,UAA+C;QAChE,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAC9B,yCAAyC,CAAC,UAAU,CAAC,CAAC;QACtD,IAAI,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;YAChC,MAAM,IAAI,OAAO,CAAC,SAAS,CAAC,sBAAsB,CAChD,0DAA0D,EAC1D;gBACE,IAAI,EAAE,iCAAiC;gBACvC,MAAM,EAAE,OAAO;gBACf,KAAK,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM;aAChC,CACF,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC;QAClC,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;QACpC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QACxB,MAAM,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QACzC,wEAAwE;QACxE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,iBAAiB,GAAG,SAAS,CAAC;QACnC,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACzC,IAAI,OAAkD,CAAC;QACvD,IAAI,YAAsC,CAAC;QAC3C,MAAM,mBAAmB,GAAG,IAAI,OAAO,CAAQ,CAAC,WAAW,EAAE,SAAS,EAAE,EAAE;YACxE,IAAI,UAAU,EAAE,SAAS,KAAK,SAAS,EAAE,CAAC;gBACxC,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;oBACxB,SAAS,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,sBAAsB,CACpD,8CAA8C,UAAU,CAAC,SAAS,IAAI,EACtE;wBACE,IAAI,EAAE,iCAAiC;wBACvC,MAAM,EAAE,OAAO;qBAChB,CACF,CAAC,CAAC;gBACL,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;YAC3B,CAAC;YACD,IAAI,UAAU,EAAE,MAAM,EAAE,CAAC;gBACvB,YAAY,GAAG,GAAG,EAAE;oBAClB,SAAS,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,sBAAsB,CACpD,wCAAwC,EACxC;wBACE,IAAI,EAAE,iCAAiC;wBACvC,MAAM,EAAE,OAAO;wBACf,KAAK,EAAE,UAAU,CAAC,MAAO,CAAC,MAAM;qBACjC,CACF,CAAC,CAAC;gBACL,CAAC,CAAC;gBACF,UAAU,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YAC5E,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,mBAAmB,CAAC,CAAC,CAAC;YACxE,IAAI,OAAO;gBAAE,IAAI,CAAC,eAAe,EAAE,CAAC;YACpC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,IAAI,CAAC,YAAY,GAAG,oBAAoB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC;gBAC1G,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,CAAC;YAC7C,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,CAAC;YAC7C,CAAC;YAAC,OAAO,gBAAgB,EAAE,CAAC;gBAC1B,MAAM,IAAI,0CAA0C,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;YAChF,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,IAAI,OAAO;gBAAE,YAAY,CAAC,OAAO,CAAC,CAAC;YACnC,IAAI,YAAY,IAAI,UAAU,EAAE,MAAM,EAAE,CAAC;gBACvC,UAAU,CAAC,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;YAC/D,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACI,IAAI;QACT,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IAED;;OAEG;IACI,SAAS,CACd,UAA0D;QAE1D,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,kBAAkB,CAAC;QACjC,CAAC;QAED,MAAM,kBAAkB,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,IAAI,CAC/D,GAAG,EAAE;YACH,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;YACjC,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;QACtC,CAAC,EACD,CAAC,QAAiB,EAAE,EAAE;YACpB,IAAI,CAAC,kBAAkB,GAAG,QAAQ,CAAC;YACnC,MAAM,QAAQ,CAAC;QACjB,CAAC,CACF,CAAC;QACF,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;QAC7C,KAAK,kBAAkB,CAAC,IAAI,CAC1B,GAAG,EAAE;YACH,IAAI,IAAI,CAAC,kBAAkB,KAAK,kBAAkB,EAAE,CAAC;gBACnD,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;YACtC,CAAC;QACH,CAAC,EACD,GAAG,EAAE;YACH,IAAI,IAAI,CAAC,kBAAkB,KAAK,kBAAkB,EAAE,CAAC;gBACnD,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;YACtC,CAAC;QACH,CAAC,CACF,CAAC;QACF,OAAO,kBAAkB,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IAC7B,CAAC;IAED,IAAW,iBAAiB;QAC1B,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACnC,CAAC;IAEO,KAAK,CAAC,mCAAmC,CAAC,QAAiB;QACjE,MAAM,+BAA+B,GACnC,QAAQ,YAAY,OAAO,CAAC,SAAS,CAAC,sBAAsB;eACzD;gBACD,iCAAiC;gBACjC,iCAAiC;aAClC,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC;QACjD,IAAI,+BAA+B,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC3D,kBAAkB,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,CAAC;QAC5D,CAAC;QAED,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,oBAAoB,IAAI,IAAI,CAAC,kBAAkB,KAAK,SAAS,EAAE,CAAC;gBACxE,MAAM,IAAI,0CAA0C,CAClD,QAAQ,EACR,IAAI,CAAC,kBAAkB,CACxB,CAAC;YACJ,CAAC;YACD,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,MAAM,kBAAkB,CAAC;QAC3B,CAAC;QAAC,OAAO,gBAAgB,EAAE,CAAC;YAC1B,MAAM,IAAI,0CAA0C,CAClD,QAAQ,EACR,gBAAgB,CACjB,CAAC;QACJ,CAAC;IACH,CAAC;IAED,0DAA0D;IAEnD,KAAK,CAAC,CAAC,4BAA4B,CAAC,CAAC,QAAuC,EACjF,UAAsE;QACtE,MAAM,OAAO,GAAG,qCAAqC,CAAC,QAAQ,CAAC,CAAC;QAChE,yCAAyC,CAAC,UAAU,CAAC,CAAC;QACtD,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CAAC,+BAA+B,EACpD,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,CAAC,SAAS,EAAE,EAAE,UAAU,CAAoC,CAAC;QACjG,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,sCAAsC,CAAC,KAAK,EAAE,+BAA+B,CAAC,CAAC;QACvF,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,CAAC,iCAAiC,CAAC,CAC9C,QAAwD,EACxD,UAA+C;QAE/C,MAAM,KAAK,GAAG,sDAAsD,CAAC,QAAQ,CAAC,CAAC;QAC/E,yCAAyC,CAAC,UAAU,CAAC,CAAC;QACtD,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,4BAA4B,EAC5B,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,EAC9C,UAAU,CACyC,CAAC;QACxD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,sCAAsC,CAAC,KAAK,EAAE,4BAA4B,CAAC,CAAC;QACpF,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,CAAC,gCAAgC,CAAC,CAAC,QAAuD,EACrG,UAA+C;QAC/C,OAAO,IAAI,CAAC,uBAAuB,CAAC,yBAAyB,EAAE,QAAQ,EAAE,UAAU,CAA4D,CAAC;IAClJ,CAAC;IACM,KAAK,CAAC,CAAC,qCAAqC,CAAC,CAAC,QAAuD,EAC1G,UAA+C;QAC/C,OAAO,IAAI,CAAC,uBAAuB,CAAC,kCAAkC,EAAE,QAAQ,EAAE,UAAU,CAAiE,CAAC;IAChK,CAAC;IACO,KAAK,CAAC,uBAAuB,CAAC,MAAsE,EAC1G,QAAuD,EAAE,UAA+C;QACxG,MAAM,KAAK,GAAG,yCAAyC,CAAC,QAAQ,CAAC,CAAC;QAClE,yCAAyC,CAAC,UAAU,CAAC,CAAC;QACtD,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE,UAAU,CAAC,CAAC;QAC7F,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,sCAAsC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,yBAAyB,CACpC,QAAwD,EACxD,UAA+C;QAE/C,MAAM,KAAK,GAAG,0CAA0C,CAAC,QAAQ,CAAC,CAAC;QACnE,yCAAyC,CAAC,UAAU,CAAC,CAAC;QACtD,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CAAC,2BAA2B,EAChD,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE,UAAU,CAA8C,CAAC;QAC7G,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,sCAAsC,CAAC,KAAK,EAAE,2BAA2B,CAAC,CAAC;QACnF,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,gCAAgC,CAC3C,QAAyD,EACzD,UAA+C;QAE/C,MAAM,KAAK,GAAG,4DAA4D,CAAC,QAAQ,CAAC,CAAC;QACrF,yCAAyC,CAAC,UAAU,CAAC,CAAC;QACtD,MAAM,MAAM,GAAqD;YAC/D,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,GAAG,KAAK,CAAC,MAAM;YACf,SAAS,EAAE,UAAU,EAAE,SAAS;SACjC,CAAC;QACF,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,kCAAkC,EAClC,MAAM,EACN,UAAU,CAC8C,CAAC;QAC7D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,sCAAsC,CAAC,KAAK,EAAE,kCAAkC,CAAC,CAAC;QAC1F,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,yBAAyB,CACpC,QAAmD,EACnD,UAA+C;QAE/C,MAAM,KAAK,GAAG,2CAA2C,CAAC,QAAQ,CAAC,CAAC;QACpE,yCAAyC,CAAC,UAAU,CAAC,CAAC;QACtD,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,2BAA2B,EAC3B,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,EAC9C,UAAU,CACwC,CAAC;QACvD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,sCAAsC,CAAC,KAAK,EAAE,2BAA2B,CAAC,CAAC;QACnF,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,OAAO,CAClB,MAA0B,EAC1B,UAA+C;QAE/C,kCAAkC,CAAC,MAAM,CAAC,CAAC;QAC3C,yCAAyC,CAAC,UAAU,CAAC,CAAC;QACtD,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,OAAO,EACP,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,EAC5C,UAAU,CACkB,CAAC;QACjC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,4EAA4E;YAC5E,IAAI,KAAK,YAAY,KAAK,IAAI,mBAAmB,IAAI,KAAK,IAAI,KAAK,CAAC,iBAAiB,KAAK,cAAc,EAAE,CAAC;gBACzG,MAAM,IAAI,uBAAuB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;YACtD,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,MAAM;QACjB,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAA2B,CAAC,CAAC;IACvD,CAAC;IAEM,KAAK,CAAC,SAAS;QACpB,OAAO,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAA2B,CAAyB,CAAC;IAC3F,CAAC;IAEM,KAAK,CAAC,UAAU;QACrB,OAAO,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,EAA2B,CAA6B,CAAC;IAC1F,CAAC;IAEM,KAAK,CAAC,SAAS,CACpB,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,WAAW,EACX,EAA2B,EAC3B,UAAU,CACO,CAAC;QACtB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,MAAmC;QAEnC,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,MAAM,CAAqC,CAAC;QAC7F,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,kCAAkC,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,MAAyC,EACzC,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,sBAAsB,EACtB,MAAM,EACN,UAAU,CAC2B,CAAC;QAC1C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,kCAAkC,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,MAAyC,EACzC,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,sBAAsB,EACtB,MAAM,EACN,UAAU,CAC2B,CAAC;QAC1C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,kCAAkC,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,sBAAsB,CACjC,MAA2C,EAC3C,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,wBAAwB,EACxB,MAAM,EACN,UAAU,CAC6B,CAAC;QAC5C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,kCAAkC,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,MAAyC,EACzC,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,sBAAsB,EACtB,MAAM,EACN,UAAU,CAC2B,CAAC;QAC1C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,kCAAkC,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,sCAAsC,CACjD,MAA2D,EAC3D,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,wCAAwC,EACxC,MAAM,EACN,UAAU,CAC6C,CAAC;QAC5D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,8CAA8C,CAClD,kCAAkC,CAAC,KAAK,CAAC,EACzC,KAAK,YAAY,OAAO,CAAC,SAAS,CAAC,sBAAsB;gBACvD,CAAC,CAAC,KAAK,CAAC,iBAAiB;gBACzB,CAAC,CAAC,SAAS,CACd,CAAC;QACJ,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,uCAAuC,CAClD,MAA4D,EAC5D,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,yCAAyC,EACzC,MAAM,EACN,UAAU,CAC8C,CAAC;QAC7D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,8CAA8C,CAClD,kCAAkC,CAAC,KAAK,CAAC,EACzC,KAAK,YAAY,OAAO,CAAC,SAAS,CAAC,sBAAsB;gBACvD,CAAC,CAAC,KAAK,CAAC,iBAAiB;gBACzB,CAAC,CAAC,SAAS,CACd,CAAC;QACJ,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,4BAA4B,CACvC,MAAiD;QAEjD,OAAO,IAAI,CAAC,IAAI,CAAC,8BAA8B,EAAE,MAAM,CAA8C,CAAC;IACxG,CAAC;IAEM,KAAK,CAAC,mBAAmB;QAC9B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,EAA2B,CAAoD,CAAC;QACtI,OAAO,MAAM,CAAC,OAAO,CAAC;IACxB,CAAC;IAEM,KAAK,CAAC,2BAA2B,CAAC,MAGxC;QACC,OAAO,IAAI,CAAC,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAA8C,CAAC;IACvG,CAAC;IAEM,KAAK,CAAC,6BAA6B,CACxC,MAAgC,EAChC,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,+BAA+B,EAC/B,MAAM,EACN,UAAU,CACkC,CAAC;QACjD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,kCAAkC,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,cAAc,CACzB,MAAmC,EACnC,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,gBAAgB,EAChB,MAAM,EACN,UAAU,CACe,CAAC;QAC9B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAC7B,MAAuC,EACvC,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,oBAAoB,EACpB,MAAM,EACN,UAAU,CACe,CAAC;QAC9B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,kCAAkC,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,wBAAwB,CACnC,MAA6C,EAC7C,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,0BAA0B,EAC1B,MAAM,EACN,UAAU,CACsB,CAAC;QACrC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,cAAc,CACzB,MAAmC,EACnC,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,gBAAgB,EAChB,EAAE,GAAG,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,EAC/C,UAAU,CACqB,CAAC;QACpC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,kCAAkC,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,yBAAyB,CACpC,MAA8C,EAC9C,UAA+C;QAE/C,IAAI,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,IAAI,CACpB,2BAA2B,EAC3B,MAAM,EACN,UAAU,CACgC,CAAC;QAC/C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mCAAmC,CAAC,KAAK,CAAC,CAAC;YACtD,MAAM,kCAAkC,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,MAAM,GAKxB,EAAE;QACJ,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAA0B,CAAC;IAChE,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAAC,MAAuC;QACrE,OAAO,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC;IACjD,CAAC;IAEM,KAAK,CAAC,aAAa;QACxB,OAAO,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,EAA2B,CAAyB,CAAC;IACzF,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,GAAW,EAAE,MAAM,GAAG,KAAK;QAClD,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,CAA2B,CAAC;IAC7E,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,EAAW;QACrC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAuC,CAAC;QACzG,OAAO,MAAM,CAAC,WAAW,CAAC;IAC5B,CAAC;IAEM,KAAK,CAAC,YAAY,CACvB,EAAU,EACV,UAAkB,EAClB,KAAK,GAAG,EAAE,EACV,IAAI,GAAG,CAAC;QAER,OAAO,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,CAA8B,CAAC;IACjG,CAAC;CACF"}