recker 1.0.102 → 1.0.103

package/dist/clients/reddb.js

@@ -1,13 +1,91 @@
 import { performance } from 'node:perf_hooks';
 import { connect as connectTcp } from 'node:net';
 import { connect as connectTls } from 'node:tls';
+import * as grpc from '@grpc/grpc-js';
+import protobuf from 'protobufjs';
 import { createClient } from '../core/client.js';
-import { AuthenticationError, ConfigurationError, ConnectionError, NotFoundError, ParseError, ProtocolError, UnsupportedError, ValidationError, } from '../core/errors.js';
+import { AbortError, AuthenticationError, ConfigurationError, ConnectionError, NotFoundError, ParseError, ProtocolError, UnsupportedError, ValidationError, } from '../core/errors.js';
+import { REDDB_PROTO } from './reddb-proto.js';
+const PROTO_OBJECT_OPTIONS = {
+    longs: Number,
+    enums: String,
+    defaults: false,
+    arrays: true,
+    objects: true,
+    oneofs: true,
+};
+const parsedProto = protobuf.parse(REDDB_PROTO, { keepCase: true });
+const protoRoot = parsedProto.root.resolveAll();
+const protoService = protoRoot.lookupService('reddb.v1.RedDb');
+const grpcDefinition = buildGrpcDefinition(protoService);
+const GrpcRedDbClient = grpc.makeGenericClientConstructor(grpcDefinition, 'RedDb');
 const WIRE_MSG_QUERY = 0x01;
 const WIRE_MSG_RESULT = 0x02;
 const WIRE_MSG_ERROR = 0x03;
 const WIRE_MSG_BULK_INSERT = 0x04;
 const WIRE_MSG_BULK_OK = 0x05;
+const WIRE_MSG_BULK_INSERT_BINARY = 0x06;
+const WIRE_VAL_NULL = 0;
+const WIRE_VAL_I64 = 1;
+const WIRE_VAL_F64 = 2;
+const WIRE_VAL_TEXT = 3;
+const WIRE_VAL_BOOL = 4;
+const WIRE_VAL_U64 = 5;
+const QUERY_PROFILE = {
+    preferences: ['wire', 'grpc', 'http'],
+};
+const BATCH_PROFILE = {
+    preferences: ['wire', 'grpc', 'http'],
+    emulated: ['wire', 'http'],
+};
+const CONTROL_PROFILE = {
+    preferences: ['grpc', 'http'],
+    supported: { wire: false },
+};
+const ROW_SCAN_PROFILE = {
+    preferences: ['grpc', 'http'],
+    supported: { wire: false },
+};
+const ROW_BULK_PROFILE = {
+    preferences: ['wire', 'grpc', 'http'],
+};
+const ROW_MUTATION_PROFILE = {
+    preferences: ['grpc', 'http'],
+    supported: { wire: false },
+};
+const ENTITY_MUTATION_PROFILE = {
+    preferences: ['grpc', 'http'],
+    supported: { wire: false },
+};
+const VECTOR_SEARCH_PROFILE = {
+    preferences: ['grpc', 'http'],
+    supported: { wire: false },
+};
+const KV_HTTP_PROFILE = {
+    preferences: ['http'],
+    supported: { grpc: false, wire: false },
+};
+const KV_LIST_PROFILE = {
+    preferences: ['http', 'grpc', 'wire'],
+};
+function buildGrpcDefinition(service) {
+    const definition = {};
+    for (const method of service.methodsArray) {
+        definition[method.name] = {
+            path: `/${service.fullName.replace(/^\./, '')}/${method.name}`,
+            requestStream: false,
+            responseStream: false,
+            requestSerialize: (value) => Buffer.from(method.resolvedRequestType.encode(method.resolvedRequestType.fromObject(value)).finish()),
+            requestDeserialize: (value) => method.resolvedRequestType.toObject(method.resolvedRequestType.decode(value), PROTO_OBJECT_OPTIONS),
+            responseSerialize: (value) => Buffer.from(method.resolvedResponseType.encode(method.resolvedResponseType.fromObject(value)).finish()),
+            responseDeserialize: (value) => method.resolvedResponseType.toObject(method.resolvedResponseType.decode(value), PROTO_OBJECT_OPTIONS),
+        };
+    }
+    return definition;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
 function isBufferLike(value) {
     return Buffer.isBuffer(value) || value instanceof Uint8Array;
 }
@@ -50,6 +128,32 @@ function parseWireAddress(address) {
     }
     return { host, port };
 }
+function parseGrpcAddress(address) {
+    if (!address || !address.trim()) {
+        throw new ConfigurationError('grpcAddress must be a non-empty target string', {
+            configKey: 'grpcAddress',
+        });
+    }
+    const trimmed = address.trim();
+    if (trimmed.includes('://')) {
+        const url = new URL(trimmed);
+        const secure = url.protocol === 'grpcs:' || url.protocol === 'https:';
+        const port = Number(url.port || (secure ? 443 : 50051));
+        if (!url.hostname || !Number.isInteger(port) || port <= 0) {
+            throw new ConfigurationError(`Invalid grpcAddress: ${address}`, {
+                configKey: 'grpcAddress',
+            });
+        }
+        return {
+            target: `${url.hostname}:${port}`,
+            secure,
+        };
+    }
+    return {
+        target: trimmed,
+        secure: false,
+    };
+}
 function escapeSqlIdentifier(value) {
     if (!value || !value.trim()) {
         throw new ValidationError('SQL identifier cannot be empty', {
@@ -59,12 +163,74 @@ function escapeSqlIdentifier(value) {
     }
     return `"${value.replace(/"/g, '""')}"`;
 }
+function escapeSqlLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function toSafeNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function toPositiveInteger(value, field, minimum = 0) {
+    const parsed = toSafeNumber(value);
+    if (parsed === undefined || !Number.isInteger(parsed) || parsed < minimum) {
+        throw new ValidationError(`${field} must be an integer >= ${minimum}`, {
+            field,
+            value,
+        });
+    }
+    return parsed;
+}
+function parseJsonText(text, context) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new ParseError(`Failed to parse RedDB ${context}: ${error instanceof Error ? error.message : String(error)}`, { format: 'json' });
+    }
+}
+function parseMaybeJson(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return text;
+    }
+}
+function stringifyJson(value, context) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch (error) {
+        throw new ValidationError(`Failed to serialize ${context} as JSON: ${error instanceof Error ? error.message : String(error)}`, { field: context, value });
+    }
+}
+function ensureNonEmptyString(value, field, message) {
+    if (!value || !value.trim()) {
+        throw new ValidationError(message || `${field} must be a non-empty string`, {
+            field,
+            value,
+        });
+    }
+    return value;
+}
 function buildQueryStats(data) {
-    if (!data || typeof data !== 'object') {
+    if (!isPlainObject(data)) {
         return {};
     }
     const queryData = data;
-    const stats = queryData.result?.stats;
+    const stats = isPlainObject(queryData.result?.stats) ? queryData.result?.stats : undefined;
     return {
         recordCount: typeof queryData.record_count === 'number' ? queryData.record_count : undefined,
         affectedRows: typeof queryData.affected_rows === 'number' ? queryData.affected_rows : undefined,
@@ -91,24 +257,197 @@ async function mapWithConcurrency(items, concurrency, worker) {
     await Promise.all(Array.from({ length: safeConcurrency }, () => run()));
     return results;
 }
+function normalizeQueryData(data) {
+    if (!isPlainObject(data)) {
+        return {};
+    }
+    const normalized = { ...data };
+    normalized.record_count = toSafeNumber(data.record_count);
+    normalized.affected_rows = toSafeNumber(data.affected_rows);
+    const resultJson = typeof data.result_json === 'string' ? parseMaybeJson(data.result_json) : undefined;
+    const sourceResult = isPlainObject(data.result) ? { ...data.result } : undefined;
+    const jsonResult = isPlainObject(resultJson) ? { ...resultJson } : undefined;
+    if (sourceResult || jsonResult || Array.isArray(data.columns)) {
+        normalized.result = {
+            ...(jsonResult || {}),
+            ...(sourceResult || {}),
+        };
+    }
+    if (normalized.result && Array.isArray(data.columns)) {
+        normalized.result.columns = data.columns.map((value) => String(value));
+    }
+    if (isPlainObject(normalized.result?.stats)) {
+        normalized.result.stats = {
+            ...normalized.result.stats,
+            rows_scanned: toSafeNumber(normalized.result.stats.rows_scanned),
+            exec_time_us: toSafeNumber(normalized.result.stats.exec_time_us),
+            nodes_scanned: toSafeNumber(normalized.result.stats.nodes_scanned),
+            edges_scanned: toSafeNumber(normalized.result.stats.edges_scanned),
+        };
+    }
+    return normalized;
+}
+function normalizeBatchQueryData(data) {
+    if (!isPlainObject(data) || !Array.isArray(data.results)) {
+        return { results: [] };
+    }
+    return {
+        ...data,
+        results: data.results.map((item) => normalizeQueryData(item)),
+    };
+}
+function normalizeScanData(data) {
+    if (!isPlainObject(data)) {
+        return {
+            collection: '',
+            total: 0,
+            next_offset: null,
+            items: [],
+        };
+    }
+    return {
+        ...data,
+        collection: typeof data.collection === 'string' ? data.collection : '',
+        total: toSafeNumber(data.total) ?? 0,
+        next_offset: toSafeNumber(data.next_offset) ?? null,
+        items: Array.isArray(data.items)
+            ? data.items.map((item) => ({
+                ...(isPlainObject(item) ? item : {}),
+                id: toSafeNumber(isPlainObject(item) ? item.id : undefined) ?? 0,
+                kind: isPlainObject(item) && typeof item.kind === 'string' ? item.kind : '',
+                collection: isPlainObject(item) && typeof item.collection === 'string' ? item.collection : '',
+                json: isPlainObject(item) && typeof item.json === 'string' ? item.json : '',
+            }))
+            : [],
+    };
+}
+function normalizeEntityData(data) {
+    if (!isPlainObject(data)) {
+        return {};
+    }
+    const entity = typeof data.entity_json === 'string'
+        ? parseMaybeJson(data.entity_json)
+        : data.entity;
+    return {
+        ...data,
+        id: toSafeNumber(data.id),
+        entity,
+        entity_json: typeof data.entity_json === 'string' ? data.entity_json : undefined,
+    };
+}
+function normalizeBulkEntityData(data) {
+    if (!isPlainObject(data)) {
+        return {};
+    }
+    return {
+        ...data,
+        count: toSafeNumber(data.count),
+        first_id: toSafeNumber(data.first_id),
+        items: Array.isArray(data.items) ? data.items.map((item) => normalizeEntityData(item)) : undefined,
+    };
+}
+function normalizeBulkInsertData(data) {
+    if (!isPlainObject(data)) {
+        return {};
+    }
+    return {
+        ...data,
+        count: toSafeNumber(data.count),
+        first_id: toSafeNumber(data.first_id),
+    };
+}
+function normalizeCollectionsData(data) {
+    if (Array.isArray(data)) {
+        return { collections: data.map((value) => String(value)) };
+    }
+    if (!isPlainObject(data)) {
+        return { collections: [] };
+    }
+    return {
+        ...data,
+        collections: Array.isArray(data.collections) ? data.collections.map((value) => String(value)) : [],
+    };
+}
+function normalizeHealthData(data) {
+    if (!isPlainObject(data)) {
+        return {};
+    }
+    return {
+        ...data,
+        checked_at_unix_ms: toSafeNumber(data.checked_at_unix_ms),
+    };
+}
+function normalizeStatsData(data) {
+    if (!isPlainObject(data)) {
+        return {};
+    }
+    return {
+        ...data,
+        collection_count: toSafeNumber(data.collection_count),
+        total_entities: toSafeNumber(data.total_entities),
+        total_memory_bytes: toSafeNumber(data.total_memory_bytes),
+        cross_ref_count: toSafeNumber(data.cross_ref_count),
+        active_connections: toSafeNumber(data.active_connections),
+        idle_connections: toSafeNumber(data.idle_connections),
+        total_checkouts: toSafeNumber(data.total_checkouts),
+        started_at_unix_ms: toSafeNumber(data.started_at_unix_ms),
+    };
+}
+function normalizePayloadValue(data) {
+    if (!isPlainObject(data)) {
+        return { payload: data };
+    }
+    const ok = typeof data.ok === 'boolean' ? data.ok : undefined;
+    const payload = typeof data.payload === 'string' ? parseMaybeJson(data.payload) : data.payload;
+    if (isPlainObject(payload)) {
+        return ok === undefined || Object.prototype.hasOwnProperty.call(payload, 'ok')
+            ? payload
+            : { ok, ...payload };
+    }
+    if (Array.isArray(payload)) {
+        return {
+            ok,
+            items: payload,
+        };
+    }
+    if (payload !== undefined) {
+        return {
+            ok,
+            payload,
+        };
+    }
+    return { ...data };
+}
+function normalizeOperationData(data, extras = {}) {
+    const base = isPlainObject(data) ? { ...data } : {};
+    for (const [key, value] of Object.entries(extras)) {
+        if (!Object.prototype.hasOwnProperty.call(base, key)) {
+            base[key] = value;
+        }
+    }
+    return base;
+}
 class RedDbWireSocket {
     endpoint;
     tlsOptions;
     timeout;
+    connectTimeout;
+    keepAlive;
+    keepAliveInitialDelayMs;
     socket = null;
     connectPromise = null;
     pending = [];
     buffer = Buffer.alloc(0);
-    constructor(address, tlsOptions, timeout) {
+    constructor(address, tlsOptions, timeout, connectTimeout, keepAlive, keepAliveInitialDelayMs) {
         this.endpoint = parseWireAddress(address);
         this.timeout = timeout;
+        this.connectTimeout = connectTimeout;
+        this.keepAlive = keepAlive;
+        this.keepAliveInitialDelayMs = keepAliveInitialDelayMs;
         this.tlsOptions = typeof tlsOptions === 'boolean'
             ? { enabled: tlsOptions }
             : { enabled: tlsOptions?.enabled ?? false, ...tlsOptions };
     }
-    get available() {
-        return this.socket !== null && !this.socket.destroyed;
-    }
     async query(sql, timeout) {
         const response = await this.send(WIRE_MSG_QUERY, Buffer.from(sql, 'utf8'), timeout);
         if (response.type !== WIRE_MSG_RESULT) {
@@ -118,12 +457,7 @@ class RedDbWireSocket {
                 phase: 'query',
             });
         }
-        try {
-            return JSON.parse(response.payload.toString('utf8'));
-        }
-        catch (error) {
-            throw new ParseError(`Failed to parse RedDB wire query payload: ${error instanceof Error ? error.message : String(error)}`, { format: 'json' });
-        }
+        return parseJsonText(response.payload.toString('utf8'), 'wire query payload');
     }
     async bulkInsert(collection, payloads, timeout) {
         const collectionBuffer = Buffer.from(collection, 'utf8');
@@ -139,23 +473,40 @@ class RedDbWireSocket {
             parts.push(lengthBuffer, jsonBuffer);
         }
         const response = await this.send(WIRE_MSG_BULK_INSERT, Buffer.concat(parts), timeout);
-        if (response.type !== WIRE_MSG_BULK_OK) {
-            throw new ProtocolError(`Unexpected wire bulk response type: ${response.type}`, {
-                protocol: 'reddb',
-                code: response.type,
-                phase: 'bulkInsert',
-            });
+        return decodeBulkOkResponse(response, 'bulkInsert');
+    }
+    async bulkInsertBinary(collection, fieldNames, rows, timeout) {
+        const collectionBuffer = Buffer.from(collection, 'utf8');
+        const header = Buffer.alloc(2 + collectionBuffer.length + 2);
+        header.writeUInt16LE(collectionBuffer.length, 0);
+        collectionBuffer.copy(header, 2);
+        header.writeUInt16LE(fieldNames.length, 2 + collectionBuffer.length);
+        const parts = [header];
+        for (const fieldName of fieldNames) {
+            const nameBuffer = Buffer.from(fieldName, 'utf8');
+            const nameHeader = Buffer.alloc(2);
+            nameHeader.writeUInt16LE(nameBuffer.length, 0);
+            parts.push(nameHeader, nameBuffer);
         }
-        if (response.payload.length >= 8) {
-            return Number(response.payload.readBigUInt64LE(0));
+        const rowHeader = Buffer.alloc(4);
+        rowHeader.writeUInt32LE(rows.length, 0);
+        parts.push(rowHeader);
+        for (const row of rows) {
+            if (row.length !== fieldNames.length) {
+                throw new ValidationError(`bulkInsertBinary row length ${row.length} does not match fieldNames length ${fieldNames.length}`, { field: 'rows', value: row });
+            }
+            for (const value of row) {
+                parts.push(encodeWireBinaryValue(value));
+            }
         }
-        return 0;
+        const response = await this.send(WIRE_MSG_BULK_INSERT_BINARY, Buffer.concat(parts), timeout);
+        return decodeBulkOkResponse(response, 'bulkInsertBinary');
     }
     async close() {
         this.destroy();
     }
     async connect() {
-        if (this.available) {
+        if (this.socket && !this.socket.destroyed) {
             return;
         }
         if (this.connectPromise) {
@@ -175,6 +526,7 @@ class RedDbWireSocket {
                 cleanup();
                 if (!socket.destroyed) {
                     socket.setNoDelay(true);
+                    socket.setKeepAlive(this.keepAlive, this.keepAliveInitialDelayMs);
                 }
                 this.socket = socket;
                 socket.on('data', (chunk) => this.onData(chunk));
@@ -198,7 +550,7 @@ class RedDbWireSocket {
                     host: this.endpoint.host,
                     port: this.endpoint.port,
                 }, onConnect);
-            socket.setTimeout(this.timeout, () => {
+            socket.setTimeout(this.connectTimeout, () => {
                 onError(new Error(`RedDB wire connection to ${this.endpoint.host}:${this.endpoint.port} timed out`));
             });
             socket.once('error', onError);
@@ -296,23 +648,298 @@ class RedDbWireSocket {
         }
     }
 }
+class RedDbWirePool {
+    clients;
+    nextIndex = 0;
+    constructor(clients) {
+        if (clients.length === 0) {
+            throw new ConfigurationError('wire pool requires at least one client', {
+                configKey: 'wirePoolSize',
+            });
+        }
+        this.clients = clients;
+    }
+    async query(sql, timeout) {
+        return await this.select().query(sql, timeout);
+    }
+    async bulkInsert(collection, payloads, timeout) {
+        return await this.select().bulkInsert(collection, payloads, timeout);
+    }
+    async bulkInsertBinary(collection, fieldNames, rows, timeout) {
+        return await this.select().bulkInsertBinary(collection, fieldNames, rows, timeout);
+    }
+    async close() {
+        await Promise.all(this.clients.map((client) => client.close()));
+    }
+    select() {
+        const client = this.clients[this.nextIndex % this.clients.length];
+        this.nextIndex += 1;
+        return client;
+    }
+}
+function decodeBulkOkResponse(response, phase) {
+    if (response.type !== WIRE_MSG_BULK_OK) {
+        throw new ProtocolError(`Unexpected wire bulk response type: ${response.type}`, {
+            protocol: 'reddb',
+            code: response.type,
+            phase,
+        });
+    }
+    if (response.payload.length >= 8) {
+        return Number(response.payload.readBigUInt64LE(0));
+    }
+    return 0;
+}
+function encodeWireBinaryValue(value) {
+    if (value === null) {
+        return Buffer.from([WIRE_VAL_NULL]);
+    }
+    if (typeof value === 'string') {
+        const text = Buffer.from(value, 'utf8');
+        const buffer = Buffer.alloc(1 + 4 + text.length);
+        buffer[0] = WIRE_VAL_TEXT;
+        buffer.writeUInt32LE(text.length, 1);
+        text.copy(buffer, 5);
+        return buffer;
+    }
+    if (typeof value === 'boolean') {
+        return Buffer.from([WIRE_VAL_BOOL, value ? 1 : 0]);
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new ValidationError('bulkInsertBinary number values must be finite', {
+                field: 'rows',
+                value,
+            });
+        }
+        if (Number.isInteger(value)) {
+            const buffer = Buffer.alloc(1 + 8);
+            buffer[0] = WIRE_VAL_I64;
+            buffer.writeBigInt64LE(BigInt(value), 1);
+            return buffer;
+        }
+        const buffer = Buffer.alloc(1 + 8);
+        buffer[0] = WIRE_VAL_F64;
+        buffer.writeDoubleLE(value, 1);
+        return buffer;
+    }
+    if (typeof value === 'bigint') {
+        const maxU64 = (1n << 64n) - 1n;
+        const minI64 = -(1n << 63n);
+        const maxI64 = (1n << 63n) - 1n;
+        if (value >= 0 && value <= maxU64) {
+            const buffer = Buffer.alloc(1 + 8);
+            buffer[0] = WIRE_VAL_U64;
+            buffer.writeBigUInt64LE(value, 1);
+            return buffer;
+        }
+        if (value >= minI64 && value <= maxI64) {
+            const buffer = Buffer.alloc(1 + 8);
+            buffer[0] = WIRE_VAL_I64;
+            buffer.writeBigInt64LE(value, 1);
+            return buffer;
+        }
+        throw new ValidationError('bulkInsertBinary bigint values must fit within 64 bits', {
+            field: 'rows',
+            value: value.toString(),
+        });
+    }
+    if (isBufferLike(value)) {
+        throw new UnsupportedError('RedDB wire bulkInsertBinary does not support byte values; use the gRPC transport for blob payloads', { feature: 'reddb.wire.bulkInsertBinary.bytes' });
+    }
+    throw new ValidationError('Unsupported bulkInsertBinary value type', {
+        field: 'rows',
+        value,
+    });
+}
+class RedDbGrpcClient {
+    client;
+    timeout;
+    metadataEntries;
+    constructor(address, tlsOptions, timeout, metadataEntries, keepalive, channelOptions) {
+        const parsed = parseGrpcAddress(address);
+        const resolvedTls = typeof tlsOptions === 'boolean'
+            ? { enabled: tlsOptions }
+            : { enabled: tlsOptions?.enabled ?? parsed.secure, ...tlsOptions };
+        const rootCerts = typeof resolvedTls.ca === 'string' ? Buffer.from(resolvedTls.ca) : (resolvedTls.ca ?? null);
+        const credentials = resolvedTls.enabled
+            ? grpc.credentials.createSsl(rootCerts, null, null, {
+                rejectUnauthorized: resolvedTls.rejectUnauthorized ?? true,
+            })
+            : grpc.credentials.createInsecure();
+        const keepaliveOptions = {
+            'grpc.keepalive_time_ms': keepalive?.timeMs ?? 30000,
+            'grpc.keepalive_timeout_ms': keepalive?.timeoutMs ?? 10000,
+            'grpc.keepalive_permit_without_calls': keepalive?.permitWithoutCalls === false ? 0 : 1,
+            'grpc.http2.max_pings_without_data': keepalive?.maxPingsWithoutData ?? 0,
+            'grpc.initial_reconnect_backoff_ms': keepalive?.initialReconnectBackoffMs ?? 250,
+            'grpc.max_reconnect_backoff_ms': keepalive?.maxReconnectBackoffMs ?? 5000,
+        };
+        const options = {
+            ...keepaliveOptions,
+            ...(channelOptions || {}),
+        };
+        if (resolvedTls.servername) {
+            options['grpc.ssl_target_name_override'] = resolvedTls.servername;
+            options['grpc.default_authority'] = resolvedTls.servername;
+        }
+        this.client = new GrpcRedDbClient(parsed.target, credentials, options);
+        this.timeout = timeout;
+        this.metadataEntries = metadataEntries;
+    }
+    async unary(methodName, request, options) {
+        if (options.signal?.aborted) {
+            throw new AbortError();
+        }
+        return await new Promise((resolve, reject) => {
+            const metadata = new grpc.Metadata();
+            for (const [key, value] of this.metadataEntries) {
+                metadata.set(key, value);
+            }
+            let completed = false;
+            const cleanup = () => {
+                if (options.signal && onAbort) {
+                    options.signal.removeEventListener('abort', onAbort);
+                }
+            };
+            const callback = (error, response) => {
+                if (completed) {
+                    return;
+                }
+                completed = true;
+                cleanup();
+                if (error) {
+                    reject(mapGrpcError(methodName, error, options.signal?.aborted ?? false));
+                    return;
+                }
+                resolve(response);
+            };
+            const deadlineMs = options.timeout ?? this.timeout;
+            const callOptions = deadlineMs > 0 && Number.isFinite(deadlineMs)
+                ? { deadline: new Date(Date.now() + deadlineMs) }
+                : {};
+            const method = this.client[methodName];
+            const call = method.call(this.client, request, metadata, callOptions, callback);
+            const onAbort = options.signal
+                ? () => {
+                    if (completed) {
+                        return;
+                    }
+                    call.cancel();
+                }
+                : null;
+            if (options.signal && onAbort) {
+                options.signal.addEventListener('abort', onAbort, { once: true });
+            }
+        });
+    }
+    close() {
+        this.client.close();
+    }
+}
+function mapGrpcError(methodName, error, aborted) {
+    if (aborted || error.code === grpc.status.CANCELLED) {
+        return new AbortError(`RedDB gRPC ${methodName} was aborted`);
+    }
+    if (error.code === grpc.status.UNAUTHENTICATED) {
+        return new AuthenticationError(`RedDB gRPC ${methodName} unauthorized: ${error.message}`, {
+            authType: 'bearer',
+        });
+    }
+    if (error.code === grpc.status.NOT_FOUND) {
+        return new NotFoundError(`RedDB gRPC ${methodName} not found: ${error.message}`, {
+            resource: methodName,
+        });
+    }
+    if (error.code === grpc.status.DEADLINE_EXCEEDED || error.code === grpc.status.UNAVAILABLE) {
+        return new ConnectionError(`RedDB gRPC ${methodName} failed: ${error.message}`, {
+            code: String(error.code),
+        });
+    }
+    return new ProtocolError(`RedDB gRPC ${methodName} failed: ${error.message}`, {
+        protocol: 'reddb',
+        code: error.code,
+        phase: 'grpc',
+        retriable: error.code === grpc.status.RESOURCE_EXHAUSTED || error.code === grpc.status.INTERNAL,
+    });
+}
 export class RedDbClient {
     baseUrl;
     httpClient;
+    grpcClient;
+    wireClient;
     defaultTransport;
     allowTransportFallback;
     timeout;
     batchConcurrency;
-    wireClient;
+    operationTimeouts;
+    system = {
+        health: (options = {}) => this.executeSystemHealth('system.health', 'Health', '/health', options),
+        ready: (options = {}) => this.executeSystemHealth('system.ready', 'Ready', '/ready', options),
+        stats: (options = {}) => this.executeSystemStats(options),
+    };
+    sql = {
+        query: (query, options = {}) => this.executeSqlQuery('sql.query', query, options),
+        explain: (query, options = {}) => this.executeSqlExplain(query, options),
+        batch: (queries, options = {}) => this.executeSqlBatch(queries, options),
+    };
+    collections = {
+        list: (options = {}) => this.executeCollectionsList(options),
+        create: (options) => this.executeCollectionCreate(options),
+        describe: (options) => this.executeCollectionDescribe(options),
+        drop: (options) => this.executeCollectionDrop(options),
+    };
+    indexes = {
+        list: (options = {}) => this.executeIndexesList(options),
+        statuses: (options = {}) => this.executeIndexesStatuses(options),
+        create: (options) => this.executeIndexCreate(options),
+        enable: (options) => this.executeIndexToggle('indexes.enable', 'enable', true, options),
+        disable: (options) => this.executeIndexToggle('indexes.disable', 'disable', false, options),
+        warmup: (options) => this.executeIndexWarmup(options),
+        rebuild: (options = {}) => this.executeIndexesRebuild(options),
+    };
+    rows = {
+        scan: (request) => this.executeRowsScan(request),
+        create: (request) => this.executeRowCreate(request),
+        bulkCreate: (request) => this.executeRowsBulkCreate(request),
+        patch: (request) => this.executeRowPatch(request),
+        delete: (request) => this.executeRowDelete(request),
+    };
+    documents = {
+        create: (request) => this.executeEntityCreate('documents.create', 'CreateDocument', 'documents', request),
+        bulkCreate: (request) => this.executeBulkEntityCreate('documents.bulkCreate', 'BulkCreateDocuments', 'bulk/documents', request),
+    };
+    nodes = {
+        create: (request) => this.executeEntityCreate('nodes.create', 'CreateNode', 'nodes', request),
+        bulkCreate: (request) => this.executeBulkEntityCreate('nodes.bulkCreate', 'BulkCreateNodes', 'bulk/nodes', request),
+    };
+    edges = {
+        create: (request) => this.executeEntityCreate('edges.create', 'CreateEdge', 'edges', request),
+        bulkCreate: (request) => this.executeBulkEntityCreate('edges.bulkCreate', 'BulkCreateEdges', 'bulk/edges', request),
+    };
+    vectors = {
+        create: (request) => this.executeEntityCreate('vectors.create', 'CreateVector', 'vectors', request),
+        bulkCreate: (request) => this.executeBulkEntityCreate('vectors.bulkCreate', 'BulkCreateVectors', 'bulk/vectors', request),
+        bulkInsertBinary: (request) => this.executeVectorBulkInsertBinary(request),
+        similar: (request) => this.executeVectorSearch('vectors.similar', 'Similar', 'similar', request),
+        ivfSearch: (request) => this.executeVectorSearch('vectors.ivfSearch', 'IvfSearch', 'ivf/search', request),
+    };
+    kv = {
+        get: (request) => this.executeKvGet(request),
+        put: (request) => this.executeKvPut(request),
+        delete: (request) => this.executeKvDelete(request),
+        list: (request) => this.executeKvList(request),
+    };
     constructor(options = {}) {
         this.baseUrl = options.baseUrl;
         this.defaultTransport = options.transport ?? 'auto';
         this.allowTransportFallback = options.allowTransportFallback ?? true;
         this.timeout = options.timeout ?? 30000;
         this.batchConcurrency = Math.max(1, options.batchConcurrency ?? 8);
+        this.operationTimeouts = { ...(options.operationTimeouts || {}) };
         const headers = { ...(options.headers || {}) };
         if (options.authToken) {
-            headers.Authorization = `Bearer ${options.authToken}`;
+            headers.authorization = `Bearer ${options.authToken}`;
         }
         if (options.writeToken) {
             headers['x-write-token'] = options.writeToken;
@@ -332,274 +959,710 @@ export class RedDbClient {
         else {
             this.httpClient = null;
         }
-        this.wireClient = options.wireAddress
-            ? new RedDbWireSocket(options.wireAddress, options.wireTls, this.timeout)
+        this.grpcClient = options.grpcAddress
+            ? new RedDbGrpcClient(options.grpcAddress, options.grpcTls, this.timeout, Object.entries(headers), options.grpcKeepalive, options.grpcOptions)
             : null;
+        if (options.wireAddress) {
+            const wirePoolSize = Math.max(1, options.wirePoolSize ?? 1);
+            const wireConnectTimeout = options.wireConnectTimeout ?? this.timeout;
+            const wireKeepAlive = options.wireKeepAlive ?? true;
+            const wireKeepAliveInitialDelayMs = options.wireKeepAliveInitialDelayMs ?? 30000;
+            const clients = Array.from({ length: wirePoolSize }, () => new RedDbWireSocket(options.wireAddress, options.wireTls, this.timeout, wireConnectTimeout, wireKeepAlive, wireKeepAliveInitialDelayMs));
+            this.wireClient = wirePoolSize === 1
+                ? clients[0]
+                : new RedDbWirePool(clients);
+        }
+        else {
+            this.wireClient = null;
+        }
     }
     getCapabilities() {
         const hasHttp = this.httpClient !== null;
+        const hasGrpc = this.grpcClient !== null;
         const hasWire = this.wireClient !== null;
         return {
             requestedTransport: this.defaultTransport,
             allowTransportFallback: this.allowTransportFallback,
             availableTransports: {
                 http: hasHttp,
+                grpc: hasGrpc,
                 wire: hasWire,
-                grpc: false,
             },
-            native: {
-                query: hasHttp || hasWire,
-                batchQuery: false,
-                scan: hasHttp,
-                bulkInsertRows: hasHttp || hasWire,
-                bulkInsertBinary: false,
-                stats: hasHttp,
-                ensureCollection: hasHttp,
-                ensureIndex: hasHttp || hasWire,
-                warmupIndex: hasHttp,
+            namespaces: {
+                system: hasHttp || hasGrpc,
+                sql: hasHttp || hasGrpc || hasWire,
+                collections: hasHttp || hasGrpc,
+                indexes: hasHttp || hasGrpc || hasWire,
+                rows: hasHttp || hasGrpc || hasWire,
+                documents: hasHttp || hasGrpc,
+                nodes: hasHttp || hasGrpc,
+                edges: hasHttp || hasGrpc,
+                vectors: hasHttp || hasGrpc || hasWire,
+                kv: hasHttp || hasGrpc || hasWire,
             },
-            emulated: {
-                batchQuery: hasHttp || hasWire,
-                bulkInsertBinary: hasHttp || hasWire,
+            features: {
+                grpcNative: hasGrpc,
+                wireSql: hasWire,
+                wireBulkRows: hasWire,
+                wireBinaryBulkScalars: hasWire,
+                httpBinaryBulkEmulation: hasHttp,
+                sqlBatchEmulationOverHttp: hasHttp,
+                sqlBatchEmulationOverWire: hasWire,
+                kvListViaSql: hasHttp || hasGrpc || hasWire,
             },
         };
     }
-    async query(query, options = {}) {
-        if (!query || !query.trim()) {
-            throw new ValidationError('Query must be a non-empty string', {
-                field: 'query',
-                value: query,
-            });
+    async close() {
+        if (this.grpcClient) {
+            this.grpcClient.close();
+        }
+        if (this.wireClient) {
+            await this.wireClient.close();
         }
-        const resolution = this.resolveTransport('query', options.transport);
+    }
+    async executeSystemHealth(operation, grpcMethod, httpPath, options) {
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
         const startedAt = Date.now();
         const started = performance.now();
-        const data = resolution.transport === 'wire'
-            ? await this.runWireQuery(query, options)
-            : await this.runHttpQuery('/query', {
-                query,
-                entity_types: options.entityTypes,
-                capabilities: options.capabilities,
-            }, options);
-        return this.buildEnvelope('query', data, resolution, startedAt, started);
-    }
-    async explainQuery(query, options = {}) {
-        if (!query || !query.trim()) {
-            throw new ValidationError('Query must be a non-empty string', {
-                field: 'query',
-                value: query,
-            });
-        }
-        const resolution = this.resolveTransport('explainQuery', options.transport);
+        const data = resolution.transport === 'grpc'
+            ? normalizeHealthData(await this.runGrpc(grpcMethod, {}, requestOptions))
+            : normalizeHealthData(await this.runHttpGet(httpPath, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeSystemStats(options) {
+        const operation = 'system.stats';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizeStatsData(await this.runGrpc('Stats', {}, requestOptions))
+            : normalizeStatsData(await this.runHttpGet('/stats', requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeSqlQuery(operation, query, options) {
+        ensureNonEmptyString(query, 'query', 'Query must be a non-empty string');
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, QUERY_PROFILE, requestOptions.transport);
         const startedAt = Date.now();
         const started = performance.now();
         const data = resolution.transport === 'wire'
-            ? await this.runWireQuery(`EXPLAIN ${query}`, options)
-            : await this.runHttpQuery('/query/explain', { query }, options);
-        return this.buildEnvelope('explainQuery', data, resolution, startedAt, started);
+            ? normalizeQueryData(await this.runWireQuery(query, requestOptions))
+            : resolution.transport === 'grpc'
+                ? normalizeQueryData(await this.runGrpc('Query', {
+                    query,
+                    entity_types: requestOptions.entityTypes ?? [],
+                    capabilities: requestOptions.capabilities ?? [],
+                }, requestOptions))
+                : normalizeQueryData(await this.runHttpPost('/query', {
+                    query,
+                    entity_types: requestOptions.entityTypes,
+                    capabilities: requestOptions.capabilities,
+                }, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
     }
-    async mutateQuery(query, options = {}) {
-        return this.query(query, options);
+    async executeSqlExplain(query, options) {
+        ensureNonEmptyString(query, 'query', 'Query must be a non-empty string');
+        const operation = 'sql.explain';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, QUERY_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'wire'
+            ? normalizePayloadValue(await this.runWireQuery(`EXPLAIN ${query}`, requestOptions))
+            : resolution.transport === 'grpc'
+                ? normalizePayloadValue(await this.runGrpc('ExplainQuery', {
+                    query,
+                    entity_types: requestOptions.entityTypes ?? [],
+                    capabilities: requestOptions.capabilities ?? [],
+                }, requestOptions))
+                : normalizePayloadValue(await this.runHttpPost('/query/explain', {
+                    query,
+                }, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
     }
-    async batchQuery(queries, options = {}) {
+    async executeSqlBatch(queries, options) {
         if (!Array.isArray(queries) || queries.length === 0) {
-            throw new ValidationError('batchQuery requires a non-empty array of queries', {
+            throw new ValidationError('batch requires a non-empty array of queries', {
                 field: 'queries',
                 value: queries,
             });
         }
-        const resolution = this.resolveTransport('batchQuery', options.transport);
+        const operation = 'sql.batch';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, BATCH_PROFILE, requestOptions.transport);
         const startedAt = Date.now();
         const started = performance.now();
-        const results = await mapWithConcurrency(queries, this.batchConcurrency, async (query) => {
-            if (resolution.transport === 'wire') {
-                return this.runWireQuery(query, options);
-            }
-            return this.runHttpQuery('/query', {
-                query,
-                entity_types: options.entityTypes,
-                capabilities: options.capabilities,
-            }, options);
-        });
-        return this.buildEnvelope('batchQuery', { results }, { ...resolution, emulated: true }, startedAt, started);
+        let data;
+        if (resolution.transport === 'grpc' && !resolution.emulated) {
+            data = normalizeBatchQueryData(await this.runGrpc('BatchQuery', { queries }, requestOptions));
+        }
+        else {
+            const concurrency = Math.max(1, requestOptions.concurrency ?? this.batchConcurrency);
+            const results = await mapWithConcurrency(queries, concurrency, async (query) => {
+                if (resolution.transport === 'wire') {
+                    return normalizeQueryData(await this.runWireQuery(query, requestOptions));
+                }
+                return normalizeQueryData(await this.runHttpPost('/query', {
+                    query,
+                    entity_types: requestOptions.entityTypes,
+                    capabilities: requestOptions.capabilities,
+                }, requestOptions));
+            });
+            data = { results };
+        }
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeCollectionsList(options) {
+        const operation = 'collections.list';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizeCollectionsData(await this.runGrpc('Collections', {}, requestOptions))
+            : normalizeCollectionsData(await this.runHttpGet('/collections', requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeCollectionCreate(options) {
+        const name = ensureNonEmptyString(options.name, 'name', 'create requires a collection name');
+        const operation = 'collections.create';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const payload = { name };
+        if (requestOptions.ttl !== undefined)
+            payload.ttl = requestOptions.ttl;
+        if (requestOptions.ttlMs !== undefined)
+            payload.ttl_ms = requestOptions.ttlMs;
+        const data = resolution.transport === 'grpc'
+            ? normalizePayloadValue(await this.runGrpc('CreateCollection', {
+                payload_json: stringifyJson(payload, 'collection payload'),
+            }, requestOptions))
+            : normalizePayloadValue(await this.runHttpPost('/collections', payload, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeCollectionDescribe(options) {
+        const name = ensureNonEmptyString(options.name, 'name', 'describe requires a collection name');
+        const operation = 'collections.describe';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizePayloadValue(await this.runGrpc('DescribeCollection', {
+                collection: name,
+            }, requestOptions))
+            : normalizePayloadValue(await this.runHttpGet(`/collections/${encodeURIComponent(name)}`, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeCollectionDrop(options) {
+        const name = ensureNonEmptyString(options.name, 'name', 'drop requires a collection name');
+        const operation = 'collections.drop';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizeOperationData(await this.runGrpc('DropCollection', {
+                payload_json: stringifyJson({ name }, 'drop collection payload'),
+            }, requestOptions), {
+                dropped: name,
+                message: `dropped collection ${name}`,
+            })
+            : normalizeOperationData(await this.runHttpDelete(`/collections/${encodeURIComponent(name)}`, requestOptions), {
+                dropped: name,
+            });
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeIndexesList(options) {
+        const operation = 'indexes.list';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizePayloadValue(await this.runGrpc('Indexes', {
+                collection: requestOptions.collection ?? '',
+            }, requestOptions))
+            : normalizePayloadValue(await this.runHttpGet(requestOptions.collection
+                ? `/collections/${encodeURIComponent(requestOptions.collection)}/indexes`
+                : '/indexes', requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
     }
-    async scan(params) {
-        if (!params.collection || !params.collection.trim()) {
-            throw new ValidationError('scan requires a collection name', {
-                field: 'collection',
-                value: params.collection,
+    async executeIndexesStatuses(options) {
+        const operation = 'indexes.statuses';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizePayloadValue(await this.runGrpc('IndexStatuses', {}, requestOptions))
+            : normalizePayloadValue(await this.runHttpGet('/catalog/indexes/status', requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeIndexCreate(options) {
+        const name = ensureNonEmptyString(options.name, 'name', 'create requires an index name');
+        const collection = ensureNonEmptyString(options.collection, 'collection', 'create requires a collection name');
+        if (!Array.isArray(options.columns) || options.columns.length === 0) {
+            throw new ValidationError('create requires at least one column', {
+                field: 'columns',
+                value: options.columns,
             });
         }
-        const resolution = this.resolveTransport('scan', params.transport);
+        const unique = options.unique ? 'UNIQUE ' : '';
+        const method = options.method ? ` USING ${options.method}` : '';
+        const columns = options.columns.map(escapeSqlIdentifier).join(', ');
+        const query = `CREATE ${unique}INDEX IF NOT EXISTS ${escapeSqlIdentifier(name)} ON ${escapeSqlIdentifier(collection)} (${columns})${method}`;
+        return await this.executeSqlQuery('indexes.create', query, options);
+    }
+    async executeIndexToggle(operation, pathAction, enabled, options) {
+        const name = ensureNonEmptyString(options.name, 'name', `${pathAction} requires an index name`);
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizePayloadValue(await this.runGrpc('SetIndexEnabled', { name, enabled }, requestOptions))
+            : normalizePayloadValue(await this.runHttpPost(`/indexes/${encodeURIComponent(name)}/${pathAction}`, {}, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeIndexWarmup(options) {
+        const name = ensureNonEmptyString(options.name, 'name', 'warmup requires an index name');
+        const operation = 'indexes.warmup';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizePayloadValue(await this.runGrpc('WarmupIndex', { name }, requestOptions))
+            : normalizePayloadValue(await this.runHttpPost(`/indexes/${encodeURIComponent(name)}/warmup`, {}, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeIndexesRebuild(options) {
+        const operation = 'indexes.rebuild';
+        const requestOptions = this.withResolvedTimeout(operation, options);
+        const resolution = this.resolveTransport(operation, CONTROL_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizePayloadValue(await this.runGrpc('RebuildIndexes', {
+                collection: requestOptions.collection ?? '',
+            }, requestOptions))
+            : normalizePayloadValue(await this.runHttpPost(requestOptions.collection
+                ? `/collections/${encodeURIComponent(requestOptions.collection)}/indexes/rebuild`
+                : '/indexes/rebuild', {}, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeRowsScan(request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'scan requires a collection name');
+        const operation = 'rows.scan';
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, ROW_SCAN_PROFILE, requestOptions.transport);
         const startedAt = Date.now();
         const started = performance.now();
-        const query = new URLSearchParams();
-        query.set('offset', String(Math.max(0, params.offset ?? 0)));
-        query.set('limit', String(Math.max(1, params.limit ?? 100)));
-        const data = await this.runHttpGet(`/collections/${encodeURIComponent(params.collection)}/scan?${query.toString()}`, params);
-        return this.buildEnvelope('scan', data, resolution, startedAt, started);
+        const offset = Math.max(0, requestOptions.offset ?? 0);
+        const limit = Math.max(1, requestOptions.limit ?? 100);
+        const data = resolution.transport === 'grpc'
+            ? normalizeScanData(await this.runGrpc('Scan', { collection, offset, limit }, requestOptions))
+            : normalizeScanData(await this.runHttpGet(`/collections/${encodeURIComponent(collection)}/scan?offset=${offset}&limit=${limit}`, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
     }
-    async bulkInsertRows(params) {
-        if (!params.collection || !params.collection.trim()) {
-            throw new ValidationError('bulkInsertRows requires a collection name', {
-                field: 'collection',
-                value: params.collection,
+    async executeRowCreate(request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'create requires a collection name');
+        if (!isPlainObject(request.payload) || !isPlainObject(request.payload.fields)) {
+            throw new ValidationError('rows.create requires payload.fields', {
+                field: 'payload',
+                value: request.payload,
             });
         }
-        if (!Array.isArray(params.items) || params.items.length === 0) {
-            throw new ValidationError('bulkInsertRows requires a non-empty items array', {
+        const operation = 'rows.create';
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, ROW_MUTATION_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizeEntityData(await this.runGrpc('CreateRow', {
+                collection,
+                payload_json: stringifyJson(requestOptions.payload, 'row payload'),
+            }, requestOptions))
+            : normalizeEntityData(await this.runHttpPost(`/collections/${encodeURIComponent(collection)}/rows`, requestOptions.payload, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeRowsBulkCreate(request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'bulkCreate requires a collection name');
+        if (!Array.isArray(request.items) || request.items.length === 0) {
+            throw new ValidationError('rows.bulkCreate requires a non-empty items array', {
                 field: 'items',
-                value: params.items,
+                value: request.items,
             });
         }
-        const resolution = this.resolveTransport('bulkInsertRows', params.transport);
+        for (const item of request.items) {
+            if (!isPlainObject(item) || !isPlainObject(item.fields)) {
+                throw new ValidationError('rows.bulkCreate items must contain a fields object', {
+                    field: 'items',
+                    value: item,
+                });
+            }
+        }
+        const operation = 'rows.bulkCreate';
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, ROW_BULK_PROFILE, requestOptions.transport);
         const startedAt = Date.now();
         const started = performance.now();
         let data;
         if (resolution.transport === 'wire') {
-            const payloads = params.items.map((item) => JSON.stringify(item));
-            const count = await this.runWireBulkInsert(params.collection, payloads, params);
-            data = { ok: true, count };
+            const count = await this.runWireBulkInsert(collection, requestOptions.items.map((item) => stringifyJson(item, 'row bulk item')), requestOptions);
+            data = {
+                ok: true,
+                count,
+            };
+        }
+        else if (resolution.transport === 'grpc') {
+            data = normalizeBulkEntityData(await this.runGrpc('BulkCreateRows', {
+                collection,
+                payload_json: requestOptions.items.map((item) => stringifyJson(item, 'row bulk item')),
+            }, requestOptions));
         }
         else {
-            data = await this.runHttpQuery(`/collections/${encodeURIComponent(params.collection)}/bulk/rows`, { items: params.items }, params);
+            data = normalizeBulkEntityData(await this.runHttpPost(`/collections/${encodeURIComponent(collection)}/bulk/rows`, { items: requestOptions.items }, requestOptions));
         }
-        return this.buildEnvelope('bulkInsertRows', data, resolution, startedAt, started);
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
     }
-    async bulkInsertBinary(params) {
-        if (!params.collection || !params.collection.trim()) {
-            throw new ValidationError('bulkInsertBinary requires a collection name', {
-                field: 'collection',
-                value: params.collection,
+    async executeRowPatch(request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'patch requires a collection name');
+        const id = toPositiveInteger(request.id, 'id', 0);
+        if (!isPlainObject(request.payload)) {
+            throw new ValidationError('patch requires a payload object', {
+                field: 'payload',
+                value: request.payload,
             });
         }
-        if (!Array.isArray(params.fieldNames) || params.fieldNames.length === 0) {
-            throw new ValidationError('bulkInsertBinary requires fieldNames', {
-                field: 'fieldNames',
-                value: params.fieldNames,
+        const operation = 'rows.patch';
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, ROW_MUTATION_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizeEntityData(await this.runGrpc('PatchEntity', {
+                collection,
+                id,
+                payload_json: stringifyJson(requestOptions.payload, 'patch payload'),
+            }, requestOptions))
+            : normalizeEntityData(await this.runHttpPatch(`/collections/${encodeURIComponent(collection)}/entities/${id}`, requestOptions.payload, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeRowDelete(request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'delete requires a collection name');
+        const id = toPositiveInteger(request.id, 'id', 0);
+        const operation = 'rows.delete';
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, ROW_MUTATION_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = resolution.transport === 'grpc'
+            ? normalizeOperationData(await this.runGrpc('DeleteEntity', { collection, id }, requestOptions), {
+                deleted: true,
+                id,
+            })
+            : normalizeOperationData(await this.runHttpDelete(`/collections/${encodeURIComponent(collection)}/entities/${id}`, requestOptions), {
+                deleted: true,
+                id,
             });
-        }
-        if (!Array.isArray(params.rows) || params.rows.length === 0) {
-            throw new ValidationError('bulkInsertBinary requires rows', {
-                field: 'rows',
-                value: params.rows,
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeEntityCreate(operation, grpcMethod, httpAction, request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'create requires a collection name');
+        if (!isPlainObject(request.payload)) {
+            throw new ValidationError('create requires a payload object', {
+                field: 'payload',
+                value: request.payload,
             });
         }
-        const hasTrueBinaryValues = params.rows.some((row) => row.some((value) => isBufferLike(value)));
-        if (hasTrueBinaryValues) {
-            throw new UnsupportedError('bulkInsertBinary byte values require native gRPC support, which is not implemented yet', { feature: 'reddb.bulkInsertBinary.bytes' });
-        }
-        const items = params.rows.map((row) => ({
-            fields: this.binaryRowToFields(params.fieldNames, row),
-        }));
-        const envelope = await this.bulkInsertRows({
-            collection: params.collection,
-            items,
-            transport: params.transport,
-            signal: params.signal,
-            timeout: params.timeout,
-        });
-        return {
-            ...envelope,
-            emulated: true,
-            metrics: {
-                ...envelope.metrics,
-                operation: 'bulkInsertBinary',
-                emulated: true,
-            },
-        };
-    }
-    async stats(options = {}) {
-        const resolution = this.resolveTransport('stats', options.transport);
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, ENTITY_MUTATION_PROFILE, requestOptions.transport);
         const startedAt = Date.now();
         const started = performance.now();
-        const data = await this.runHttpGet('/stats', options);
-        return this.buildEnvelope('stats', data, resolution, startedAt, started);
+        const data = resolution.transport === 'grpc'
+            ? normalizeEntityData(await this.runGrpc(grpcMethod, {
+                collection,
+                payload_json: stringifyJson(requestOptions.payload, `${operation} payload`),
+            }, requestOptions))
+            : normalizeEntityData(await this.runHttpPost(`/collections/${encodeURIComponent(collection)}/${httpAction}`, requestOptions.payload, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
     }
-    async ensureCollection(options) {
-        if (!options.name || !options.name.trim()) {
-            throw new ValidationError('ensureCollection requires a collection name', {
-                field: 'name',
-                value: options.name,
+    async executeBulkEntityCreate(operation, grpcMethod, httpAction, request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'bulkCreate requires a collection name');
+        if (!Array.isArray(request.items) || request.items.length === 0) {
+            throw new ValidationError('bulkCreate requires a non-empty items array', {
+                field: 'items',
+                value: request.items,
             });
         }
-        const resolution = this.resolveTransport('ensureCollection', options.transport);
+        for (const item of request.items) {
+            if (!isPlainObject(item)) {
+                throw new ValidationError('bulkCreate items must be objects', {
+                    field: 'items',
+                    value: item,
+                });
+            }
+        }
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, ENTITY_MUTATION_PROFILE, requestOptions.transport);
         const startedAt = Date.now();
         const started = performance.now();
-        const payload = { name: options.name };
-        if (options.ttl !== undefined)
-            payload.ttl = options.ttl;
-        if (options.ttlMs !== undefined)
-            payload.ttl_ms = options.ttlMs;
-        const data = await this.runHttpQuery('/collections', payload, options);
-        return this.buildEnvelope('ensureCollection', data, resolution, startedAt, started);
+        const data = resolution.transport === 'grpc'
+            ? normalizeBulkEntityData(await this.runGrpc(grpcMethod, {
+                collection,
+                payload_json: requestOptions.items.map((item) => stringifyJson(item, `${operation} item`)),
+            }, requestOptions))
+            : normalizeBulkEntityData(await this.runHttpPost(`/collections/${encodeURIComponent(collection)}/${httpAction}`, { items: requestOptions.items }, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
     }
-    async ensureIndex(options) {
-        if (!options.name || !options.name.trim()) {
-            throw new ValidationError('ensureIndex requires an index name', {
-                field: 'name',
-                value: options.name,
+    async executeVectorBulkInsertBinary(request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'bulkInsertBinary requires a collection name');
+        if (!Array.isArray(request.fieldNames) || request.fieldNames.length === 0) {
+            throw new ValidationError('bulkInsertBinary requires fieldNames', {
+                field: 'fieldNames',
+                value: request.fieldNames,
             });
         }
-        if (!options.collection || !options.collection.trim()) {
-            throw new ValidationError('ensureIndex requires a collection name', {
-                field: 'collection',
-                value: options.collection,
+        if (!Array.isArray(request.rows) || request.rows.length === 0) {
+            throw new ValidationError('bulkInsertBinary requires rows', {
+                field: 'rows',
+                value: request.rows,
             });
         }
-        if (!Array.isArray(options.columns) || options.columns.length === 0) {
-            throw new ValidationError('ensureIndex requires at least one column', {
-                field: 'columns',
-                value: options.columns,
-            });
+        const hasBytes = request.rows.some((row) => row.some((value) => isBufferLike(value)));
+        const profile = hasBytes
+            ? {
+                preferences: ['grpc'],
+                supported: { http: false, wire: false },
+            }
+            : {
+                preferences: ['wire', 'grpc', 'http'],
+                emulated: ['http'],
+            };
+        const operation = 'vectors.bulkInsertBinary';
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, profile, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        let data;
+        if (resolution.transport === 'wire') {
+            const count = await this.runWireBulkInsertBinary(collection, requestOptions.fieldNames, requestOptions.rows, requestOptions);
+            data = {
+                ok: true,
+                count,
+            };
         }
-        const unique = options.unique ? 'UNIQUE ' : '';
-        const method = options.method ? ` USING ${options.method}` : '';
-        const columns = options.columns.map(escapeSqlIdentifier).join(', ');
-        const query = `CREATE ${unique}INDEX IF NOT EXISTS ${escapeSqlIdentifier(options.name)} ON ${escapeSqlIdentifier(options.collection)} (${columns})${method}`;
-        return this.query(query, options);
+        else if (resolution.transport === 'grpc') {
+            data = normalizeBulkInsertData(await this.runGrpc('BulkInsertBinary', {
+                collection,
+                field_names: requestOptions.fieldNames,
+                rows: requestOptions.rows.map((row) => ({
+                    values: row.map((value) => toGrpcBinaryValue(value)),
+                })),
+            }, requestOptions));
+        }
+        else {
+            data = normalizeBulkInsertData(await this.runHttpPost(`/collections/${encodeURIComponent(collection)}/bulk/rows`, {
+                items: requestOptions.rows.map((row) => ({
+                    fields: rowToScalarFields(requestOptions.fieldNames, row),
+                })),
+            }, requestOptions));
+        }
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
     }
-    async warmupIndex(options) {
-        if (!options.name || !options.name.trim()) {
-            throw new ValidationError('warmupIndex requires an index name', {
-                field: 'name',
-                value: options.name,
+    async executeVectorSearch(operation, grpcMethod, httpAction, request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', `${operation} requires a collection name`);
+        if (!isPlainObject(request.payload)) {
+            throw new ValidationError(`${operation} requires a payload object`, {
+                field: 'payload',
+                value: request.payload,
             });
         }
-        const resolution = this.resolveTransport('warmupIndex', options.transport);
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, VECTOR_SEARCH_PROFILE, requestOptions.transport);
         const startedAt = Date.now();
         const started = performance.now();
-        const data = await this.runHttpQuery(`/indexes/${encodeURIComponent(options.name)}/warmup`, {}, options);
-        return this.buildEnvelope('warmupIndex', data, resolution, startedAt, started);
+        const data = resolution.transport === 'grpc'
+            ? normalizePayloadValue(await this.runGrpc(grpcMethod, {
+                collection,
+                payload_json: stringifyJson(requestOptions.payload, `${operation} payload`),
+            }, requestOptions))
+            : normalizePayloadValue(await this.runHttpPost(`/collections/${encodeURIComponent(collection)}/${httpAction}`, requestOptions.payload, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
     }
-    async close() {
-        if (this.wireClient) {
-            await this.wireClient.close();
+    async executeKvGet(request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'kv.get requires a collection name');
+        const key = ensureNonEmptyString(request.key, 'key', 'kv.get requires a key');
+        const operation = 'kv.get';
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, KV_HTTP_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = normalizeOperationData(await this.runHttpGet(`/collections/${encodeURIComponent(collection)}/kvs/${encodeURIComponent(key)}`, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeKvPut(request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'kv.put requires a collection name');
+        const key = ensureNonEmptyString(request.key, 'key', 'kv.put requires a key');
+        const operation = 'kv.put';
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, KV_HTTP_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = normalizeEntityData(await this.runHttpPut(`/collections/${encodeURIComponent(collection)}/kvs/${encodeURIComponent(key)}`, { value: requestOptions.value }, requestOptions));
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeKvDelete(request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'kv.delete requires a collection name');
+        const key = ensureNonEmptyString(request.key, 'key', 'kv.delete requires a key');
+        const operation = 'kv.delete';
+        const requestOptions = this.withResolvedTimeout(operation, request);
+        const resolution = this.resolveTransport(operation, KV_HTTP_PROFILE, requestOptions.transport);
+        const startedAt = Date.now();
+        const started = performance.now();
+        const data = normalizeOperationData(await this.runHttpDelete(`/collections/${encodeURIComponent(collection)}/kvs/${encodeURIComponent(key)}`, requestOptions), {
+            key,
+            deleted: true,
+        });
+        return this.buildEnvelope(operation, data, resolution, startedAt, started);
+    }
+    async executeKvList(request) {
+        const collection = ensureNonEmptyString(request.collection, 'collection', 'kv.list requires a collection name');
+        const limit = request.limit === undefined ? 100 : toPositiveInteger(request.limit, 'limit', 1);
+        const offset = request.offset === undefined ? 0 : toPositiveInteger(request.offset, 'offset', 0);
+        const order = request.order === 'desc' ? 'DESC' : 'ASC';
+        const where = request.prefix
+            ? ` WHERE key LIKE ${escapeSqlLiteral(`${request.prefix}%`)}`
+            : '';
+        const sql = `SELECT id, key, value FROM ${escapeSqlIdentifier(collection)}${where} ORDER BY key ${order} LIMIT ${limit} OFFSET ${offset}`;
+        const queryEnvelope = await this.executeSqlQuery('kv.list', sql, {
+            transport: request.transport,
+            signal: request.signal,
+            timeout: request.timeout,
+            entityTypes: request.entityTypes,
+            capabilities: request.capabilities,
+        });
+        const items = Array.isArray(queryEnvelope.data.result?.records)
+            ? queryEnvelope.data.result.records.map((record) => ({
+                ...record,
+                id: toSafeNumber(record.id),
+                key: typeof record.key === 'string' ? record.key : undefined,
+                value: record.value,
+            }))
+            : [];
+        return this.mapEnvelope(queryEnvelope, 'kv.list', {
+            items,
+            query: queryEnvelope.data,
+        });
+    }
+    resolveOperationTimeout(operation, override) {
+        if (override !== undefined) {
+            return override;
         }
+        const bucket = this.operationTimeoutBucket(operation);
+        const bucketTimeout = bucket ? this.operationTimeouts[bucket] : undefined;
+        return bucketTimeout ?? this.timeout;
     }
-    binaryRowToFields(fieldNames, row) {
-        if (row.length !== fieldNames.length) {
-            throw new ValidationError(`bulkInsertBinary row length ${row.length} does not match fieldNames length ${fieldNames.length}`, { field: 'rows', value: row });
+    withResolvedTimeout(operation, options) {
+        if (options.timeout !== undefined) {
+            return options;
         }
-        const fields = {};
-        for (let index = 0; index < fieldNames.length; index++) {
-            const fieldName = fieldNames[index];
-            const value = row[index];
-            if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-                fields[fieldName] = value;
-                continue;
-            }
-            if (isBufferLike(value)) {
-                throw new UnsupportedError('bulkInsertBinary emulation cannot safely serialize byte values without native gRPC support', { feature: 'reddb.bulkInsertBinary.bytes' });
+        return {
+            ...options,
+            timeout: this.resolveOperationTimeout(operation),
+        };
+    }
+    operationTimeoutBucket(operation) {
+        if (operation.startsWith('system.'))
+            return 'system';
+        if (operation === 'sql.batch')
+            return 'sqlBatch';
+        if (operation.startsWith('sql.'))
+            return 'sql';
+        if (operation === 'rows.scan')
+            return 'scan';
+        if (operation.startsWith('collections.'))
+            return 'ddl';
+        if (operation.startsWith('indexes.'))
+            return 'index';
+        if (operation === 'vectors.similar' || operation === 'vectors.ivfSearch')
+            return 'search';
+        if (operation.startsWith('kv.'))
+            return 'kv';
+        if (operation === 'rows.bulkCreate' ||
+            operation.endsWith('.bulkCreate') ||
+            operation === 'vectors.bulkInsertBinary') {
+            return 'bulk';
+        }
+        if (operation.startsWith('rows.') ||
+            operation.endsWith('.create') ||
+            operation.endsWith('.patch') ||
+            operation.endsWith('.delete')) {
+            return 'mutation';
+        }
+        return undefined;
+    }
+    resolveTransport(operation, profile, requestedTransport) {
+        const requested = requestedTransport ?? this.defaultTransport;
+        const available = {
+            http: this.httpClient !== null,
+            grpc: this.grpcClient !== null,
+            wire: this.wireClient !== null,
+        };
+        const supported = {
+            http: profile.supported?.http ?? true,
+            grpc: profile.supported?.grpc ?? true,
+            wire: profile.supported?.wire ?? true,
+        };
+        const canUse = (transport) => available[transport] && supported[transport];
+        const choosePreferred = () => profile.preferences.find((transport) => canUse(transport));
+        if (requested === 'auto') {
+            const chosen = choosePreferred();
+            if (!chosen) {
+                throw new UnsupportedError(`No RedDB transport is configured for ${operation}`, {
+                    feature: `reddb.${operation}`,
+                });
             }
-            throw new ValidationError(`Unsupported binary row value for field ${fieldName}`, {
-                field: fieldName,
-                value,
+            return {
+                transport: chosen,
+                requestedTransport: requested,
+                degradedFromRequestedTransport: false,
+                emulated: profile.emulated?.includes(chosen) ?? false,
+            };
+        }
+        if (canUse(requested)) {
+            return {
+                transport: requested,
+                requestedTransport: requested,
+                degradedFromRequestedTransport: false,
+                emulated: profile.emulated?.includes(requested) ?? false,
+            };
+        }
+        if (!this.allowTransportFallback) {
+            throw new UnsupportedError(`Transport ${requested} cannot satisfy ${operation}`, {
+                feature: `reddb.${operation}.${requested}`,
+            });
+        }
+        const chosen = choosePreferred();
+        if (!chosen) {
+            throw new UnsupportedError(`No RedDB transport is configured for ${operation}`, {
+                feature: `reddb.${operation}`,
             });
         }
-        return fields;
+        return {
+            transport: chosen,
+            requestedTransport: requested,
+            degradedFromRequestedTransport: chosen !== requested,
+            emulated: profile.emulated?.includes(chosen) ?? false,
+        };
     }
-    async runHttpQuery(path, payload, options) {
+    async runHttpPost(path, payload, options) {
         if (!this.httpClient) {
             throw new UnsupportedError('HTTP transport is not configured for this RedDB client', {
                 feature: 'reddb.http',
@@ -613,6 +1676,47 @@ export class RedDbClient {
         });
         return this.parseHttpResponse(response, path);
     }
+    async runHttpPut(path, payload, options) {
+        if (!this.httpClient) {
+            throw new UnsupportedError('HTTP transport is not configured for this RedDB client', {
+                feature: 'reddb.http',
+            });
+        }
+        const response = await this.httpClient.put(path, {
+            json: payload,
+            signal: options.signal,
+            timeout: options.timeout ?? this.timeout,
+            throwHttpErrors: false,
+        });
+        return this.parseHttpResponse(response, path);
+    }
+    async runHttpPatch(path, payload, options) {
+        if (!this.httpClient) {
+            throw new UnsupportedError('HTTP transport is not configured for this RedDB client', {
+                feature: 'reddb.http',
+            });
+        }
+        const response = await this.httpClient.patch(path, {
+            json: payload,
+            signal: options.signal,
+            timeout: options.timeout ?? this.timeout,
+            throwHttpErrors: false,
+        });
+        return this.parseHttpResponse(response, path);
+    }
+    async runHttpDelete(path, options) {
+        if (!this.httpClient) {
+            throw new UnsupportedError('HTTP transport is not configured for this RedDB client', {
+                feature: 'reddb.http',
+            });
+        }
+        const response = await this.httpClient.delete(path, {
+            signal: options.signal,
+            timeout: options.timeout ?? this.timeout,
+            throwHttpErrors: false,
+        });
+        return this.parseHttpResponse(response, path);
+    }
     async runHttpGet(path, options) {
         if (!this.httpClient) {
             throw new UnsupportedError('HTTP transport is not configured for this RedDB client', {
@@ -656,6 +1760,14 @@ export class RedDbClient {
             throw new ParseError(`Failed to parse RedDB HTTP response for ${path}: ${error instanceof Error ? error.message : String(error)}`, { format: 'json' });
         }
     }
+    async runGrpc(methodName, request, options) {
+        if (!this.grpcClient) {
+            throw new UnsupportedError('gRPC transport is not configured for this RedDB client', {
+                feature: 'reddb.grpc',
+            });
+        }
+        return await this.grpcClient.unary(methodName, request, options);
+    }
     async runWireQuery(query, options) {
         if (options.signal) {
             throw new UnsupportedError('AbortSignal is not supported for RedDB wire operations', {
@@ -682,121 +1794,18 @@ export class RedDbClient {
         }
         return await this.wireClient.bulkInsert(collection, payloads, options.timeout ?? this.timeout);
     }
-    resolveTransport(operation, requestedTransport) {
-        const requested = requestedTransport ?? this.defaultTransport;
-        const hasHttp = this.httpClient !== null;
-        const hasWire = this.wireClient !== null;
-        const requireHttp = () => {
-            if (hasHttp) {
-                return {
-                    transport: 'http',
-                    requestedTransport: requested,
-                    degradedFromRequestedTransport: requested !== 'auto' && requested !== 'http',
-                    emulated: false,
-                };
-            }
-            throw new UnsupportedError(`Operation ${operation} requires the RedDB HTTP API`, {
-                feature: `reddb.${operation}.http`,
-            });
-        };
-        const preferWireThenHttp = () => {
-            if (hasWire) {
-                return {
-                    transport: 'wire',
-                    requestedTransport: requested,
-                    degradedFromRequestedTransport: requested === 'grpc' || requested === 'http',
-                    emulated: false,
-                };
-            }
-            if (hasHttp) {
-                return {
-                    transport: 'http',
-                    requestedTransport: requested,
-                    degradedFromRequestedTransport: requested === 'grpc' || requested === 'wire',
-                    emulated: false,
-                };
-            }
-            throw new UnsupportedError(`No RedDB transport is configured for ${operation}`, {
-                feature: `reddb.${operation}`,
-            });
-        };
-        const preferHttpThenWire = () => {
-            if (hasHttp) {
-                return {
-                    transport: 'http',
-                    requestedTransport: requested,
-                    degradedFromRequestedTransport: requested === 'grpc' || requested === 'wire',
-                    emulated: false,
-                };
-            }
-            if (hasWire) {
-                return {
-                    transport: 'wire',
-                    requestedTransport: requested,
-                    degradedFromRequestedTransport: requested === 'grpc' || requested === 'http',
-                    emulated: false,
-                };
-            }
-            throw new UnsupportedError(`No RedDB transport is configured for ${operation}`, {
-                feature: `reddb.${operation}`,
-            });
-        };
-        const requiresHttp = new Set(['scan', 'stats', 'ensureCollection', 'warmupIndex']);
-        const prefersWire = new Set(['query', 'mutateQuery', 'explainQuery', 'batchQuery', 'bulkInsertRows', 'bulkInsertBinary', 'ensureIndex']);
-        if (requested === 'auto') {
-            return prefersWire.has(operation) ? preferWireThenHttp() : requireHttp();
-        }
-        if (requested === 'http') {
-            if (requiresHttp.has(operation)) {
-                return requireHttp();
-            }
-            if (hasHttp) {
-                return {
-                    transport: 'http',
-                    requestedTransport: requested,
-                    degradedFromRequestedTransport: false,
-                    emulated: false,
-                };
-            }
-            if (this.allowTransportFallback && hasWire) {
-                return {
-                    transport: 'wire',
-                    requestedTransport: requested,
-                    degradedFromRequestedTransport: true,
-                    emulated: false,
-                };
-            }
-            throw new UnsupportedError(`HTTP transport is unavailable for ${operation}`, {
-                feature: `reddb.${operation}.http`,
-            });
-        }
-        if (requested === 'wire') {
-            if (hasWire && !requiresHttp.has(operation)) {
-                return {
-                    transport: 'wire',
-                    requestedTransport: requested,
-                    degradedFromRequestedTransport: false,
-                    emulated: false,
-                };
-            }
-            if (this.allowTransportFallback && hasHttp) {
-                return {
-                    transport: 'http',
-                    requestedTransport: requested,
-                    degradedFromRequestedTransport: true,
-                    emulated: false,
-                };
-            }
-            throw new UnsupportedError(`Wire transport cannot satisfy ${operation}`, {
-                feature: `reddb.${operation}.wire`,
+    async runWireBulkInsertBinary(collection, fieldNames, rows, options) {
+        if (options.signal) {
+            throw new UnsupportedError('AbortSignal is not supported for RedDB wire operations', {
+                feature: 'reddb.wire.signal',
             });
         }
-        if (!this.allowTransportFallback) {
-            throw new UnsupportedError(`gRPC transport is not implemented for ${operation}`, {
-                feature: `reddb.${operation}.grpc`,
+        if (!this.wireClient) {
+            throw new UnsupportedError('Wire transport is not configured for this RedDB client', {
+                feature: 'reddb.wire',
             });
         }
-        return requiresHttp.has(operation) ? preferHttpThenWire() : preferWireThenHttp();
+        return await this.wireClient.bulkInsertBinary(collection, fieldNames, rows, options.timeout ?? this.timeout);
     }
     buildEnvelope(operation, data, resolution, startedAt, started) {
         const queryStats = buildQueryStats(data);
@@ -818,6 +1827,83 @@ export class RedDbClient {
             },
         };
     }
+    mapEnvelope(envelope, operation, data) {
+        return {
+            ...envelope,
+            data,
+            metrics: {
+                ...envelope.metrics,
+                operation,
+            },
+        };
+    }
+}
+function toGrpcBinaryValue(value) {
+    if (value === null) {
+        return {};
+    }
+    if (typeof value === 'string') {
+        return { text_value: value };
+    }
+    if (typeof value === 'boolean') {
+        return { bool_value: value };
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new ValidationError('bulkInsertBinary number values must be finite', {
+                field: 'rows',
+                value,
+            });
+        }
+        return Number.isInteger(value)
+            ? { int_value: value }
+            : { float_value: value };
+    }
+    if (typeof value === 'bigint') {
+        return { int_value: value.toString() };
+    }
+    if (isBufferLike(value)) {
+        return { blob_value: Buffer.from(value) };
+    }
+    throw new ValidationError('Unsupported bulkInsertBinary value type', {
+        field: 'rows',
+        value,
+    });
+}
+function rowToScalarFields(fieldNames, row) {
+    if (row.length !== fieldNames.length) {
+        throw new ValidationError(`bulkInsertBinary row length ${row.length} does not match fieldNames length ${fieldNames.length}`, { field: 'rows', value: row });
+    }
+    const fields = {};
+    for (let index = 0; index < fieldNames.length; index++) {
+        const fieldName = fieldNames[index];
+        const value = row[index];
+        if (value === null ||
+            typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean' ||
+            typeof value === 'bigint') {
+            if (typeof value === 'bigint') {
+                const numeric = Number(value);
+                if (!Number.isSafeInteger(numeric)) {
+                    throw new UnsupportedError('bulkInsertBinary bigint values outside the safe integer range require gRPC transport', { feature: 'reddb.http.bulkInsertBinary.bigint' });
+                }
+                fields[fieldName] = numeric;
+            }
+            else {
+                fields[fieldName] = value;
+            }
+            continue;
+        }
+        if (isBufferLike(value)) {
+            throw new UnsupportedError('bulkInsertBinary byte values require gRPC transport; HTTP emulation would be lossy', { feature: 'reddb.http.bulkInsertBinary.bytes' });
+        }
+        throw new ValidationError(`Unsupported bulkInsertBinary value for field ${fieldName}`, {
+            field: fieldName,
+            value,
+        });
+    }
+    return fields;
 }
 export function createRedDbClient(options = {}) {
     return new RedDbClient(options);