@geodedb/client 1.0.0-alpha.11

package/dist/index.mjs

@@ -0,0 +1,5101 @@
+import Decimal from 'decimal.js-light';
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+function isDriverError(err) {
+  return err instanceof DriverError;
+}
+function isGeodeError(err) {
+  return err instanceof DriverError || err instanceof TransportError || err instanceof ConfigError || err instanceof SecurityError || err instanceof StateError;
+}
+function isRetryableError(err) {
+  if (isGeodeError(err)) {
+    return err.isRetryable;
+  }
+  return false;
+}
+var StatusClass, DriverError, TransportError, ConfigError, SecurityError, StateError, ErrClosed, ErrQueryInProgress, ErrTxInProgress, ErrNoTx, ErrTxDone, ErrRowsClosed, ErrBadConn;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    StatusClass = {
+      SUCCESS: "00000",
+      WARNING: "01000",
+      NO_DATA: "02000",
+      TRANSACTION_STATE: "25000",
+      AUTH: "28000",
+      SERIALIZATION: "40001",
+      DEADLOCK: "40502",
+      SYNTAX: "42000",
+      CONSTRAINT: "23000",
+      DUPLICATE: "42P07",
+      INVALID_PARAM: "22023",
+      SYSTEM: "58000"
+    };
+    DriverError = class _DriverError extends Error {
+      statusClass;
+      subclass;
+      code;
+      anchor;
+      additional;
+      findings;
+      constructor(options) {
+        const msg = options.message ? `geode: ${options.code}: ${options.message}` : `geode: ${options.code}`;
+        super(msg);
+        this.name = "DriverError";
+        this.statusClass = options.statusClass;
+        this.subclass = options.subclass;
+        this.code = options.code;
+        this.anchor = options.anchor;
+        this.additional = options.additional ?? [];
+        this.findings = options.findings ?? [];
+        Object.setPrototypeOf(this, _DriverError.prototype);
+      }
+      get isRetryable() {
+        return this.statusClass === StatusClass.SERIALIZATION || this.statusClass === StatusClass.DEADLOCK;
+      }
+    };
+    TransportError = class _TransportError extends Error {
+      statusClass = StatusClass.SYSTEM;
+      operation;
+      address;
+      cause;
+      constructor(options) {
+        const addr = options.address ? ` to ${options.address}` : "";
+        const causeMsg = options.cause ? `: ${options.cause.message}` : "";
+        super(`geode: transport ${options.operation}${addr}${causeMsg}`);
+        this.name = "TransportError";
+        this.operation = options.operation;
+        this.address = options.address;
+        this.cause = options.cause;
+        Object.setPrototypeOf(this, _TransportError.prototype);
+      }
+      get isRetryable() {
+        return true;
+      }
+    };
+    ConfigError = class _ConfigError extends Error {
+      statusClass = StatusClass.INVALID_PARAM;
+      field;
+      value;
+      constructor(options) {
+        const valStr = options.value !== void 0 ? `=${JSON.stringify(options.value)}` : "";
+        super(`geode: config ${options.field}${valStr}: ${options.message}`);
+        this.name = "ConfigError";
+        this.field = options.field;
+        this.value = options.value;
+        Object.setPrototypeOf(this, _ConfigError.prototype);
+      }
+      get isRetryable() {
+        return false;
+      }
+    };
+    SecurityError = class _SecurityError extends Error {
+      statusClass = StatusClass.AUTH;
+      type;
+      cause;
+      constructor(options) {
+        const causeMsg = options.cause ? `: ${options.cause.message}` : "";
+        super(`geode: security ${options.type}: ${options.message}${causeMsg}`);
+        this.name = "SecurityError";
+        this.type = options.type;
+        this.cause = options.cause;
+        Object.setPrototypeOf(this, _SecurityError.prototype);
+      }
+      get isRetryable() {
+        return false;
+      }
+    };
+    StateError = class _StateError extends Error {
+      statusClass = StatusClass.TRANSACTION_STATE;
+      currentState;
+      operation;
+      constructor(options) {
+        const msg = options.message ? `geode: state error: ${options.operation} (state=${options.currentState}): ${options.message}` : `geode: state error: ${options.operation} (state=${options.currentState})`;
+        super(msg);
+        this.name = "StateError";
+        this.currentState = options.currentState;
+        this.operation = options.operation;
+        Object.setPrototypeOf(this, _StateError.prototype);
+      }
+      get isRetryable() {
+        return false;
+      }
+    };
+    ErrClosed = new Error("geode: connection closed");
+    ErrQueryInProgress = new Error("geode: query already in progress");
+    ErrTxInProgress = new Error("geode: transaction already in progress");
+    ErrNoTx = new Error("geode: no transaction in progress");
+    ErrTxDone = new Error("geode: transaction already committed or rolled back");
+    ErrRowsClosed = new Error("geode: rows closed");
+    ErrBadConn = new Error("geode: bad connection");
+  }
+});
+
+// src/config.ts
+function defaultConfig() {
+  return {
+    host: "localhost",
+    port: DEFAULT_PORT,
+    pageSize: DEFAULT_PAGE_SIZE,
+    helloName: DEFAULT_HELLO_NAME,
+    helloVersion: DEFAULT_HELLO_VERSION,
+    conformance: DEFAULT_CONFORMANCE,
+    connectTimeout: 3e4,
+    requestTimeout: 12e4,
+    keepAliveInterval: 1e4,
+    maxIdleTime: 3e4
+  };
+}
+function parseDSN(dsn) {
+  const cfg = defaultConfig();
+  if (process.env["GEODE_HOST"]) {
+    cfg.host = process.env["GEODE_HOST"];
+  }
+  if (process.env["GEODE_PORT"]) {
+    const port = parseInt(process.env["GEODE_PORT"], 10);
+    if (!isNaN(port)) {
+      cfg.port = port;
+    }
+  }
+  if (process.env["GEODE_TLS_CA"]) {
+    cfg.tlsCA = process.env["GEODE_TLS_CA"];
+  }
+  if (process.env["GEODE_USERNAME"]) {
+    cfg.username = process.env["GEODE_USERNAME"];
+  }
+  if (process.env["GEODE_PASSWORD"]) {
+    cfg.password = process.env["GEODE_PASSWORD"];
+  }
+  dsn = dsn.trim();
+  if (!dsn) {
+    return cfg;
+  }
+  if (dsn.startsWith("geode://")) {
+    return parseURLDSN(dsn, cfg);
+  }
+  return parseSimpleDSN(dsn, cfg);
+}
+function parseURLDSN(dsn, cfg) {
+  let url;
+  try {
+    url = new URL(dsn);
+  } catch {
+    throw new ConfigError({
+      field: "dsn",
+      value: dsn,
+      message: "invalid URL format"
+    });
+  }
+  if (!url.hostname) {
+    throw new ConfigError({
+      field: "host",
+      message: "host is required"
+    });
+  }
+  cfg.host = url.hostname;
+  if (url.port) {
+    cfg.port = parseInt(url.port, 10);
+  }
+  if (url.username) {
+    cfg.username = decodeURIComponent(url.username);
+  }
+  if (url.password) {
+    cfg.password = decodeURIComponent(url.password);
+  }
+  applyQueryParams(url.searchParams, cfg);
+  return cfg;
+}
+function parseSimpleDSN(dsn, cfg) {
+  let queryStr = "";
+  const queryIdx = dsn.indexOf("?");
+  if (queryIdx >= 0) {
+    queryStr = dsn.slice(queryIdx + 1);
+    dsn = dsn.slice(0, queryIdx);
+  }
+  if (dsn) {
+    const result = parseHostPort(dsn);
+    cfg.host = result.host;
+    cfg.port = result.port;
+  }
+  if (queryStr) {
+    const params = new URLSearchParams(queryStr);
+    applyQueryParams(params, cfg);
+  }
+  return cfg;
+}
+function parseHostPort(addr) {
+  if (addr.startsWith("[")) {
+    const closeBracket = addr.indexOf("]");
+    if (closeBracket === -1) {
+      throw new ConfigError({
+        field: "host",
+        value: addr,
+        message: "invalid IPv6 address format"
+      });
+    }
+    const host2 = addr.slice(1, closeBracket);
+    const rest = addr.slice(closeBracket + 1);
+    if (rest.startsWith(":")) {
+      const port2 = parseInt(rest.slice(1), 10);
+      if (isNaN(port2)) {
+        throw new ConfigError({
+          field: "port",
+          value: rest.slice(1),
+          message: "must be a valid port number"
+        });
+      }
+      return { host: host2, port: port2 };
+    }
+    return { host: host2, port: DEFAULT_PORT };
+  }
+  const lastColon = addr.lastIndexOf(":");
+  if (lastColon === -1) {
+    return { host: addr, port: DEFAULT_PORT };
+  }
+  if (addr.indexOf(":") !== lastColon) {
+    return { host: addr, port: DEFAULT_PORT };
+  }
+  const host = addr.slice(0, lastColon);
+  const portStr = addr.slice(lastColon + 1);
+  const port = parseInt(portStr, 10);
+  if (isNaN(port)) {
+    throw new ConfigError({
+      field: "port",
+      value: portStr,
+      message: "must be a valid port number"
+    });
+  }
+  if (!host) {
+    throw new ConfigError({
+      field: "host",
+      message: "host is required"
+    });
+  }
+  return { host, port };
+}
+function applyQueryParams(params, cfg) {
+  for (const [key, value] of params) {
+    switch (key) {
+      case "page_size": {
+        const n = parseInt(value, 10);
+        if (isNaN(n) || n <= 0) {
+          throw new ConfigError({
+            field: "page_size",
+            value,
+            message: "must be a positive integer"
+          });
+        }
+        if (n > MAX_PAGE_SIZE) {
+          throw new ConfigError({
+            field: "page_size",
+            value,
+            message: `must not exceed ${MAX_PAGE_SIZE}`
+          });
+        }
+        cfg.pageSize = n;
+        break;
+      }
+      case "hello_name":
+        if (!value) {
+          throw new ConfigError({
+            field: "hello_name",
+            message: "cannot be empty"
+          });
+        }
+        cfg.helloName = value;
+        break;
+      case "hello_ver":
+        if (!value) {
+          throw new ConfigError({
+            field: "hello_ver",
+            message: "cannot be empty"
+          });
+        }
+        cfg.helloVersion = value;
+        break;
+      case "conformance":
+        cfg.conformance = value;
+        break;
+      case "username":
+      case "user":
+        cfg.username = value;
+        break;
+      case "password":
+      case "pass":
+        cfg.password = value;
+        break;
+      case "ca":
+        cfg.tlsCA = value;
+        break;
+      case "cert":
+        cfg.tlsCert = value;
+        break;
+      case "key":
+        cfg.tlsKey = value;
+        break;
+      case "insecure":
+        cfg.insecureSkipVerify = value === "true" || value === "1";
+        break;
+      case "server_name":
+        cfg.serverName = value;
+        break;
+      case "connect_timeout": {
+        const n = parseInt(value, 10);
+        if (!isNaN(n) && n > 0) {
+          cfg.connectTimeout = n;
+        }
+        break;
+      }
+      case "request_timeout": {
+        const n = parseInt(value, 10);
+        if (!isNaN(n) && n > 0) {
+          cfg.requestTimeout = n;
+        }
+        break;
+      }
+    }
+  }
+  if (cfg.tlsCert && !cfg.tlsKey || !cfg.tlsCert && cfg.tlsKey) {
+    throw new ConfigError({
+      field: "tls",
+      message: "both cert and key must be provided for mTLS"
+    });
+  }
+}
+function validateConfig(cfg) {
+  if (!cfg.host) {
+    throw new ConfigError({
+      field: "host",
+      message: "host is required"
+    });
+  }
+  if (!cfg.port || cfg.port < 1 || cfg.port > 65535) {
+    throw new ConfigError({
+      field: "port",
+      value: String(cfg.port),
+      message: "must be a valid port number (1-65535)"
+    });
+  }
+  if (cfg.pageSize <= 0) {
+    throw new ConfigError({
+      field: "pageSize",
+      value: String(cfg.pageSize),
+      message: "must be positive"
+    });
+  }
+  if (cfg.pageSize > MAX_PAGE_SIZE) {
+    throw new ConfigError({
+      field: "pageSize",
+      value: String(cfg.pageSize),
+      message: `must not exceed ${MAX_PAGE_SIZE}`
+    });
+  }
+}
+function getAddress(cfg) {
+  if (cfg.host.includes(":")) {
+    return `[${cfg.host}]:${cfg.port}`;
+  }
+  return `${cfg.host}:${cfg.port}`;
+}
+function cloneConfig(cfg) {
+  return { ...cfg };
+}
+var DEFAULT_PORT, DEFAULT_PAGE_SIZE, DEFAULT_HELLO_NAME, DEFAULT_HELLO_VERSION, DEFAULT_CONFORMANCE, MAX_QUERY_LENGTH, MAX_PAGE_SIZE;
+var init_config = __esm({
+  "src/config.ts"() {
+    init_errors();
+    DEFAULT_PORT = 3141;
+    DEFAULT_PAGE_SIZE = 1e3;
+    DEFAULT_HELLO_NAME = "geode-nodejs";
+    DEFAULT_HELLO_VERSION = "1.0.0";
+    DEFAULT_CONFORMANCE = "min";
+    MAX_QUERY_LENGTH = 1 << 20;
+    MAX_PAGE_SIZE = 1e5;
+  }
+});
+function parseGQLType(typeStr) {
+  const upper = typeStr.toUpperCase();
+  switch (upper) {
+    case "INT":
+    case "INTEGER":
+    case "BIGINT":
+      return "INT";
+    case "FLOAT":
+    case "DOUBLE":
+    case "REAL":
+      return "FLOAT";
+    case "DECIMAL":
+    case "NUMERIC":
+      return "DECIMAL";
+    case "STRING":
+    case "VARCHAR":
+    case "TEXT":
+      return "STRING";
+    case "BOOL":
+    case "BOOLEAN":
+      return "BOOL";
+    case "NULL":
+      return "NULL";
+    case "LIST":
+    case "ARRAY":
+      return "ARRAY";
+    case "MAP":
+    case "RECORD":
+    case "OBJECT":
+      return "OBJECT";
+    case "NODE":
+      return "NODE";
+    case "EDGE":
+    case "RELATIONSHIP":
+      return "EDGE";
+    case "PATH":
+      return "PATH";
+    case "BYTEA":
+    case "BINARY":
+      return "BYTEA";
+    case "DATE":
+      return "DATE";
+    case "TIME":
+      return "TIME";
+    case "TIMETZ":
+    case "TIME WITH TIME ZONE":
+      return "TIMETZ";
+    case "TIMESTAMP":
+      return "TIMESTAMP";
+    case "TIMESTAMPTZ":
+    case "TIMESTAMP WITH TIME ZONE":
+      return "TIMESTAMPTZ";
+    case "INTERVAL":
+      return "INTERVAL";
+    case "JSON":
+      return "JSON";
+    case "JSONB":
+      return "JSONB";
+    case "XML":
+      return "XML";
+    case "UUID":
+      return "UUID";
+    case "URL":
+      return "URL";
+    case "DOMAIN":
+      return "DOMAIN";
+    case "ENUM":
+      return "ENUM";
+    case "BIT":
+    case "VARBIT":
+      return "BIT_STRING";
+    default:
+      if (upper.includes("RANGE")) {
+        return "RANGE";
+      }
+      return "UNKNOWN";
+  }
+}
+function fromJSON(value, typeHint) {
+  if (value === null || value === void 0) {
+    return GQLValue.null();
+  }
+  if (typeHint) {
+    return convertWithType(value, typeHint);
+  }
+  if (typeof value === "boolean") {
+    return GQLValue.bool(value);
+  }
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) {
+      return GQLValue.int(value);
+    }
+    return GQLValue.float(value);
+  }
+  if (typeof value === "bigint") {
+    return GQLValue.int(value);
+  }
+  if (typeof value === "string") {
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)) {
+      return GQLValue.uuid(value);
+    }
+    if (/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2})?/.test(value)) {
+      const date = new Date(value);
+      if (!isNaN(date.getTime())) {
+        return GQLValue.timestamp(date);
+      }
+    }
+    return GQLValue.string(value);
+  }
+  if (Array.isArray(value)) {
+    return GQLValue.array(value.map((v) => fromJSON(v)));
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    if ("id" in obj && "labels" in obj && "properties" in obj) {
+      return GQLValue.node(obj);
+    }
+    if ("id" in obj && "type" in obj && "startNode" in obj && "endNode" in obj) {
+      return GQLValue.edge(obj);
+    }
+    if ("nodes" in obj && "edges" in obj && Array.isArray(obj.nodes)) {
+      return GQLValue.path(obj);
+    }
+    const map = /* @__PURE__ */ new Map();
+    for (const [k, v] of Object.entries(obj)) {
+      map.set(k, fromJSON(v));
+    }
+    return GQLValue.object(map);
+  }
+  return GQLValue.unknown(value);
+}
+function convertWithType(value, type) {
+  switch (type) {
+    case "NULL":
+      return GQLValue.null();
+    case "BOOL":
+      return GQLValue.bool(Boolean(value));
+    case "INT":
+      if (typeof value === "number") {
+        return GQLValue.int(value);
+      }
+      if (typeof value === "bigint") {
+        return GQLValue.int(value);
+      }
+      if (typeof value === "string") {
+        return GQLValue.int(BigInt(value));
+      }
+      return GQLValue.int(0);
+    case "FLOAT":
+      return GQLValue.float(Number(value));
+    case "DECIMAL":
+      return GQLValue.decimal(String(value));
+    case "STRING":
+      return GQLValue.string(String(value));
+    case "UUID":
+      return GQLValue.uuid(String(value));
+    case "BYTEA":
+      if (value instanceof Uint8Array) {
+        return GQLValue.bytes(value);
+      }
+      if (typeof value === "string") {
+        return GQLValue.bytes(Buffer.from(value, "base64"));
+      }
+      return GQLValue.bytes(new Uint8Array());
+    case "DATE":
+      return GQLValue.date(value instanceof Date ? value : new Date(String(value)));
+    case "TIME":
+    case "TIMETZ":
+      return GQLValue.time(value instanceof Date ? value : new Date(String(value)));
+    case "TIMESTAMP":
+    case "TIMESTAMPTZ":
+      return GQLValue.timestamp(value instanceof Date ? value : new Date(String(value)));
+    case "JSON":
+    case "JSONB":
+      return GQLValue.json(value);
+    case "ARRAY":
+      if (Array.isArray(value)) {
+        return GQLValue.array(value.map((v) => fromJSON(v)));
+      }
+      return GQLValue.array([]);
+    case "OBJECT":
+      return fromJSON(value);
+    case "NODE":
+      return GQLValue.node(value);
+    case "EDGE":
+      return GQLValue.edge(value);
+    case "PATH":
+      return GQLValue.path(value);
+    default:
+      return fromJSON(value);
+  }
+}
+function parseRow(raw, columns) {
+  const row = /* @__PURE__ */ new Map();
+  for (const col of columns) {
+    const value = raw[col.name];
+    row.set(col.name, fromJSON(value, col.kind));
+  }
+  return row;
+}
+function rowToObject(row) {
+  const obj = {};
+  for (const [key, value] of row) {
+    obj[key] = value.toJS();
+  }
+  return obj;
+}
+var GQLValue;
+var init_types = __esm({
+  "src/types.ts"() {
+    GQLValue = class _GQLValue {
+      kind;
+      _intValue = 0n;
+      _floatValue = 0;
+      _boolValue = false;
+      _stringValue = "";
+      _decimalValue;
+      _arrayValue = [];
+      _objectValue = /* @__PURE__ */ new Map();
+      _bytesValue = new Uint8Array();
+      _dateValue;
+      _rangeValue;
+      _nodeValue;
+      _edgeValue;
+      _pathValue;
+      _rawValue;
+      constructor(kind) {
+        this.kind = kind;
+      }
+      // Factory methods
+      static null() {
+        return new _GQLValue("NULL");
+      }
+      static bool(value) {
+        const v = new _GQLValue("BOOL");
+        v._boolValue = value;
+        return v;
+      }
+      static int(value) {
+        const v = new _GQLValue("INT");
+        v._intValue = typeof value === "bigint" ? value : BigInt(Math.trunc(value));
+        return v;
+      }
+      static float(value) {
+        const v = new _GQLValue("FLOAT");
+        v._floatValue = value;
+        return v;
+      }
+      static string(value) {
+        const v = new _GQLValue("STRING");
+        v._stringValue = value;
+        return v;
+      }
+      static decimal(value) {
+        const v = new _GQLValue("DECIMAL");
+        v._decimalValue = value instanceof Decimal ? value : new Decimal(value);
+        return v;
+      }
+      static array(values) {
+        const v = new _GQLValue("ARRAY");
+        v._arrayValue = values;
+        return v;
+      }
+      static object(values) {
+        const v = new _GQLValue("OBJECT");
+        v._objectValue = values instanceof Map ? values : new Map(Object.entries(values));
+        return v;
+      }
+      static bytes(value) {
+        const v = new _GQLValue("BYTEA");
+        v._bytesValue = value instanceof Uint8Array ? value : new Uint8Array(value);
+        return v;
+      }
+      static date(value) {
+        const v = new _GQLValue("DATE");
+        v._dateValue = value;
+        return v;
+      }
+      static time(value) {
+        const v = new _GQLValue("TIME");
+        v._dateValue = value;
+        return v;
+      }
+      static timestamp(value) {
+        const v = new _GQLValue("TIMESTAMP");
+        v._dateValue = value;
+        return v;
+      }
+      static uuid(value) {
+        const v = new _GQLValue("UUID");
+        v._stringValue = value;
+        return v;
+      }
+      static json(value) {
+        const v = new _GQLValue("JSON");
+        v._rawValue = value;
+        return v;
+      }
+      static node(value) {
+        const v = new _GQLValue("NODE");
+        v._nodeValue = value;
+        return v;
+      }
+      static edge(value) {
+        const v = new _GQLValue("EDGE");
+        v._edgeValue = value;
+        return v;
+      }
+      static path(value) {
+        const v = new _GQLValue("PATH");
+        v._pathValue = value;
+        return v;
+      }
+      static range(value) {
+        const v = new _GQLValue("RANGE");
+        v._rangeValue = value;
+        return v;
+      }
+      static unknown(value) {
+        const v = new _GQLValue("UNKNOWN");
+        v._rawValue = value;
+        return v;
+      }
+      // Type-safe accessors
+      get isNull() {
+        return this.kind === "NULL";
+      }
+      get asBool() {
+        if (this.kind !== "BOOL") {
+          throw new TypeError(`Cannot convert ${this.kind} to boolean`);
+        }
+        return this._boolValue;
+      }
+      get asInt() {
+        if (this.kind !== "INT") {
+          throw new TypeError(`Cannot convert ${this.kind} to int`);
+        }
+        return this._intValue;
+      }
+      get asNumber() {
+        if (this.kind === "INT") {
+          return Number(this._intValue);
+        }
+        if (this.kind === "FLOAT") {
+          return this._floatValue;
+        }
+        if (this.kind === "DECIMAL") {
+          return this._decimalValue?.toNumber() ?? 0;
+        }
+        throw new TypeError(`Cannot convert ${this.kind} to number`);
+      }
+      get asFloat() {
+        if (this.kind !== "FLOAT") {
+          throw new TypeError(`Cannot convert ${this.kind} to float`);
+        }
+        return this._floatValue;
+      }
+      get asString() {
+        if (this.kind === "STRING" || this.kind === "UUID") {
+          return this._stringValue;
+        }
+        return this.toString();
+      }
+      get asDecimal() {
+        if (this.kind !== "DECIMAL") {
+          throw new TypeError(`Cannot convert ${this.kind} to decimal`);
+        }
+        return this._decimalValue;
+      }
+      get asArray() {
+        if (this.kind !== "ARRAY") {
+          throw new TypeError(`Cannot convert ${this.kind} to array`);
+        }
+        return this._arrayValue;
+      }
+      get asObject() {
+        if (this.kind !== "OBJECT" && this.kind !== "NODE" && this.kind !== "EDGE") {
+          throw new TypeError(`Cannot convert ${this.kind} to object`);
+        }
+        return this._objectValue;
+      }
+      get asBytes() {
+        if (this.kind !== "BYTEA") {
+          throw new TypeError(`Cannot convert ${this.kind} to bytes`);
+        }
+        return this._bytesValue;
+      }
+      get asDate() {
+        if (this.kind !== "DATE" && this.kind !== "TIME" && this.kind !== "TIMETZ" && this.kind !== "TIMESTAMP" && this.kind !== "TIMESTAMPTZ") {
+          throw new TypeError(`Cannot convert ${this.kind} to date`);
+        }
+        return this._dateValue;
+      }
+      get asNode() {
+        if (this.kind !== "NODE") {
+          throw new TypeError(`Cannot convert ${this.kind} to node`);
+        }
+        return this._nodeValue;
+      }
+      get asEdge() {
+        if (this.kind !== "EDGE") {
+          throw new TypeError(`Cannot convert ${this.kind} to edge`);
+        }
+        return this._edgeValue;
+      }
+      get asPath() {
+        if (this.kind !== "PATH") {
+          throw new TypeError(`Cannot convert ${this.kind} to path`);
+        }
+        return this._pathValue;
+      }
+      get asRange() {
+        if (this.kind !== "RANGE") {
+          throw new TypeError(`Cannot convert ${this.kind} to range`);
+        }
+        return this._rangeValue;
+      }
+      get asJSON() {
+        if (this.kind !== "JSON" && this.kind !== "JSONB") {
+          throw new TypeError(`Cannot convert ${this.kind} to JSON`);
+        }
+        return this._rawValue;
+      }
+      get raw() {
+        return this._rawValue;
+      }
+      toString() {
+        switch (this.kind) {
+          case "NULL":
+            return "null";
+          case "BOOL":
+            return this._boolValue.toString();
+          case "INT":
+            return this._intValue.toString();
+          case "FLOAT":
+            return this._floatValue.toString();
+          case "STRING":
+          case "UUID":
+            return this._stringValue;
+          case "DECIMAL":
+            return this._decimalValue?.toString() ?? "0";
+          case "ARRAY":
+            return `[${this._arrayValue.map((v) => v.toString()).join(", ")}]`;
+          case "OBJECT":
+            return `{${[...this._objectValue.entries()].map(([k, v]) => `${k}: ${v.toString()}`).join(", ")}}`;
+          case "BYTEA":
+            return `<bytes:${this._bytesValue.length}>`;
+          case "DATE":
+          case "TIME":
+          case "TIMETZ":
+          case "TIMESTAMP":
+          case "TIMESTAMPTZ":
+            return this._dateValue?.toISOString() ?? "";
+          case "NODE":
+            return `(${this._nodeValue?.labels.join(":")} {${JSON.stringify(this._nodeValue?.properties)}})`;
+          case "EDGE":
+            return `[${this._edgeValue?.type} {${JSON.stringify(this._edgeValue?.properties)}}]`;
+          case "PATH":
+            return `<path:${this._pathValue?.nodes.length} nodes>`;
+          case "JSON":
+          case "JSONB":
+            return JSON.stringify(this._rawValue);
+          default:
+            return String(this._rawValue ?? "");
+        }
+      }
+      /**
+       * Convert to a plain JavaScript value.
+       */
+      toJS() {
+        switch (this.kind) {
+          case "NULL":
+            return null;
+          case "BOOL":
+            return this._boolValue;
+          case "INT":
+            if (this._intValue >= Number.MIN_SAFE_INTEGER && this._intValue <= Number.MAX_SAFE_INTEGER) {
+              return Number(this._intValue);
+            }
+            return this._intValue;
+          case "FLOAT":
+            return this._floatValue;
+          case "STRING":
+          case "UUID":
+            return this._stringValue;
+          case "DECIMAL":
+            return this._decimalValue?.toString();
+          case "ARRAY":
+            return this._arrayValue.map((v) => v.toJS());
+          case "OBJECT":
+            return Object.fromEntries([...this._objectValue.entries()].map(([k, v]) => [k, v.toJS()]));
+          case "BYTEA":
+            return this._bytesValue;
+          case "DATE":
+          case "TIME":
+          case "TIMETZ":
+          case "TIMESTAMP":
+          case "TIMESTAMPTZ":
+            return this._dateValue;
+          case "NODE":
+            return this._nodeValue;
+          case "EDGE":
+            return this._edgeValue;
+          case "PATH":
+            return this._pathValue;
+          case "RANGE":
+            return this._rangeValue;
+          case "JSON":
+          case "JSONB":
+            return this._rawValue;
+          default:
+            return this._rawValue;
+        }
+      }
+      /**
+       * Convert to JSON-serializable format.
+       */
+      toJSON() {
+        return this.toJS();
+      }
+    };
+  }
+});
+
+// src/protocol.ts
+function parseFrame(data) {
+  let str;
+  if (Buffer.isBuffer(data)) {
+    str = data.toString("utf-8");
+  } else {
+    str = data;
+  }
+  try {
+    const frame = JSON.parse(str);
+    if (!frame.result || typeof frame.result.type !== "string") {
+      const topLevel = frame;
+      if (typeof topLevel.type === "string") {
+        return {
+          status_class: topLevel.status_class ?? "00000",
+          status_subclass: "000",
+          result: frame
+        };
+      }
+      if (typeof topLevel.status_class === "string") {
+        const resultType = Array.isArray(topLevel.columns) ? RespType.BINDINGS : RespType.STATUS;
+        return {
+          status_class: topLevel.status_class,
+          status_subclass: "000",
+          result: {
+            type: resultType,
+            ...frame
+          }
+        };
+      }
+      throw new TransportError({
+        operation: "parse_frame",
+        cause: new Error(
+          `invalid frame structure: missing result.type. Received: ${str.slice(0, 200)}`
+        )
+      });
+    }
+    return frame;
+  } catch (e) {
+    if (e instanceof TransportError) {
+      throw e;
+    }
+    throw new TransportError({
+      operation: "parse_frame",
+      cause: e instanceof Error ? e : new Error(String(e))
+    });
+  }
+}
+function isErrorFrame(frame) {
+  return frame.result.type === RespType.ERROR;
+}
+function isSchemaFrame(frame) {
+  return frame.result.type === RespType.SCHEMA;
+}
+function isBindingsFrame(frame) {
+  return frame.result.type === RespType.BINDINGS;
+}
+function isFinalFrame(frame) {
+  return frame.result.final === true;
+}
+function frameToError(frame) {
+  const result = frame.result;
+  const additional = [];
+  if (result.additional) {
+    for (const info of result.additional) {
+      if (info.message) {
+        additional.push(info.message);
+      } else if (info.code) {
+        additional.push(info.code);
+      }
+    }
+  }
+  return new DriverError({
+    statusClass: frame.status_class || StatusClass.SYSTEM,
+    subclass: frame.status_subclass || "000",
+    code: result.code ?? "UnknownError",
+    message: result.message ?? "Unknown error",
+    anchor: result.anchor,
+    additional,
+    findings: result.flagger_findings
+  });
+}
+function getColumnsFromSchema(frame) {
+  if (!isSchemaFrame(frame)) {
+    throw new Error("Expected SCHEMA frame");
+  }
+  const columns = frame.result.columns ?? [];
+  return columns.map((col) => ({
+    name: col.name,
+    type: col.type,
+    kind: parseGQLType(col.type)
+  }));
+}
+function buildHelloMessage(cfg) {
+  const msg = {
+    type: MsgType.HELLO,
+    client_name: cfg.helloName,
+    client_ver: cfg.helloVersion,
+    wanted_conformance: cfg.conformance
+  };
+  if (cfg.username) {
+    msg["username"] = cfg.username;
+  }
+  if (cfg.password) {
+    msg["password"] = cfg.password;
+  }
+  return msg;
+}
+function buildRunGQLMessage(query2, params) {
+  const msg = {
+    type: MsgType.RUN_GQL,
+    text: query2
+  };
+  if (params && Object.keys(params).length > 0) {
+    msg["params"] = params;
+  }
+  return msg;
+}
+function buildPullMessage(requestId, pageSize) {
+  return {
+    type: MsgType.PULL,
+    request_id: requestId,
+    page_size: pageSize
+  };
+}
+function buildBeginMessage() {
+  return {
+    type: MsgType.BEGIN
+  };
+}
+function buildCommitMessage() {
+  return {
+    type: MsgType.COMMIT
+  };
+}
+function buildRollbackMessage() {
+  return {
+    type: MsgType.ROLLBACK
+  };
+}
+function buildSavepointMessage(name) {
+  return {
+    type: MsgType.SAVEPOINT,
+    name
+  };
+}
+function buildRollbackToMessage(name) {
+  return {
+    type: MsgType.ROLLBACK_TO,
+    name
+  };
+}
+function buildPingMessage() {
+  return {
+    type: MsgType.PING
+  };
+}
+function serializeMessage(msg) {
+  const json = JSON.stringify(msg);
+  return Buffer.from(json + "\n", "utf-8");
+}
+function rewritePlaceholders(query2, args) {
+  const params = {};
+  let argIndex = 0;
+  let result = "";
+  let i = 0;
+  while (i < query2.length) {
+    const ch = query2[i];
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      result += ch;
+      i++;
+      while (i < query2.length && query2[i] !== quote) {
+        if (query2[i] === "\\" && i + 1 < query2.length) {
+          result += query2[i];
+          i++;
+        }
+        result += query2[i];
+        i++;
+      }
+      if (i < query2.length) {
+        result += query2[i];
+        i++;
+      }
+      continue;
+    }
+    if (ch === "?") {
+      argIndex++;
+      const paramName = `p${argIndex}`;
+      result += "$" + paramName;
+      if (argIndex <= args.length) {
+        params[paramName] = args[argIndex - 1];
+      }
+      i++;
+      continue;
+    }
+    result += ch;
+    i++;
+  }
+  return { query: result, params };
+}
+function countPlaceholders(query2) {
+  let count = 0;
+  let i = 0;
+  while (i < query2.length) {
+    const ch = query2[i];
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      i++;
+      while (i < query2.length && query2[i] !== quote) {
+        if (query2[i] === "\\") {
+          i++;
+        }
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "?") {
+      count++;
+    }
+    i++;
+  }
+  return count;
+}
+function mergeParams(positionalParams, namedParams) {
+  if (!namedParams || Object.keys(namedParams).length === 0) {
+    return positionalParams;
+  }
+  return { ...positionalParams, ...namedParams };
+}
+var MsgType, RespType;
+var init_protocol = __esm({
+  "src/protocol.ts"() {
+    init_errors();
+    init_types();
+    MsgType = {
+      HELLO: "HELLO",
+      RUN_GQL: "RUN_GQL",
+      PULL: "PULL",
+      BEGIN: "BEGIN",
+      COMMIT: "COMMIT",
+      ROLLBACK: "ROLLBACK",
+      SAVEPOINT: "SAVEPOINT",
+      ROLLBACK_TO: "ROLLBACK_TO",
+      PING: "PING"
+    };
+    RespType = {
+      HELLO: "HELLO",
+      SCHEMA: "SCHEMA",
+      BINDINGS: "BINDINGS",
+      ERROR: "ERROR",
+      EXPLAIN: "EXPLAIN",
+      PROFILE: "PROFILE",
+      RESULT: "RESULT",
+      STATUS: "STATUS"
+    };
+  }
+});
+
+// src/validate.ts
+function validateQuery(query2) {
+  if (!query2) {
+    throw new SecurityError({
+      type: "input",
+      message: "query cannot be empty"
+    });
+  }
+  if (query2.length > MAX_QUERY_LENGTH) {
+    throw new SecurityError({
+      type: "input",
+      message: `query exceeds maximum length of ${MAX_QUERY_LENGTH} bytes`
+    });
+  }
+  if (query2.includes("\0")) {
+    throw new SecurityError({
+      type: "input",
+      message: "query contains null bytes"
+    });
+  }
+  if (/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/.test(query2)) {
+    throw new SecurityError({
+      type: "input",
+      message: "query contains invalid control characters"
+    });
+  }
+}
+function validateParamName(name) {
+  if (!name) {
+    throw new SecurityError({
+      type: "input",
+      message: "parameter name cannot be empty"
+    });
+  }
+  if (!PARAM_NAME_PATTERN.test(name)) {
+    throw new SecurityError({
+      type: "input",
+      message: `invalid parameter name: ${name}`
+    });
+  }
+  if (RESERVED_KEYWORDS.has(name.toLowerCase())) {
+    throw new SecurityError({
+      type: "input",
+      message: `parameter name is a reserved keyword: ${name}`
+    });
+  }
+}
+function validateParamValue(value) {
+  try {
+    JSON.stringify(value);
+  } catch {
+    throw new SecurityError({
+      type: "input",
+      message: "parameter value contains circular reference or is not serializable"
+    });
+  }
+  validateValueRecursive(value, 0);
+}
+function validateValueRecursive(value, depth) {
+  const MAX_DEPTH = 32;
+  if (depth > MAX_DEPTH) {
+    throw new SecurityError({
+      type: "input",
+      message: `parameter value exceeds maximum nesting depth of ${MAX_DEPTH}`
+    });
+  }
+  if (value === null || value === void 0) {
+    return;
+  }
+  if (typeof value === "string") {
+    if (value.includes("\0")) {
+      throw new SecurityError({
+        type: "input",
+        message: "parameter value contains null bytes"
+      });
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      validateValueRecursive(item, depth + 1);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [key, val] of Object.entries(value)) {
+      validateParamName(key);
+      validateValueRecursive(val, depth + 1);
+    }
+    return;
+  }
+}
+function validateHostname(hostname) {
+  if (!hostname) {
+    throw new SecurityError({
+      type: "input",
+      message: "hostname cannot be empty"
+    });
+  }
+  if (hostname.length > 253) {
+    throw new SecurityError({
+      type: "input",
+      message: "hostname exceeds maximum length"
+    });
+  }
+  if (!/^[a-zA-Z0-9.\-:[\]]+$/.test(hostname)) {
+    throw new SecurityError({
+      type: "input",
+      message: "hostname contains invalid characters"
+    });
+  }
+  if (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(hostname)) {
+    const parts = hostname.split(".").map(Number);
+    if (parts.some((p) => p < 0 || p > 255)) {
+      throw new SecurityError({
+        type: "input",
+        message: "invalid IPv4 address"
+      });
+    }
+    return;
+  }
+  if (hostname.includes(":") || hostname.startsWith("[")) {
+    const addr = hostname.replace(/^\[|\]$/g, "");
+    if (!/^[a-fA-F0-9:]+$/.test(addr)) {
+      throw new SecurityError({
+        type: "input",
+        message: "invalid IPv6 address"
+      });
+    }
+    return;
+  }
+  const labels = hostname.split(".");
+  for (const label of labels) {
+    if (!label || label.length > 63) {
+      throw new SecurityError({
+        type: "input",
+        message: "hostname label is invalid"
+      });
+    }
+    if (!/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(label)) {
+      throw new SecurityError({
+        type: "input",
+        message: "hostname label contains invalid characters"
+      });
+    }
+  }
+}
+function validatePort(port) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new SecurityError({
+      type: "input",
+      message: "port must be an integer between 1 and 65535"
+    });
+  }
+}
+function validatePageSize(pageSize) {
+  if (!Number.isInteger(pageSize) || pageSize < 1) {
+    throw new SecurityError({
+      type: "input",
+      message: "page size must be a positive integer"
+    });
+  }
+  if (pageSize > MAX_PAGE_SIZE) {
+    throw new SecurityError({
+      type: "input",
+      message: `page size must not exceed ${MAX_PAGE_SIZE}`
+    });
+  }
+}
+function validateSavepointName(name) {
+  if (!name) {
+    throw new SecurityError({
+      type: "input",
+      message: "savepoint name cannot be empty"
+    });
+  }
+  if (name.length > 128) {
+    throw new SecurityError({
+      type: "input",
+      message: "savepoint name exceeds maximum length of 128 characters"
+    });
+  }
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new SecurityError({
+      type: "input",
+      message: "savepoint name contains invalid characters"
+    });
+  }
+}
+function sanitizeForLog(value) {
+  return value.replace(/password\s*[:=]\s*\S+/gi, "password=***").replace(/token\s*[:=]\s*\S+/gi, "token=***").replace(/secret\s*[:=]\s*\S+/gi, "secret=***").replace(/api[_-]?key\s*[:=]\s*\S+/gi, "api_key=***");
+}
+var PARAM_NAME_PATTERN, RESERVED_KEYWORDS;
+var init_validate = __esm({
+  "src/validate.ts"() {
+    init_errors();
+    init_config();
+    PARAM_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]{0,127}$/;
+    RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
+      "match",
+      "create",
+      "delete",
+      "set",
+      "remove",
+      "return",
+      "where",
+      "with",
+      "order",
+      "by",
+      "skip",
+      "limit",
+      "union",
+      "all",
+      "optional",
+      "and",
+      "or",
+      "not",
+      "xor",
+      "null",
+      "true",
+      "false",
+      "in",
+      "is",
+      "as",
+      "case",
+      "when",
+      "then",
+      "else",
+      "end",
+      "exists",
+      "count",
+      "sum",
+      "avg",
+      "min",
+      "max",
+      "collect",
+      "distinct",
+      "merge",
+      "call",
+      "yield",
+      "unwind",
+      "foreach",
+      "detach",
+      "drop",
+      "graph",
+      "use",
+      "catalog",
+      "constraint",
+      "index",
+      "create",
+      "node",
+      "relationship",
+      "edge",
+      "property",
+      "on",
+      "for",
+      "if",
+      "begin",
+      "commit",
+      "rollback",
+      "transaction"
+    ]);
+  }
+});
+
+// src/prepared.ts
+var prepared_exports = {};
+__export(prepared_exports, {
+  PreparedStatement: () => PreparedStatement,
+  extractParameters: () => extractParameters,
+  prepare: () => prepare
+});
+function extractParameters(query2) {
+  const params = [];
+  let i = 0;
+  let position = 0;
+  while (i < query2.length) {
+    const ch = query2[i];
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      i++;
+      while (i < query2.length && query2[i] !== quote) {
+        if (query2[i] === "\\") {
+          i++;
+        }
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "/" && i + 1 < query2.length && query2[i + 1] === "/") {
+      while (i < query2.length && query2[i] !== "\n") {
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && i + 1 < query2.length && query2[i + 1] === "*") {
+      i += 2;
+      while (i + 1 < query2.length && !(query2[i] === "*" && query2[i + 1] === "/")) {
+        i++;
+      }
+      i += 2;
+      continue;
+    }
+    if (ch === "?") {
+      position++;
+      params.push({
+        name: `p${position}`,
+        position,
+        positional: true
+      });
+      i++;
+      continue;
+    }
+    if (ch === "$") {
+      i++;
+      let name = "";
+      while (i < query2.length && /[a-zA-Z0-9_]/.test(query2[i] ?? "")) {
+        name += query2[i];
+        i++;
+      }
+      if (name) {
+        position++;
+        const existing = params.find((p) => p.name === name);
+        if (!existing) {
+          params.push({
+            name,
+            position,
+            positional: false
+          });
+        }
+      }
+      continue;
+    }
+    i++;
+  }
+  return params;
+}
+function prepare(conn, query2) {
+  return new PreparedStatement(conn, query2);
+}
+var PreparedStatement;
+var init_prepared = __esm({
+  "src/prepared.ts"() {
+    init_errors();
+    init_validate();
+    PreparedStatement = class {
+      _conn;
+      _query;
+      _parameters;
+      _closed = false;
+      /**
+       * Create a new prepared statement.
+       *
+       * @internal Use Connection.prepare() instead.
+       */
+      constructor(conn, query2) {
+        validateQuery(query2);
+        this._conn = conn;
+        this._query = query2;
+        this._parameters = extractParameters(query2);
+      }
+      /**
+       * Get the query text.
+       */
+      get query() {
+        return this._query;
+      }
+      /**
+       * Get parameter information.
+       */
+      get parameters() {
+        return this._parameters;
+      }
+      /**
+       * Get the number of parameters.
+       */
+      get parameterCount() {
+        return this._parameters.length;
+      }
+      /**
+       * Get positional parameter count (number of ? placeholders).
+       */
+      get positionalCount() {
+        return this._parameters.filter((p) => p.positional).length;
+      }
+      /**
+       * Get named parameter names.
+       */
+      get namedParameters() {
+        return this._parameters.filter((p) => !p.positional).map((p) => p.name);
+      }
+      /**
+       * Check if the statement is closed.
+       */
+      get isClosed() {
+        return this._closed;
+      }
+      /**
+       * Execute the prepared statement and return results.
+       *
+       * @param params - Parameter values (object for named, array for positional)
+       * @param options - Additional query options
+       * @returns Query result
+       */
+      async execute(params, options) {
+        this.checkClosed();
+        const resolvedParams = this.resolveParams(params);
+        return this._conn.query(this._query, { ...options, params: resolvedParams });
+      }
+      /**
+       * Execute the prepared statement and return all rows.
+       *
+       * @param params - Parameter values
+       * @param options - Additional query options
+       * @returns Array of row objects
+       */
+      async executeAll(params, options) {
+        this.checkClosed();
+        const resolvedParams = this.resolveParams(params);
+        return this._conn.queryAll(this._query, { ...options, params: resolvedParams });
+      }
+      /**
+       * Execute the prepared statement without returning results.
+       *
+       * @param params - Parameter values
+       * @param options - Additional query options
+       */
+      async exec(params, options) {
+        this.checkClosed();
+        const resolvedParams = this.resolveParams(params);
+        return this._conn.exec(this._query, { ...options, params: resolvedParams });
+      }
+      /**
+       * Validate parameters without executing.
+       *
+       * @param params - Parameter values to validate
+       * @throws SecurityError if validation fails
+       */
+      validate(params) {
+        this.checkClosed();
+        this.resolveParams(params);
+      }
+      /**
+       * Close the prepared statement.
+       *
+       * After closing, the statement cannot be executed.
+       */
+      close() {
+        this._closed = true;
+      }
+      /**
+       * Resolve and validate parameters.
+       */
+      resolveParams(params) {
+        if (!params) {
+          if (this._parameters.length > 0) {
+            throw new SecurityError({
+              type: "validation",
+              message: `Expected ${this._parameters.length} parameters, got 0`
+            });
+          }
+          return {};
+        }
+        if (Array.isArray(params)) {
+          const positionalCount = this.positionalCount;
+          if (params.length !== positionalCount) {
+            throw new SecurityError({
+              type: "validation",
+              message: `Expected ${positionalCount} positional parameters, got ${params.length}`
+            });
+          }
+          const namedParams2 = {};
+          let posIndex = 0;
+          for (const p of this._parameters) {
+            if (p.positional) {
+              namedParams2[p.name] = params[posIndex];
+              validateParamValue(params[posIndex]);
+              posIndex++;
+            }
+          }
+          return namedParams2;
+        }
+        const namedParams = params;
+        for (const p of this._parameters) {
+          if (!p.positional && !(p.name in namedParams)) {
+            throw new SecurityError({
+              type: "validation",
+              message: `Missing required parameter: ${p.name}`
+            });
+          }
+        }
+        for (const [key, value] of Object.entries(namedParams)) {
+          validateParamName(key);
+          validateParamValue(value);
+        }
+        return namedParams;
+      }
+      /**
+       * Check if statement is closed.
+       */
+      checkClosed() {
+        if (this._closed) {
+          throw new StateError({
+            currentState: "closed",
+            operation: "execute",
+            message: "PreparedStatement is closed"
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/explain.ts
+var explain_exports = {};
+__export(explain_exports, {
+  explain: () => explain,
+  formatPlan: () => formatPlan,
+  formatProfile: () => formatProfile,
+  profile: () => profile
+});
+function parsePlanOperation(data) {
+  if (!data || typeof data !== "object") {
+    return { type: "Unknown", details: { raw: data } };
+  }
+  const obj = data;
+  const op = {
+    type: obj["type"] || obj["operator"] || "Unknown"
+  };
+  if ("operator" in obj) op.operator = obj["operator"];
+  if ("cost" in obj) op.cost = obj["cost"];
+  if ("rows" in obj) op.rows = obj["rows"];
+  if ("estimated_rows" in obj) op.rows = obj["estimated_rows"];
+  if ("estimated_cost" in obj) op.cost = obj["estimated_cost"];
+  const details = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (![
+      "type",
+      "operator",
+      "cost",
+      "rows",
+      "children",
+      "estimated_rows",
+      "estimated_cost"
+    ].includes(key)) {
+      details[key] = value;
+    }
+  }
+  if (Object.keys(details).length > 0) {
+    op.details = details;
+  }
+  if (Array.isArray(obj["children"])) {
+    op.children = obj["children"].map(parsePlanOperation);
+  }
+  return op;
+}
+function parseOperationTiming(data) {
+  if (!data || typeof data !== "object") {
+    return { type: "Unknown", wallTimeMs: 0 };
+  }
+  const obj = data;
+  const timing = {
+    type: obj["type"] || obj["operator"] || "Unknown",
+    wallTimeMs: obj["wall_time_ms"] || obj["time_ms"] || 0
+  };
+  if ("cpu_time_ms" in obj) timing.cpuTimeMs = obj["cpu_time_ms"];
+  if ("rows" in obj) timing.rows = obj["rows"];
+  if ("actual_rows" in obj) timing.rows = obj["actual_rows"];
+  if ("page_hits" in obj) timing.pageHits = obj["page_hits"];
+  if ("page_faults" in obj) timing.pageFaults = obj["page_faults"];
+  if (Array.isArray(obj["children"])) {
+    timing.children = obj["children"].map(parseOperationTiming);
+  }
+  return timing;
+}
+async function explain(conn, query2, options) {
+  validateQuery(query2);
+  let finalQuery = query2;
+  let params = options?.params ?? {};
+  if (query2.includes("?") && Array.isArray(options?.params)) {
+    const result = rewritePlaceholders(query2, options.params);
+    finalQuery = result.query;
+    params = result.params;
+  }
+  for (const [_key, value] of Object.entries(params)) {
+    validateParamValue(value);
+  }
+  const explainQuery = options?.verbose ? `EXPLAIN VERBOSE ${finalQuery}` : `EXPLAIN ${finalQuery}`;
+  const transport = conn._transport;
+  await transport.send(buildRunGQLMessage(explainQuery, params), options?.signal);
+  const data = await transport.receive(options?.signal);
+  const frame = parseFrame(data);
+  if (isErrorFrame(frame)) {
+    throw frameToError(frame);
+  }
+  if (frame.result.type === RespType.EXPLAIN) {
+    const raw = frame.result.json;
+    const root = parsePlanOperation(raw);
+    return {
+      root,
+      totalCost: calculateTotalCost(root),
+      totalRows: root.rows,
+      raw
+    };
+  }
+  return {
+    root: { type: "Unknown", details: { response: frame.result } },
+    raw: frame.result
+  };
+}
+async function profile(conn, query2, options) {
+  validateQuery(query2);
+  let finalQuery = query2;
+  let params = options?.params ?? {};
+  if (query2.includes("?") && Array.isArray(options?.params)) {
+    const result = rewritePlaceholders(query2, options.params);
+    finalQuery = result.query;
+    params = result.params;
+  }
+  for (const [_key, value] of Object.entries(params)) {
+    validateParamValue(value);
+  }
+  const profileQuery = options?.verbose ? `PROFILE VERBOSE ${finalQuery}` : `PROFILE ${finalQuery}`;
+  const transport = conn._transport;
+  await transport.send(buildRunGQLMessage(profileQuery, params), options?.signal);
+  const data = await transport.receive(options?.signal);
+  const frame = parseFrame(data);
+  if (isErrorFrame(frame)) {
+    throw frameToError(frame);
+  }
+  if (frame.result.type === RespType.PROFILE) {
+    const raw = frame.result.json;
+    const root = parseOperationTiming(raw);
+    return {
+      root,
+      totalTimeMs: calculateTotalTime(root),
+      totalRows: root.rows,
+      planningTimeMs: raw?.["planning_time_ms"],
+      executionTimeMs: raw?.["execution_time_ms"],
+      memoryBytes: raw?.["memory_bytes"],
+      raw
+    };
+  }
+  return {
+    root: { type: "Unknown", wallTimeMs: 0 },
+    totalTimeMs: 0,
+    raw: frame.result
+  };
+}
+function calculateTotalCost(op) {
+  let total = op.cost ?? 0;
+  if (op.children) {
+    for (const child of op.children) {
+      total += calculateTotalCost(child);
+    }
+  }
+  return total;
+}
+function calculateTotalTime(timing) {
+  let total = timing.wallTimeMs;
+  if (timing.children) {
+    for (const child of timing.children) {
+      total = Math.max(total, calculateTotalTime(child));
+    }
+  }
+  return total;
+}
+function formatPlan(plan, indent = 0) {
+  const lines = [];
+  function formatOp(op, depth) {
+    const prefix = "  ".repeat(depth);
+    let line = `${prefix}${op.type}`;
+    if (op.operator && op.operator !== op.type) {
+      line += ` (${op.operator})`;
+    }
+    if (op.cost !== void 0) {
+      line += ` cost=${op.cost.toFixed(2)}`;
+    }
+    if (op.rows !== void 0) {
+      line += ` rows=${op.rows}`;
+    }
+    lines.push(line);
+    if (op.details && Object.keys(op.details).length > 0) {
+      for (const [key, value] of Object.entries(op.details)) {
+        lines.push(`${prefix}  ${key}: ${JSON.stringify(value)}`);
+      }
+    }
+    if (op.children) {
+      for (const child of op.children) {
+        formatOp(child, depth + 1);
+      }
+    }
+  }
+  formatOp(plan.root, indent);
+  if (plan.totalCost !== void 0) {
+    lines.push(`Total Cost: ${plan.totalCost.toFixed(2)}`);
+  }
+  if (plan.totalRows !== void 0) {
+    lines.push(`Estimated Rows: ${plan.totalRows}`);
+  }
+  return lines.join("\n");
+}
+function formatProfile(prof, indent = 0) {
+  const lines = [];
+  function formatTiming(timing, depth) {
+    const prefix = "  ".repeat(depth);
+    let line = `${prefix}${timing.type}`;
+    line += ` ${timing.wallTimeMs.toFixed(2)}ms`;
+    if (timing.rows !== void 0) {
+      line += ` ${timing.rows} rows`;
+    }
+    if (timing.pageHits !== void 0 || timing.pageFaults !== void 0) {
+      line += ` (hits=${timing.pageHits ?? 0}, faults=${timing.pageFaults ?? 0})`;
+    }
+    lines.push(line);
+    if (timing.children) {
+      for (const child of timing.children) {
+        formatTiming(child, depth + 1);
+      }
+    }
+  }
+  formatTiming(prof.root, indent);
+  lines.push("---");
+  lines.push(`Total Time: ${prof.totalTimeMs.toFixed(2)}ms`);
+  if (prof.planningTimeMs !== void 0) {
+    lines.push(`Planning: ${prof.planningTimeMs.toFixed(2)}ms`);
+  }
+  if (prof.executionTimeMs !== void 0) {
+    lines.push(`Execution: ${prof.executionTimeMs.toFixed(2)}ms`);
+  }
+  if (prof.totalRows !== void 0) {
+    lines.push(`Rows: ${prof.totalRows}`);
+  }
+  if (prof.memoryBytes !== void 0) {
+    lines.push(`Memory: ${formatBytes(prof.memoryBytes)}`);
+  }
+  return lines.join("\n");
+}
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  return `${value.toFixed(2)} ${units[unitIndex]}`;
+}
+var init_explain = __esm({
+  "src/explain.ts"() {
+    init_validate();
+    init_protocol();
+  }
+});
+
+// src/batch.ts
+var batch_exports = {};
+__export(batch_exports, {
+  batch: () => batch,
+  batchAll: () => batchAll,
+  batchFirst: () => batchFirst,
+  batchMap: () => batchMap,
+  batchParallel: () => batchParallel
+});
+async function batch(conn, queries, options) {
+  const results = [];
+  const startTime = Date.now();
+  let successful = 0;
+  let failed = 0;
+  const stopOnError = options?.stopOnError ?? false;
+  const inTransaction = options?.transaction ?? false;
+  let tx = null;
+  if (inTransaction) {
+    tx = await conn.begin(options?.signal);
+  }
+  try {
+    for (let i = 0; i < queries.length; i++) {
+      if (options?.signal?.aborted) {
+        for (let j = i; j < queries.length; j++) {
+          const q2 = queries[j];
+          results.push({
+            index: j,
+            query: q2?.query ?? "",
+            success: false,
+            error: new Error("Batch execution cancelled")
+          });
+          failed++;
+        }
+        break;
+      }
+      const q = queries[i];
+      if (!q) continue;
+      const queryStart = Date.now();
+      try {
+        const queryResult = await conn.query(q.query, {
+          params: q.params,
+          signal: options?.signal,
+          pageSize: options?.pageSize
+        });
+        const rows = [];
+        for await (const row of queryResult) {
+          rows.push(rowToObject(row));
+        }
+        results.push({
+          index: i,
+          query: q.query,
+          success: true,
+          rows,
+          durationMs: Date.now() - queryStart
+        });
+        successful++;
+      } catch (error) {
+        results.push({
+          index: i,
+          query: q.query,
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error)),
+          durationMs: Date.now() - queryStart
+        });
+        failed++;
+        if (stopOnError) {
+          for (let j = i + 1; j < queries.length; j++) {
+            const skipped = queries[j];
+            results.push({
+              index: j,
+              query: skipped?.query ?? "",
+              success: false,
+              error: new Error("Skipped due to previous error")
+            });
+            failed++;
+          }
+          break;
+        }
+      }
+    }
+    if (tx && failed === 0) {
+      await tx.commit();
+    } else if (tx) {
+      await tx.rollback();
+    }
+  } catch (error) {
+    if (tx) {
+      try {
+        await tx.rollback();
+      } catch {
+      }
+    }
+    throw error;
+  }
+  return {
+    total: queries.length,
+    successful,
+    failed,
+    totalDurationMs: Date.now() - startTime,
+    results
+  };
+}
+async function batchAll(conn, queries, options) {
+  const summary = await batch(conn, queries, options);
+  return summary.results.filter(
+    (r) => r.success && r.rows !== void 0
+  ).map((r) => r.rows);
+}
+async function batchFirst(conn, queries, options) {
+  for (const q of queries) {
+    try {
+      const rows = await conn.queryAll(q.query, {
+        params: q.params,
+        signal: options?.signal,
+        pageSize: options?.pageSize
+      });
+      return rows;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function batchMap(conn, queryTemplate, items, options) {
+  const queries = items.map((params) => ({
+    query: queryTemplate,
+    params
+  }));
+  return batch(conn, queries, options);
+}
+async function batchParallel(conn, queries, options) {
+  const concurrency = options?.concurrency ?? 5;
+  const results = [];
+  const startTime = Date.now();
+  let successful = 0;
+  let failed = 0;
+  async function executeQuery(index) {
+    const q = queries[index];
+    if (!q) return;
+    const queryStart = Date.now();
+    try {
+      const queryResult = await conn.query(q.query, {
+        params: q.params,
+        signal: options?.signal,
+        pageSize: options?.pageSize
+      });
+      const rows = [];
+      for await (const row of queryResult) {
+        rows.push(rowToObject(row));
+      }
+      results.push({
+        index,
+        query: q.query,
+        success: true,
+        rows,
+        durationMs: Date.now() - queryStart
+      });
+      successful++;
+    } catch (error) {
+      results.push({
+        index,
+        query: q.query,
+        success: false,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - queryStart
+      });
+      failed++;
+    }
+  }
+  const executing = /* @__PURE__ */ new Set();
+  for (let i = 0; i < queries.length; i++) {
+    if (options?.signal?.aborted) {
+      break;
+    }
+    while (executing.size >= concurrency) {
+      await Promise.race(executing);
+    }
+    const promise = executeQuery(i).finally(() => {
+      executing.delete(promise);
+    });
+    executing.add(promise);
+  }
+  await Promise.all(executing);
+  results.sort((a, b) => a.index - b.index);
+  return {
+    total: queries.length,
+    successful,
+    failed,
+    totalDurationMs: Date.now() - startTime,
+    results
+  };
+}
+var init_batch = __esm({
+  "src/batch.ts"() {
+    init_types();
+  }
+});
+
+// src/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  AuthClient: () => AuthClient,
+  createAuthClient: () => createAuthClient
+});
+function createAuthClient(conn) {
+  return new AuthClient(conn);
+}
+var AuthClient;
+var init_auth = __esm({
+  "src/auth.ts"() {
+    init_errors();
+    init_validate();
+    AuthClient = class {
+      _conn;
+      /**
+       * Create a new auth client.
+       *
+       * @param conn - Connection to use
+       */
+      constructor(conn) {
+        this._conn = conn;
+      }
+      // User Management
+      /**
+       * Create a new user.
+       *
+       * @param username - Username for the new user
+       * @param options - User creation options
+       */
+      async createUser(username, options) {
+        this.validateUsername(username);
+        this.validatePassword(options.password);
+        const roles = options.roles?.join(", ") ?? "";
+        const active = options.active !== false ? "true" : "false";
+        const query2 = `
+      CREATE USER $username
+      SET password = $password
+      ${roles ? `, roles = [${roles}]` : ""}
+      , active = ${active}
+    `.trim();
+        await this._conn.exec(query2, {
+          params: {
+            username,
+            password: options.password
+          }
+        });
+      }
+      /**
+       * Delete a user.
+       *
+       * @param username - Username to delete
+       */
+      async deleteUser(username) {
+        this.validateUsername(username);
+        await this._conn.exec("DROP USER $username", {
+          params: { username }
+        });
+      }
+      /**
+       * Get user information.
+       *
+       * @param username - Username to look up
+       * @returns User information or null if not found
+       */
+      async getUser(username) {
+        this.validateUsername(username);
+        const result = await this._conn.queryAll("SHOW USER $username", { params: { username } });
+        if (result.length === 0) {
+          return null;
+        }
+        const row = result[0];
+        if (!row) {
+          return null;
+        }
+        return {
+          username: row["username"],
+          roles: row["roles"] ?? [],
+          active: row["active"] ?? true,
+          createdAt: row["created_at"] ? new Date(row["created_at"]) : void 0,
+          lastLoginAt: row["last_login"] ? new Date(row["last_login"]) : void 0,
+          metadata: row["metadata"]
+        };
+      }
+      /**
+       * List all users.
+       *
+       * @returns Array of users
+       */
+      async listUsers() {
+        const result = await this._conn.queryAll("SHOW USERS");
+        return result.map((row) => ({
+          username: row["username"],
+          roles: row["roles"] ?? [],
+          active: row["active"] ?? true,
+          createdAt: row["created_at"] ? new Date(row["created_at"]) : void 0,
+          lastLoginAt: row["last_login"] ? new Date(row["last_login"]) : void 0
+        }));
+      }
+      /**
+       * Change a user's password.
+       *
+       * @param username - Username
+       * @param newPassword - New password
+       */
+      async changePassword(username, newPassword) {
+        this.validateUsername(username);
+        this.validatePassword(newPassword);
+        await this._conn.exec("ALTER USER $username SET password = $password", {
+          params: { username, password: newPassword }
+        });
+      }
+      /**
+       * Activate a user.
+       *
+       * @param username - Username to activate
+       */
+      async activateUser(username) {
+        this.validateUsername(username);
+        await this._conn.exec("ALTER USER $username SET active = true", {
+          params: { username }
+        });
+      }
+      /**
+       * Deactivate a user.
+       *
+       * @param username - Username to deactivate
+       */
+      async deactivateUser(username) {
+        this.validateUsername(username);
+        await this._conn.exec("ALTER USER $username SET active = false", {
+          params: { username }
+        });
+      }
+      // Role Management
+      /**
+       * Create a new role.
+       *
+       * @param name - Role name
+       * @param options - Role creation options
+       */
+      async createRole(name, options) {
+        this.validateRoleName(name);
+        let query2 = "CREATE ROLE $name";
+        if (options?.description) {
+          query2 += " SET description = $description";
+        }
+        await this._conn.exec(query2, {
+          params: {
+            name,
+            description: options?.description
+          }
+        });
+        if (options?.permissions) {
+          for (const perm of options.permissions) {
+            await this.grantPermission(name, perm);
+          }
+        }
+      }
+      /**
+       * Delete a role.
+       *
+       * @param name - Role name to delete
+       */
+      async deleteRole(name) {
+        this.validateRoleName(name);
+        await this._conn.exec("DROP ROLE $name", {
+          params: { name }
+        });
+      }
+      /**
+       * Get role information.
+       *
+       * @param name - Role name
+       * @returns Role information or null if not found
+       */
+      async getRole(name) {
+        this.validateRoleName(name);
+        const result = await this._conn.queryAll("SHOW ROLE $name", { params: { name } });
+        const row = result[0];
+        if (!row) {
+          return null;
+        }
+        return {
+          name: row["name"],
+          description: row["description"],
+          permissions: row["permissions"] ?? [],
+          system: row["system"]
+        };
+      }
+      /**
+       * List all roles.
+       *
+       * @returns Array of roles
+       */
+      async listRoles() {
+        const result = await this._conn.queryAll("SHOW ROLES");
+        return result.map((row) => ({
+          name: row["name"],
+          description: row["description"],
+          permissions: row["permissions"] ?? [],
+          system: row["system"]
+        }));
+      }
+      /**
+       * Assign a role to a user.
+       *
+       * @param username - Username
+       * @param roleName - Role to assign
+       */
+      async assignRole(username, roleName) {
+        this.validateUsername(username);
+        this.validateRoleName(roleName);
+        await this._conn.exec("GRANT ROLE $role TO $user", {
+          params: { role: roleName, user: username }
+        });
+      }
+      /**
+       * Revoke a role from a user.
+       *
+       * @param username - Username
+       * @param roleName - Role to revoke
+       */
+      async revokeRole(username, roleName) {
+        this.validateUsername(username);
+        this.validateRoleName(roleName);
+        await this._conn.exec("REVOKE ROLE $role FROM $user", {
+          params: { role: roleName, user: username }
+        });
+      }
+      /**
+       * Grant a permission to a role.
+       *
+       * @param roleName - Role name
+       * @param permission - Permission to grant
+       */
+      async grantPermission(roleName, permission) {
+        this.validateRoleName(roleName);
+        let query2 = `GRANT ${permission.action} ON ${permission.resource}`;
+        if (permission.label) {
+          query2 += `:${permission.label}`;
+        }
+        query2 += " TO $role";
+        await this._conn.exec(query2, {
+          params: { role: roleName }
+        });
+      }
+      /**
+       * Revoke a permission from a role.
+       *
+       * @param roleName - Role name
+       * @param permission - Permission to revoke
+       */
+      async revokePermission(roleName, permission) {
+        this.validateRoleName(roleName);
+        let query2 = `REVOKE ${permission.action} ON ${permission.resource}`;
+        if (permission.label) {
+          query2 += `:${permission.label}`;
+        }
+        query2 += " FROM $role";
+        await this._conn.exec(query2, {
+          params: { role: roleName }
+        });
+      }
+      // Row-Level Security
+      /**
+       * Create an RLS policy.
+       *
+       * @param name - Policy name
+       * @param label - Target label
+       * @param action - Policy action
+       * @param predicate - GQL predicate expression
+       * @param options - Additional options
+       */
+      async createRLSPolicy(name, label, action, predicate2, options) {
+        this.validatePolicyName(name);
+        validateQuery(predicate2);
+        const enabled = options?.enabled !== false ? "ENABLE" : "DISABLE";
+        const roles = options?.roles?.length ? `FOR ROLES (${options.roles.join(", ")})` : "";
+        const query2 = `
+      CREATE POLICY $name ON :${label}
+      FOR ${action}
+      ${roles}
+      USING (${predicate2})
+      ${enabled}
+    `.trim();
+        await this._conn.exec(query2, {
+          params: { name }
+        });
+      }
+      /**
+       * Delete an RLS policy.
+       *
+       * @param name - Policy name
+       * @param label - Target label
+       */
+      async deleteRLSPolicy(name, label) {
+        this.validatePolicyName(name);
+        await this._conn.exec(`DROP POLICY $name ON :${label}`, {
+          params: { name }
+        });
+      }
+      /**
+       * Get RLS policy information.
+       *
+       * @param name - Policy name
+       * @returns Policy information or null if not found
+       */
+      async getRLSPolicy(name) {
+        this.validatePolicyName(name);
+        const result = await this._conn.queryAll("SHOW POLICY $name", { params: { name } });
+        const row = result[0];
+        if (!row) {
+          return null;
+        }
+        return {
+          name: row["name"],
+          label: row["label"],
+          action: row["action"],
+          predicate: row["predicate"],
+          roles: row["roles"],
+          enabled: row["enabled"] ?? true
+        };
+      }
+      /**
+       * List all RLS policies.
+       *
+       * @param label - Optional label to filter by
+       * @returns Array of policies
+       */
+      async listRLSPolicies(label) {
+        const query2 = label ? `SHOW POLICIES ON :${label}` : "SHOW POLICIES";
+        const result = await this._conn.queryAll(query2);
+        return result.map((row) => ({
+          name: row["name"],
+          label: row["label"],
+          action: row["action"],
+          predicate: row["predicate"],
+          roles: row["roles"],
+          enabled: row["enabled"] ?? true
+        }));
+      }
+      /**
+       * Enable an RLS policy.
+       *
+       * @param name - Policy name
+       * @param label - Target label
+       */
+      async enableRLSPolicy(name, label) {
+        this.validatePolicyName(name);
+        await this._conn.exec(`ALTER POLICY $name ON :${label} ENABLE`, {
+          params: { name }
+        });
+      }
+      /**
+       * Disable an RLS policy.
+       *
+       * @param name - Policy name
+       * @param label - Target label
+       */
+      async disableRLSPolicy(name, label) {
+        this.validatePolicyName(name);
+        await this._conn.exec(`ALTER POLICY $name ON :${label} DISABLE`, {
+          params: { name }
+        });
+      }
+      // Session Management
+      /**
+       * Get the current session user.
+       *
+       * @returns Current username
+       */
+      async currentUser() {
+        const result = await this._conn.queryAll("RETURN current_user() AS user");
+        return result[0]?.["user"] ?? "";
+      }
+      /**
+       * Get the current session roles.
+       *
+       * @returns Current roles
+       */
+      async currentRoles() {
+        const result = await this._conn.queryAll("RETURN current_roles() AS roles");
+        return result[0]?.["roles"] ?? [];
+      }
+      /**
+       * Check if the current session has a specific permission.
+       *
+       * @param resource - Resource type
+       * @param action - Action to check
+       * @param label - Optional label filter
+       * @returns Whether permission is granted
+       */
+      async hasPermission(resource, action, label) {
+        const target = label ? `${resource}:${label}` : resource;
+        const result = await this._conn.queryAll("RETURN has_permission($target, $action) AS allowed", {
+          params: { target, action }
+        });
+        return result[0]?.["allowed"] ?? false;
+      }
+      // Validation helpers
+      validateUsername(username) {
+        if (!username || username.length === 0) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Username cannot be empty"
+          });
+        }
+        if (username.length > 128) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Username too long (max 128 characters)"
+          });
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(username)) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Invalid username format"
+          });
+        }
+      }
+      validatePassword(password) {
+        if (!password || password.length < 8) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Password must be at least 8 characters"
+          });
+        }
+        if (password.length > 256) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Password too long (max 256 characters)"
+          });
+        }
+      }
+      validateRoleName(name) {
+        if (!name || name.length === 0) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Role name cannot be empty"
+          });
+        }
+        if (name.length > 128) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Role name too long (max 128 characters)"
+          });
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Invalid role name format"
+          });
+        }
+      }
+      validatePolicyName(name) {
+        if (!name || name.length === 0) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Policy name cannot be empty"
+          });
+        }
+        if (name.length > 128) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Policy name too long (max 128 characters)"
+          });
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+          throw new SecurityError({
+            type: "validation",
+            message: "Invalid policy name format"
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/connection.ts
+init_config();
+init_errors();
+
+// src/transport.ts
+init_config();
+init_errors();
+var GEODE_ALPN = ["geode/1"];
+async function buildTLSConfig(cfg) {
+  const options = {
+    minVersion: "TLSv1.3",
+    maxVersion: "TLSv1.3"
+  };
+  if (cfg.tlsCACert) {
+    options.ca = cfg.tlsCACert;
+  } else if (cfg.tlsCA) {
+    try {
+      options.ca = await fs.promises.readFile(cfg.tlsCA, "utf-8");
+    } catch (e) {
+      throw new TransportError({
+        operation: "load_ca_cert",
+        cause: e instanceof Error ? e : new Error(String(e))
+      });
+    }
+  }
+  if (cfg.tlsCertPEM) {
+    options.cert = cfg.tlsCertPEM;
+  } else if (cfg.tlsCert) {
+    try {
+      options.cert = await fs.promises.readFile(cfg.tlsCert, "utf-8");
+    } catch (e) {
+      throw new TransportError({
+        operation: "load_client_cert",
+        cause: e instanceof Error ? e : new Error(String(e))
+      });
+    }
+  }
+  if (cfg.tlsKeyPEM) {
+    options.key = cfg.tlsKeyPEM;
+  } else if (cfg.tlsKey) {
+    try {
+      options.key = await fs.promises.readFile(cfg.tlsKey, "utf-8");
+    } catch (e) {
+      throw new TransportError({
+        operation: "load_client_key",
+        cause: e instanceof Error ? e : new Error(String(e))
+      });
+    }
+  }
+  return options;
+}
+var BaseTransport = class {
+  _closed = false;
+  _address;
+  constructor(address) {
+    this._address = address;
+  }
+  isClosed() {
+    return this._closed;
+  }
+  getAddress() {
+    return this._address;
+  }
+  checkClosed() {
+    if (this._closed) {
+      throw ErrClosed;
+    }
+  }
+};
+var MatrixQuicTransport = class _MatrixQuicTransport extends BaseTransport {
+  _client = null;
+  _stream = null;
+  _readBuffer = [];
+  _lineBuffer = "";
+  _pendingReads = [];
+  constructor(address) {
+    super(address);
+  }
+  /**
+   * Connect to the Geode server using QUIC.
+   */
+  static async connect(cfg) {
+    const address = getAddress(cfg);
+    const transport = new _MatrixQuicTransport(address);
+    try {
+      const { QUICClient } = await import('@matrixai/quic');
+      const [host = "localhost", portStr] = address.includes("[") ? [address.slice(1, address.lastIndexOf("]")), address.slice(address.lastIndexOf(":") + 1)] : address.split(":");
+      const port = parseInt(portStr ?? "3141", 10);
+      const cryptoOps = {
+        ops: {
+          randomBytes: (data) => {
+            const buf = Buffer.from(data);
+            crypto.randomFillSync(buf);
+            return Promise.resolve();
+          }
+        }
+      };
+      const tlsConfig = await buildTLSConfig(cfg);
+      const config = {
+        applicationProtos: GEODE_ALPN,
+        maxIdleTimeout: cfg.maxIdleTime ?? 3e4,
+        initialMaxData: 1e7,
+        initialMaxStreamDataBidiLocal: 1e6,
+        initialMaxStreamDataBidiRemote: 1e6,
+        initialMaxStreamsBidi: 100
+      };
+      if (cfg.insecureSkipVerify) {
+        config.verifyPeer = false;
+      }
+      if (tlsConfig.ca) {
+        config.caCerts = [tlsConfig.ca];
+      }
+      if (tlsConfig.cert && tlsConfig.key) {
+        config.cert = tlsConfig.cert;
+        config.key = tlsConfig.key;
+      }
+      const client = await QUICClient.createQUICClient(
+        {
+          host,
+          port,
+          serverName: cfg.serverName ?? host,
+          crypto: cryptoOps,
+          config
+        },
+        { timer: cfg.connectTimeout ?? 3e4 }
+      );
+      transport._client = client;
+      const connection = client.connection;
+      const stream = await connection.newStream();
+      transport._stream = stream;
+      transport.startReading();
+      return transport;
+    } catch (e) {
+      await transport.close();
+      throw new TransportError({
+        operation: "connect",
+        address,
+        cause: e instanceof Error ? e : new Error(String(e))
+      });
+    }
+  }
+  /**
+   * Start reading from the stream in the background.
+   */
+  startReading() {
+    if (!this._stream) return;
+    const stream = this._stream;
+    const reader = stream.readable.getReader();
+    const read = async () => {
+      try {
+        while (!this._closed) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value) {
+            this.processData(Buffer.from(value));
+          }
+        }
+      } catch {
+      } finally {
+        reader.releaseLock();
+      }
+    };
+    void read();
+  }
+  /**
+   * Process received data, splitting by newlines.
+   */
+  processData(data) {
+    this._lineBuffer += data.toString("utf-8");
+    let newlineIdx;
+    while ((newlineIdx = this._lineBuffer.indexOf("\n")) !== -1) {
+      const line = this._lineBuffer.slice(0, newlineIdx);
+      this._lineBuffer = this._lineBuffer.slice(newlineIdx + 1);
+      if (line.length > 0) {
+        const pending = this._pendingReads.shift();
+        if (pending) {
+          pending.resolve(Buffer.from(line, "utf-8"));
+        } else {
+          this._readBuffer.push(Buffer.from(line, "utf-8"));
+        }
+      }
+    }
+  }
+  async send(msg, signal) {
+    this.checkClosed();
+    if (signal?.aborted) {
+      throw new TransportError({ operation: "send", cause: new Error("Aborted") });
+    }
+    if (!this._stream) {
+      throw new TransportError({ operation: "send", cause: new Error("No stream") });
+    }
+    const data = Buffer.from(JSON.stringify(msg) + "\n", "utf-8");
+    try {
+      const stream = this._stream;
+      const writer = stream.writable.getWriter();
+      await writer.write(new Uint8Array(data));
+      writer.releaseLock();
+    } catch (e) {
+      throw new TransportError({
+        operation: "send",
+        address: this._address,
+        cause: e instanceof Error ? e : new Error(String(e))
+      });
+    }
+  }
+  async receive(signal) {
+    this.checkClosed();
+    if (signal?.aborted) {
+      throw new TransportError({ operation: "receive", cause: new Error("Aborted") });
+    }
+    const buffered = this._readBuffer.shift();
+    if (buffered) {
+      return buffered;
+    }
+    return new Promise((resolve, reject) => {
+      if (signal) {
+        const onAbort = () => {
+          reject(new TransportError({ operation: "receive", cause: new Error("Aborted") }));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      this._pendingReads.push({ resolve, reject });
+    });
+  }
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    for (const pending of this._pendingReads) {
+      pending.reject(ErrClosed);
+    }
+    this._pendingReads = [];
+    if (this._client) {
+      try {
+        const client = this._client;
+        await client.destroy();
+      } catch {
+      }
+      this._client = null;
+    }
+    this._stream = null;
+  }
+};
+var MockTransport = class extends BaseTransport {
+  _sendQueue = [];
+  _receiveQueue = [];
+  _pendingReads = [];
+  constructor(address = "mock:3141") {
+    super(address);
+  }
+  /**
+   * Queue a response to be returned by receive().
+   */
+  queueResponse(response) {
+    const data = Buffer.from(JSON.stringify(response), "utf-8");
+    this._receiveQueue.push(data);
+    const pending = this._pendingReads.shift();
+    if (pending) {
+      const queued = this._receiveQueue.shift();
+      if (queued) {
+        pending.resolve(queued);
+      }
+    }
+  }
+  /**
+   * Get all sent messages.
+   */
+  getSentMessages() {
+    return [...this._sendQueue];
+  }
+  /**
+   * Clear sent messages.
+   */
+  clearSentMessages() {
+    this._sendQueue = [];
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async send(msg, signal) {
+    this.checkClosed();
+    if (signal?.aborted) {
+      throw new TransportError({ operation: "send", cause: new Error("Aborted") });
+    }
+    this._sendQueue.push(msg);
+  }
+  async receive(signal) {
+    this.checkClosed();
+    if (signal?.aborted) {
+      throw new TransportError({ operation: "receive", cause: new Error("Aborted") });
+    }
+    const queued = this._receiveQueue.shift();
+    if (queued) {
+      return queued;
+    }
+    return new Promise((resolve, reject) => {
+      if (signal) {
+        const onAbort = () => {
+          reject(new TransportError({ operation: "receive", cause: new Error("Aborted") }));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      this._pendingReads.push({ resolve, reject });
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    for (const pending of this._pendingReads) {
+      pending.reject(ErrClosed);
+    }
+    this._pendingReads = [];
+  }
+};
+async function createTransport(cfg) {
+  return MatrixQuicTransport.connect(cfg);
+}
+
+// src/connection.ts
+init_protocol();
+init_validate();
+init_types();
+
+// src/transaction.ts
+init_errors();
+var Transaction = class {
+  _conn;
+  _done = false;
+  _savepoints = [];
+  constructor(conn) {
+    this._conn = conn;
+  }
+  /**
+   * Check if transaction is complete (committed or rolled back).
+   */
+  get isDone() {
+    return this._done;
+  }
+  /**
+   * Get the list of active savepoints.
+   */
+  get savepoints() {
+    return this._savepoints;
+  }
+  /**
+   * Execute a query within the transaction.
+   */
+  async query(query2, options) {
+    this.checkDone();
+    return this._conn.query(query2, options);
+  }
+  /**
+   * Execute a query and return all rows.
+   */
+  async queryAll(query2, options) {
+    this.checkDone();
+    return this._conn.queryAll(query2, options);
+  }
+  /**
+   * Execute a statement that doesn't return rows.
+   */
+  async exec(query2, options) {
+    this.checkDone();
+    return this._conn.exec(query2, options);
+  }
+  /**
+   * Create a savepoint.
+   */
+  async savepoint(name, signal) {
+    this.checkDone();
+    await this._conn._savepoint(name, signal);
+    this._savepoints.push(name);
+  }
+  /**
+   * Rollback to a savepoint.
+   */
+  async rollbackTo(name, signal) {
+    this.checkDone();
+    const idx = this._savepoints.indexOf(name);
+    if (idx === -1) {
+      throw new Error(`Savepoint not found: ${name}`);
+    }
+    await this._conn._rollbackTo(name, signal);
+    this._savepoints = this._savepoints.slice(0, idx);
+  }
+  /**
+   * Release a savepoint.
+   *
+   * Note: Geode doesn't have explicit RELEASE SAVEPOINT, but we track it client-side.
+   */
+  release(name) {
+    this.checkDone();
+    const idx = this._savepoints.indexOf(name);
+    if (idx === -1) {
+      throw new Error(`Savepoint not found: ${name}`);
+    }
+    this._savepoints.splice(idx, 1);
+  }
+  /**
+   * Commit the transaction.
+   */
+  async commit(signal) {
+    this.checkDone();
+    this._done = true;
+    await this._conn._commit(signal);
+    this._savepoints = [];
+  }
+  /**
+   * Rollback the transaction.
+   */
+  async rollback(signal) {
+    this.checkDone();
+    this._done = true;
+    await this._conn._rollback(signal);
+    this._savepoints = [];
+  }
+  /**
+   * Execute a function within the transaction with automatic commit/rollback.
+   */
+  async run(fn) {
+    this.checkDone();
+    try {
+      const result = await fn(this);
+      await this.commit();
+      return result;
+    } catch (e) {
+      if (!this._done) {
+        await this.rollback();
+      }
+      throw e;
+    }
+  }
+  /**
+   * Check if transaction is already done.
+   */
+  checkDone() {
+    if (this._done) {
+      throw ErrTxDone;
+    }
+    if (!this._conn.inTransaction) {
+      throw ErrNoTx;
+    }
+  }
+};
+async function withTransaction(conn, fn, signal) {
+  const tx = await conn.begin(signal);
+  return tx.run(fn);
+}
+
+// src/result.ts
+init_types();
+var QueryResult = class {
+  _conn;
+  _columns;
+  _buffer;
+  _final;
+  _ordered;
+  _orderKeys;
+  _pageSize;
+  _signal;
+  _closed = false;
+  _bufferIndex = 0;
+  _rowCount = 0;
+  constructor(conn, columns, initialRows, final, ordered, orderKeys, pageSize, signal) {
+    this._conn = conn;
+    this._columns = columns;
+    this._buffer = initialRows;
+    this._final = final;
+    this._ordered = ordered;
+    this._orderKeys = orderKeys;
+    this._pageSize = pageSize;
+    this._signal = signal;
+  }
+  /**
+   * Get column definitions.
+   */
+  get columns() {
+    return this._columns;
+  }
+  /**
+   * Get column names.
+   */
+  get columnNames() {
+    return this._columns.map((c) => c.name);
+  }
+  /**
+   * Check if results are ordered.
+   */
+  get ordered() {
+    return this._ordered;
+  }
+  /**
+   * Get order keys (if ordered).
+   */
+  get orderKeys() {
+    return this._orderKeys;
+  }
+  /**
+   * Check if all results have been fetched.
+   */
+  get complete() {
+    return this._final && this._bufferIndex >= this._buffer.length;
+  }
+  /**
+   * Check if result is closed.
+   */
+  get isClosed() {
+    return this._closed;
+  }
+  /**
+   * Get the number of rows returned so far.
+   */
+  get rowCount() {
+    return this._rowCount;
+  }
+  /**
+   * Async iterator implementation.
+   */
+  async *[Symbol.asyncIterator]() {
+    try {
+      while (!this._closed) {
+        if (this._signal?.aborted) {
+          break;
+        }
+        while (this._bufferIndex < this._buffer.length) {
+          const rawRow = this._buffer[this._bufferIndex];
+          if (rawRow) {
+            this._bufferIndex++;
+            this._rowCount++;
+            yield parseRow(rawRow, this._columns);
+          }
+        }
+        if (this._final) {
+          break;
+        }
+        const { rows, final } = await this._conn._fetchNextPage(this._pageSize, this._signal);
+        this._buffer = rows;
+        this._bufferIndex = 0;
+        this._final = final;
+      }
+    } finally {
+      this.close();
+    }
+  }
+  /**
+   * Get all remaining rows as an array.
+   */
+  async toArray() {
+    const rows = [];
+    for await (const row of this) {
+      rows.push(row);
+    }
+    return rows;
+  }
+  /**
+   * Get all remaining rows as plain objects.
+   */
+  async toObjects() {
+    const rows = [];
+    for await (const row of this) {
+      rows.push(rowToObject(row));
+    }
+    return rows;
+  }
+  /**
+   * Get the first row (or null if empty).
+   */
+  async first() {
+    for await (const row of this) {
+      this.close();
+      return row;
+    }
+    return null;
+  }
+  /**
+   * Get the first row as plain object (or null if empty).
+   */
+  async firstObject() {
+    const row = await this.first();
+    return row ? rowToObject(row) : null;
+  }
+  /**
+   * Apply a function to each row.
+   */
+  async forEach(fn) {
+    let index = 0;
+    for await (const row of this) {
+      await fn(row, index++);
+    }
+  }
+  /**
+   * Map rows to a new array.
+   */
+  async map(fn) {
+    const results = [];
+    let index = 0;
+    for await (const row of this) {
+      results.push(await fn(row, index++));
+    }
+    return results;
+  }
+  /**
+   * Filter rows.
+   */
+  async filter(predicate2) {
+    const results = [];
+    let index = 0;
+    for await (const row of this) {
+      if (await predicate2(row, index++)) {
+        results.push(row);
+      }
+    }
+    return results;
+  }
+  /**
+   * Reduce rows to a single value.
+   */
+  async reduce(fn, initial) {
+    let acc = initial;
+    let index = 0;
+    for await (const row of this) {
+      acc = await fn(acc, row, index++);
+    }
+    return acc;
+  }
+  /**
+   * Close the result set.
+   */
+  close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    this._conn._releaseResult(this);
+  }
+  /**
+   * Internal close (called by connection).
+   */
+  _close() {
+    this._closed = true;
+  }
+};
+var QueryResultIterator = class {
+  _result;
+  _iterator;
+  constructor(result) {
+    this._result = result;
+    this._iterator = result[Symbol.asyncIterator]();
+  }
+  /**
+   * Get the next row.
+   */
+  async next() {
+    const result = await this._iterator.next();
+    return {
+      done: result.done ?? false,
+      value: result.done ? void 0 : result.value
+    };
+  }
+  /**
+   * Close the iterator.
+   */
+  close() {
+    this._result.close();
+  }
+};
+
+// src/connection.ts
+var Connection = class _Connection {
+  _config;
+  _transport;
+  _state = "idle";
+  _inTransaction = false;
+  _activeResult = null;
+  _requestId = 0;
+  constructor(config, transport) {
+    this._config = config;
+    this._transport = transport;
+  }
+  /**
+   * Create a new connection to the Geode server.
+   */
+  static async connect(config) {
+    validateConfig(config);
+    const transport = await createTransport(config);
+    const conn = new _Connection(config, transport);
+    try {
+      await conn.hello();
+      return conn;
+    } catch (e) {
+      await transport.close();
+      throw e;
+    }
+  }
+  /**
+   * Create a connection with a custom transport (for testing).
+   */
+  static async connectWithTransport(config, transport) {
+    const conn = new _Connection(config, transport);
+    await conn.hello();
+    return conn;
+  }
+  /**
+   * Get connection configuration.
+   */
+  get config() {
+    return this._config;
+  }
+  /**
+   * Get current connection state.
+   */
+  get state() {
+    return this._state;
+  }
+  /**
+   * Check if connection is in a transaction.
+   */
+  get inTransaction() {
+    return this._inTransaction;
+  }
+  /**
+   * Check if connection is closed.
+   */
+  get isClosed() {
+    return this._state === "closed" || this._transport.isClosed();
+  }
+  /**
+   * Perform the HELLO handshake.
+   *
+   * Note: The server may return an ERROR frame with "Authentication required"
+   * even when no authentication is configured. This is a known server behavior
+   * that should be treated as a successful connection (matching other clients).
+   */
+  async hello() {
+    const msg = buildHelloMessage(this._config);
+    await this._transport.send(msg);
+    const data = await this._transport.receive();
+    const frame = parseFrame(data);
+    if (isErrorFrame(frame)) {
+      const statusClass = frame.status_class || frame.result.code;
+      if (statusClass !== "28000" || this._config.username || this._config.password) {
+        throw frameToError(frame);
+      }
+    }
+  }
+  /**
+   * Execute a query that returns rows.
+   */
+  async query(query2, options) {
+    this.checkState("query");
+    validateQuery(query2);
+    let finalQuery = query2;
+    let params = options?.params ?? {};
+    if (query2.includes("?") && Array.isArray(options?.params)) {
+      const result = rewritePlaceholders(query2, options.params);
+      finalQuery = result.query;
+      params = result.params;
+    }
+    for (const [_key, value] of Object.entries(params)) {
+      validateParamValue(value);
+    }
+    const signal = options?.signal;
+    try {
+      this._state = "fetching";
+      await this._transport.send(buildRunGQLMessage(finalQuery, params), signal);
+      const schemaData = await this._transport.receive(signal);
+      const schemaFrame = parseFrame(schemaData);
+      if (isErrorFrame(schemaFrame)) {
+        this._state = this._inTransaction ? "in_transaction" : "idle";
+        throw frameToError(schemaFrame);
+      }
+      if (!isSchemaFrame(schemaFrame)) {
+        this._state = this._inTransaction ? "in_transaction" : "idle";
+        throw new TransportError({
+          operation: "query",
+          cause: new Error(`Expected SCHEMA frame, got ${schemaFrame.result.type}`)
+        });
+      }
+      const columns = getColumnsFromSchema(schemaFrame);
+      const inlineFrame = await this._tryReceiveInlineFrame(signal);
+      if (inlineFrame) {
+        if (isErrorFrame(inlineFrame)) {
+          this._state = this._inTransaction ? "in_transaction" : "idle";
+          throw frameToError(inlineFrame);
+        }
+        const result2 = new QueryResult(
+          this,
+          columns,
+          inlineFrame.result.rows ?? [],
+          inlineFrame.result.final ?? true,
+          inlineFrame.result.ordered ?? false,
+          inlineFrame.result.order_keys ?? [],
+          options?.pageSize ?? this._config.pageSize,
+          signal
+        );
+        this._activeResult = result2;
+        return result2;
+      }
+      this._requestId++;
+      const pageSize = options?.pageSize ?? this._config.pageSize;
+      await this._transport.send(buildPullMessage(this._requestId, pageSize), signal);
+      const bindingsData = await this._transport.receive(signal);
+      const bindingsFrame = parseFrame(bindingsData);
+      if (isErrorFrame(bindingsFrame)) {
+        this._state = this._inTransaction ? "in_transaction" : "idle";
+        throw frameToError(bindingsFrame);
+      }
+      const result = new QueryResult(
+        this,
+        columns,
+        bindingsFrame.result.rows ?? [],
+        bindingsFrame.result.final ?? true,
+        bindingsFrame.result.ordered ?? false,
+        bindingsFrame.result.order_keys ?? [],
+        pageSize,
+        signal
+      );
+      this._activeResult = result;
+      return result;
+    } catch (e) {
+      this._state = this._inTransaction ? "in_transaction" : "idle";
+      throw e;
+    }
+  }
+  /**
+   * Execute a query and return all rows as an array.
+   */
+  async queryAll(query2, options) {
+    const result = await this.query(query2, options);
+    const rows = [];
+    for await (const row of result) {
+      rows.push(rowToObject(row));
+    }
+    return rows;
+  }
+  /**
+   * Execute a query that doesn't return rows.
+   */
+  async exec(query2, options) {
+    this.checkState("exec");
+    validateQuery(query2);
+    let finalQuery = query2;
+    let params = options?.params ?? {};
+    if (query2.includes("?") && Array.isArray(options?.params)) {
+      const result = rewritePlaceholders(query2, options.params);
+      finalQuery = result.query;
+      params = result.params;
+    }
+    for (const [_key, value] of Object.entries(params)) {
+      validateParamValue(value);
+    }
+    const signal = options?.signal;
+    try {
+      this._state = "executing";
+      await this._transport.send(buildRunGQLMessage(finalQuery, params), signal);
+      const data = await this._transport.receive(signal);
+      const frame = parseFrame(data);
+      if (isErrorFrame(frame)) {
+        throw frameToError(frame);
+      }
+      if (frame.result.type === RespType.SCHEMA) {
+        const inlineFrame = await this._tryReceiveInlineFrame(signal);
+        if (inlineFrame && isErrorFrame(inlineFrame)) {
+          throw frameToError(inlineFrame);
+        }
+      }
+    } finally {
+      this._state = this._inTransaction ? "in_transaction" : "idle";
+    }
+  }
+  /**
+   * Fetch the next page of results (internal).
+   */
+  async _fetchNextPage(pageSize, signal) {
+    this._requestId++;
+    await this._transport.send(buildPullMessage(this._requestId, pageSize), signal);
+    const data = await this._transport.receive(signal);
+    const frame = parseFrame(data);
+    if (isErrorFrame(frame)) {
+      throw frameToError(frame);
+    }
+    const resultType = frame.result.type;
+    if (resultType === RespType.BINDINGS) {
+      return {
+        rows: frame.result.rows ?? [],
+        final: frame.result.final ?? true
+      };
+    }
+    return {
+      rows: [],
+      final: true
+    };
+  }
+  async _tryReceiveInlineFrame(signal) {
+    if (signal?.aborted) {
+      return null;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1);
+    try {
+      const data = await this._transport.receive(controller.signal);
+      return parseFrame(data);
+    } catch (err) {
+      if (err instanceof TransportError && err.cause?.message === "Aborted") {
+        return null;
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Release active result (internal).
+   */
+  _releaseResult(result) {
+    if (this._activeResult === result) {
+      this._activeResult = null;
+      this._state = this._inTransaction ? "in_transaction" : "idle";
+    }
+  }
+  /**
+   * Begin a transaction.
+   */
+  async begin(signal) {
+    this.checkState("begin");
+    if (this._inTransaction) {
+      throw ErrTxInProgress;
+    }
+    await this._transport.send(buildBeginMessage(), signal);
+    const data = await this._transport.receive(signal);
+    const frame = parseFrame(data);
+    if (isErrorFrame(frame)) {
+      throw frameToError(frame);
+    }
+    this._inTransaction = true;
+    this._state = "in_transaction";
+    return new Transaction(this);
+  }
+  /**
+   * Commit the current transaction (internal).
+   */
+  async _commit(signal) {
+    await this._transport.send(buildCommitMessage(), signal);
+    const data = await this._transport.receive(signal);
+    const frame = parseFrame(data);
+    if (isErrorFrame(frame)) {
+      throw frameToError(frame);
+    }
+    this._inTransaction = false;
+    this._state = "idle";
+  }
+  /**
+   * Rollback the current transaction (internal).
+   */
+  async _rollback(signal) {
+    await this._transport.send(buildRollbackMessage(), signal);
+    const data = await this._transport.receive(signal);
+    const frame = parseFrame(data);
+    if (isErrorFrame(frame)) {
+      throw frameToError(frame);
+    }
+    this._inTransaction = false;
+    this._state = "idle";
+  }
+  /**
+   * Create a savepoint (internal).
+   */
+  async _savepoint(name, signal) {
+    validateSavepointName(name);
+    await this._transport.send(buildSavepointMessage(name), signal);
+    const data = await this._transport.receive(signal);
+    const frame = parseFrame(data);
+    if (isErrorFrame(frame)) {
+      throw frameToError(frame);
+    }
+  }
+  /**
+   * Rollback to a savepoint (internal).
+   */
+  async _rollbackTo(name, signal) {
+    validateSavepointName(name);
+    await this._transport.send(buildRollbackToMessage(name), signal);
+    const data = await this._transport.receive(signal);
+    const frame = parseFrame(data);
+    if (isErrorFrame(frame)) {
+      throw frameToError(frame);
+    }
+  }
+  /**
+   * Ping the server to check connection health.
+   */
+  async ping(signal) {
+    if (this._state === "closed") {
+      throw ErrClosed;
+    }
+    await this._transport.send(buildPingMessage(), signal);
+    const data = await this._transport.receive(signal);
+    const frame = parseFrame(data);
+    if (isErrorFrame(frame)) {
+      throw frameToError(frame);
+    }
+  }
+  /**
+   * Reset the connection session.
+   */
+  async reset(signal) {
+    if (this._state === "closed") {
+      throw ErrClosed;
+    }
+    if (this._inTransaction) {
+      await this._rollback(signal);
+    }
+    this._state = "idle";
+    this._activeResult = null;
+  }
+  /**
+   * Close the connection.
+   */
+  async close() {
+    if (this._state === "closed") {
+      return;
+    }
+    this._state = "closed";
+    if (this._activeResult) {
+      this._activeResult._close();
+      this._activeResult = null;
+    }
+    await this._transport.close();
+  }
+  /**
+   * Create a prepared statement.
+   *
+   * @param query - Query text with parameters
+   * @returns Prepared statement
+   */
+  async prepare(query2) {
+    const { PreparedStatement: PreparedStatement2 } = await Promise.resolve().then(() => (init_prepared(), prepared_exports));
+    return new PreparedStatement2(this, query2);
+  }
+  /**
+   * Get the query execution plan without executing.
+   *
+   * @param query - Query to explain
+   * @param options - Options including parameters
+   * @returns Query execution plan
+   */
+  async explain(query2, options) {
+    const { explain: doExplain } = await Promise.resolve().then(() => (init_explain(), explain_exports));
+    return doExplain(this, query2, options);
+  }
+  /**
+   * Execute a query with profiling.
+   *
+   * @param query - Query to profile
+   * @param options - Options including parameters
+   * @returns Query execution profile
+   */
+  async profile(query2, options) {
+    const { profile: doProfile } = await Promise.resolve().then(() => (init_explain(), explain_exports));
+    return doProfile(this, query2, options);
+  }
+  /**
+   * Execute multiple queries in a batch.
+   *
+   * @param queries - Array of queries to execute
+   * @param options - Batch execution options
+   * @returns Batch execution summary
+   */
+  async batch(queries, options) {
+    const { batch: doBatch } = await Promise.resolve().then(() => (init_batch(), batch_exports));
+    return doBatch(this, queries, options);
+  }
+  /**
+   * Check connection state before operation.
+   */
+  checkState(operation) {
+    if (this._state === "closed") {
+      throw ErrClosed;
+    }
+    if (this._state === "fetching" || this._activeResult) {
+      throw ErrQueryInProgress;
+    }
+    if (operation === "begin" && this._inTransaction) {
+      throw ErrTxInProgress;
+    }
+  }
+};
+
+// src/pool.ts
+init_errors();
+var ConnectionPool = class _ConnectionPool {
+  _config;
+  _connections = [];
+  _waitQueue = [];
+  _closed = false;
+  _maintenanceInterval;
+  // Pool configuration with defaults
+  _minConnections;
+  _maxConnections;
+  _acquireTimeout;
+  _idleTimeout;
+  constructor(config) {
+    this._config = config;
+    this._minConnections = config.minConnections ?? 2;
+    this._maxConnections = config.maxConnections ?? 10;
+    this._acquireTimeout = config.acquireTimeout ?? 3e4;
+    this._idleTimeout = config.idleTimeout ?? 6e4;
+    this._maintenanceInterval = setInterval(() => {
+      this.maintenance();
+    }, 1e4);
+  }
+  /**
+   * Create a new connection pool.
+   */
+  static async create(config) {
+    const pool = new _ConnectionPool(config);
+    const initPromises = [];
+    for (let i = 0; i < pool._minConnections; i++) {
+      initPromises.push(pool.addConnection());
+    }
+    try {
+      await Promise.all(initPromises);
+    } catch (e) {
+      await pool.close();
+      throw e;
+    }
+    return pool;
+  }
+  /**
+   * Get pool statistics.
+   */
+  get stats() {
+    const available = this._connections.filter((c) => !c.inUse).length;
+    const inUse = this._connections.filter((c) => c.inUse).length;
+    return {
+      total: this._connections.length,
+      available,
+      inUse,
+      waiting: this._waitQueue.length
+    };
+  }
+  /**
+   * Check if pool is closed.
+   */
+  get isClosed() {
+    return this._closed;
+  }
+  /**
+   * Acquire a connection from the pool.
+   */
+  async acquire(signal) {
+    if (this._closed) {
+      throw ErrClosed;
+    }
+    if (signal?.aborted) {
+      throw new TransportError({ operation: "acquire", cause: new Error("Aborted") });
+    }
+    const available = this._connections.find((c) => !c.inUse && !c.connection.isClosed);
+    if (available) {
+      available.inUse = true;
+      available.lastUsedAt = Date.now();
+      return available.connection;
+    }
+    if (this._connections.length < this._maxConnections) {
+      try {
+        await this.addConnection();
+        const newConn = this._connections.find((c) => !c.inUse && !c.connection.isClosed);
+        if (newConn) {
+          newConn.inUse = true;
+          newConn.lastUsedAt = Date.now();
+          return newConn.connection;
+        }
+      } catch {
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const idx = this._waitQueue.findIndex((w) => w.resolve === resolve && w.reject === reject);
+        if (idx !== -1) {
+          this._waitQueue.splice(idx, 1);
+        }
+        reject(
+          new TransportError({
+            operation: "acquire",
+            cause: new Error("Connection pool acquire timeout")
+          })
+        );
+      }, this._acquireTimeout);
+      const cleanup = () => {
+        clearTimeout(timeout);
+      };
+      if (signal) {
+        signal.addEventListener(
+          "abort",
+          () => {
+            cleanup();
+            const idx = this._waitQueue.findIndex(
+              (w) => w.resolve === resolve && w.reject === reject
+            );
+            if (idx !== -1) {
+              this._waitQueue.splice(idx, 1);
+            }
+            reject(new TransportError({ operation: "acquire", cause: new Error("Aborted") }));
+          },
+          { once: true }
+        );
+      }
+      this._waitQueue.push({
+        resolve: (conn) => {
+          cleanup();
+          resolve(conn);
+        },
+        reject: (err) => {
+          cleanup();
+          reject(err);
+        },
+        signal
+      });
+    });
+  }
+  /**
+   * Release a connection back to the pool.
+   */
+  async release(conn) {
+    const pooledConn = this._connections.find((c) => c.connection === conn);
+    if (!pooledConn) {
+      return;
+    }
+    try {
+      if (conn.inTransaction) {
+        await conn.reset();
+      }
+    } catch {
+      await this.removeConnection(pooledConn);
+      return;
+    }
+    pooledConn.inUse = false;
+    pooledConn.lastUsedAt = Date.now();
+    const waiter = this._waitQueue.shift();
+    if (waiter) {
+      pooledConn.inUse = true;
+      waiter.resolve(conn);
+    }
+  }
+  /**
+   * Execute a function with a connection from the pool.
+   */
+  async withConnection(fn, signal) {
+    const conn = await this.acquire(signal);
+    try {
+      return await fn(conn);
+    } finally {
+      await this.release(conn);
+    }
+  }
+  /**
+   * Execute a query using a pooled connection.
+   */
+  async query(query2, options) {
+    return this.withConnection((conn) => conn.query(query2, options), options?.signal);
+  }
+  /**
+   * Execute a query and return all rows.
+   */
+  async queryAll(query2, options) {
+    return this.withConnection((conn) => conn.queryAll(query2, options), options?.signal);
+  }
+  /**
+   * Execute a statement that doesn't return rows.
+   */
+  async exec(query2, options) {
+    return this.withConnection((conn) => conn.exec(query2, options), options?.signal);
+  }
+  /**
+   * Execute a function within a transaction.
+   */
+  async withTransaction(fn, signal) {
+    return this.withConnection((conn) => withTransaction(conn, fn, signal), signal);
+  }
+  /**
+   * Ping to verify pool health.
+   */
+  async ping(signal) {
+    return this.withConnection((conn) => conn.ping(signal), signal);
+  }
+  /**
+   * Close the pool and all connections.
+   */
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    if (this._maintenanceInterval) {
+      clearInterval(this._maintenanceInterval);
+      this._maintenanceInterval = void 0;
+    }
+    for (const waiter of this._waitQueue) {
+      waiter.reject(ErrClosed);
+    }
+    this._waitQueue = [];
+    const closePromises = this._connections.map(async (c) => {
+      try {
+        await c.connection.close();
+      } catch {
+      }
+    });
+    await Promise.all(closePromises);
+    this._connections = [];
+  }
+  /**
+   * Add a new connection to the pool.
+   */
+  async addConnection() {
+    const conn = await Connection.connect(this._config);
+    this._connections.push({
+      connection: conn,
+      createdAt: Date.now(),
+      lastUsedAt: Date.now(),
+      inUse: false
+    });
+  }
+  /**
+   * Remove a connection from the pool.
+   */
+  async removeConnection(pooledConn) {
+    const idx = this._connections.indexOf(pooledConn);
+    if (idx !== -1) {
+      this._connections.splice(idx, 1);
+    }
+    try {
+      await pooledConn.connection.close();
+    } catch {
+    }
+  }
+  /**
+   * Perform pool maintenance.
+   */
+  maintenance() {
+    if (this._closed) {
+      return;
+    }
+    const now = Date.now();
+    const idleConnections = this._connections.filter((c) => !c.inUse && now - c.lastUsedAt > this._idleTimeout).sort((a, b) => a.lastUsedAt - b.lastUsedAt);
+    const toRemove = Math.max(0, idleConnections.length - this._minConnections);
+    for (let i = 0; i < toRemove; i++) {
+      const conn = idleConnections[i];
+      if (conn) {
+        this.removeConnection(conn).catch(() => {
+        });
+      }
+    }
+    for (const conn of this._connections.filter((c) => c.connection.isClosed)) {
+      this.removeConnection(conn).catch(() => {
+      });
+    }
+    const available = this._connections.filter((c) => !c.connection.isClosed).length;
+    const toCreate = this._minConnections - available;
+    for (let i = 0; i < toCreate; i++) {
+      this.addConnection().catch(() => {
+      });
+    }
+  }
+};
+
+// src/client.ts
+init_config();
+var GeodeClient = class _GeodeClient {
+  _config;
+  _pool;
+  _connection;
+  constructor(config) {
+    this._config = config;
+  }
+  /**
+   * Create a new client from a DSN string.
+   */
+  static async connect(dsn, options) {
+    const config = parseDSN(dsn);
+    if (options) {
+      Object.assign(config, options);
+    }
+    const usePool = options?.pooling ?? true;
+    const client = new _GeodeClient(config);
+    if (usePool) {
+      const poolConfig = {
+        ...config,
+        minConnections: options?.pool?.min,
+        maxConnections: options?.pool?.max,
+        acquireTimeout: options?.pool?.acquireTimeout,
+        idleTimeout: options?.pool?.idleTimeout
+      };
+      client._pool = await ConnectionPool.create(poolConfig);
+    } else {
+      client._connection = await Connection.connect(config);
+    }
+    return client;
+  }
+  /**
+   * Create a new client from configuration.
+   */
+  static async connectWithConfig(config, options) {
+    const usePool = options?.pooling ?? true;
+    const client = new _GeodeClient(config);
+    if (usePool) {
+      const poolConfig = {
+        ...config,
+        minConnections: options?.pool?.min,
+        maxConnections: options?.pool?.max,
+        acquireTimeout: options?.pool?.acquireTimeout,
+        idleTimeout: options?.pool?.idleTimeout
+      };
+      client._pool = await ConnectionPool.create(poolConfig);
+    } else {
+      client._connection = await Connection.connect(config);
+    }
+    return client;
+  }
+  /**
+   * Get the client configuration.
+   */
+  get config() {
+    return this._config;
+  }
+  /**
+   * Check if client is closed.
+   */
+  get isClosed() {
+    if (this._pool) {
+      return this._pool.isClosed;
+    }
+    return this._connection?.isClosed ?? true;
+  }
+  /**
+   * Get pool statistics (if using pooling).
+   */
+  get poolStats() {
+    return this._pool?.stats ?? null;
+  }
+  /**
+   * Execute a query and return results.
+   */
+  async query(query2, options) {
+    if (this._pool) {
+      return this._pool.query(query2, options);
+    }
+    if (!this._connection) {
+      throw new Error("Client is not connected");
+    }
+    return this._connection.query(query2, options);
+  }
+  /**
+   * Execute a query and return all rows as objects.
+   */
+  async queryAll(query2, options) {
+    if (this._pool) {
+      return this._pool.queryAll(query2, options);
+    }
+    if (!this._connection) {
+      throw new Error("Client is not connected");
+    }
+    return this._connection.queryAll(query2, options);
+  }
+  /**
+   * Execute a query and return the first row.
+   */
+  async queryFirst(query2, options) {
+    const result = await this.query(query2, options);
+    return result.firstObject();
+  }
+  /**
+   * Execute a query and return a scalar value.
+   */
+  async queryScalar(query2, column, options) {
+    const row = await this.queryFirst(query2, options);
+    if (!row) {
+      return null;
+    }
+    return row[column];
+  }
+  /**
+   * Execute a statement that doesn't return rows.
+   */
+  async exec(query2, options) {
+    if (this._pool) {
+      return this._pool.exec(query2, options);
+    }
+    if (!this._connection) {
+      throw new Error("Client is not connected");
+    }
+    return this._connection.exec(query2, options);
+  }
+  /**
+   * Execute multiple statements.
+   */
+  async execBatch(queries) {
+    for (const q of queries) {
+      await this.exec(q.query, { params: q.params });
+    }
+  }
+  /**
+   * Execute a function within a transaction.
+   */
+  async withTransaction(fn, signal) {
+    if (this._pool) {
+      return this._pool.withTransaction(fn, signal);
+    }
+    if (!this._connection) {
+      throw new Error("Client is not connected");
+    }
+    return withTransaction(this._connection, fn, signal);
+  }
+  /**
+   * Get a raw connection from the pool (or the single connection).
+   *
+   * The connection must be released after use.
+   */
+  async getConnection(signal) {
+    if (this._pool) {
+      return this._pool.acquire(signal);
+    }
+    if (!this._connection) {
+      throw new Error("Client is not connected");
+    }
+    return this._connection;
+  }
+  /**
+   * Release a connection back to the pool.
+   *
+   * Only needed when using getConnection() with pooling.
+   */
+  async releaseConnection(conn) {
+    if (this._pool) {
+      return this._pool.release(conn);
+    }
+  }
+  /**
+   * Execute a function with a dedicated connection.
+   */
+  async withConnection(fn, signal) {
+    if (this._pool) {
+      return this._pool.withConnection(fn, signal);
+    }
+    if (!this._connection) {
+      throw new Error("Client is not connected");
+    }
+    return fn(this._connection);
+  }
+  /**
+   * Ping the server to check connectivity.
+   */
+  async ping(signal) {
+    if (this._pool) {
+      return this._pool.ping(signal);
+    }
+    if (!this._connection) {
+      throw new Error("Client is not connected");
+    }
+    return this._connection.ping(signal);
+  }
+  /**
+   * Close the client and release all resources.
+   */
+  async close() {
+    if (this._pool) {
+      await this._pool.close();
+      this._pool = void 0;
+    }
+    if (this._connection) {
+      await this._connection.close();
+      this._connection = void 0;
+    }
+  }
+  // Convenience methods for common graph operations
+  /**
+   * Create a node with labels and properties.
+   */
+  async createNode(labels, properties) {
+    const labelStr = Array.isArray(labels) ? labels.join(":") : labels;
+    const propsStr = properties ? " $props" : "";
+    const result = await this.queryFirst(
+      `CREATE (n:${labelStr}${propsStr}) RETURN n`,
+      properties ? { params: { props: properties } } : void 0
+    );
+    return result?.["n"];
+  }
+  /**
+   * Find nodes by label and optional property filter.
+   */
+  async findNodes(label, filter, options) {
+    let query2 = `MATCH (n:${label})`;
+    if (filter && Object.keys(filter).length > 0) {
+      const conditions = Object.keys(filter).map((k) => `n.${k} = $${k}`).join(" AND ");
+      query2 += ` WHERE ${conditions}`;
+    }
+    query2 += " RETURN n";
+    if (options?.skip) {
+      query2 += ` SKIP ${options.skip}`;
+    }
+    if (options?.limit) {
+      query2 += ` LIMIT ${options.limit}`;
+    }
+    const rows = await this.queryAll(query2, { params: filter });
+    return rows.map((r) => r["n"]);
+  }
+  /**
+   * Find a single node by label and property.
+   */
+  async findNode(label, property, value) {
+    const rows = await this.findNodes(label, { [property]: value }, { limit: 1 });
+    return rows[0] ?? null;
+  }
+  /**
+   * Create a relationship between two nodes.
+   */
+  async createRelationship(startLabel, startProp, startValue, type, endLabel, endProp, endValue, properties) {
+    const propsStr = properties ? " $props" : "";
+    const result = await this.queryFirst(
+      `MATCH (a:${startLabel}), (b:${endLabel})
+       WHERE a.${startProp} = $startValue AND b.${endProp} = $endValue
+       CREATE (a)-[r:${type}${propsStr}]->(b)
+       RETURN r`,
+      {
+        params: {
+          startValue,
+          endValue,
+          ...properties ? { props: properties } : {}
+        }
+      }
+    );
+    return result?.["r"];
+  }
+  /**
+   * Delete a node by label and property.
+   */
+  async deleteNode(label, property, value) {
+    const result = await this.queryFirst(
+      `MATCH (n:${label}) WHERE n.${property} = $value DETACH DELETE n RETURN count(n) AS deleted`,
+      { params: { value } }
+    );
+    return result?.["deleted"] ?? 0;
+  }
+  /**
+   * Update node properties.
+   */
+  async updateNode(label, matchProp, matchValue, updates) {
+    const setStatements = Object.keys(updates).map((k) => `n.${k} = $${k}`).join(", ");
+    const result = await this.queryFirst(
+      `MATCH (n:${label}) WHERE n.${matchProp} = $matchValue SET ${setStatements} RETURN n`,
+      { params: { matchValue, ...updates } }
+    );
+    return result?.["n"];
+  }
+  /**
+   * Count nodes by label.
+   */
+  async countNodes(label, filter) {
+    let query2 = `MATCH (n:${label})`;
+    if (filter && Object.keys(filter).length > 0) {
+      const conditions = Object.keys(filter).map((k) => `n.${k} = $${k}`).join(" AND ");
+      query2 += ` WHERE ${conditions}`;
+    }
+    query2 += " RETURN count(n) AS count";
+    const result = await this.queryFirst(query2, { params: filter });
+    return result?.["count"] ?? 0;
+  }
+  // Advanced operations
+  /**
+   * Create a prepared statement.
+   *
+   * @param query - Query text with parameters
+   * @returns Prepared statement
+   *
+   * @example
+   * ```typescript
+   * const stmt = client.prepare('MATCH (n:Person {name: $name}) RETURN n');
+   * const result1 = await stmt.query({ name: 'Alice' });
+   * const result2 = await stmt.query({ name: 'Bob' });
+   * stmt.close();
+   * ```
+   */
+  async prepare(query2) {
+    const conn = await this.getConnection();
+    try {
+      return conn.prepare(query2);
+    } finally {
+      await this.releaseConnection(conn);
+    }
+  }
+  /**
+   * Get the query execution plan without executing.
+   *
+   * @param query - Query to explain
+   * @param options - Options including parameters
+   * @returns Query execution plan
+   *
+   * @example
+   * ```typescript
+   * const plan = await client.explain('MATCH (n:Person)-[:KNOWS]->(m) RETURN n, m');
+   * console.log('Estimated cost:', plan.totalCost);
+   * ```
+   */
+  async explain(query2, options) {
+    const conn = await this.getConnection(options?.signal);
+    try {
+      return await conn.explain(query2, options);
+    } finally {
+      await this.releaseConnection(conn);
+    }
+  }
+  /**
+   * Execute a query with profiling.
+   *
+   * @param query - Query to profile
+   * @param options - Options including parameters
+   * @returns Query execution profile
+   *
+   * @example
+   * ```typescript
+   * const profile = await client.profile('MATCH (n:Person) RETURN count(n)');
+   * console.log('Execution time:', profile.totalTimeMs, 'ms');
+   * ```
+   */
+  async profile(query2, options) {
+    const conn = await this.getConnection(options?.signal);
+    try {
+      return await conn.profile(query2, options);
+    } finally {
+      await this.releaseConnection(conn);
+    }
+  }
+  /**
+   * Execute multiple queries in a batch.
+   *
+   * @param queries - Array of queries to execute
+   * @param options - Batch execution options
+   * @returns Batch execution summary
+   *
+   * @example
+   * ```typescript
+   * const summary = await client.batch([
+   *   { query: 'CREATE (a:Person {name: "Alice"})' },
+   *   { query: 'CREATE (b:Person {name: "Bob"})' },
+   * ]);
+   * console.log(`${summary.successful}/${summary.total} succeeded`);
+   * ```
+   */
+  async batch(queries, options) {
+    const conn = await this.getConnection(options?.signal);
+    try {
+      return await conn.batch(queries, options);
+    } finally {
+      await this.releaseConnection(conn);
+    }
+  }
+  /**
+   * Get an auth client for user and role management.
+   *
+   * @returns Auth client
+   *
+   * @example
+   * ```typescript
+   * const auth = await client.auth();
+   * await auth.createUser('alice', { password: 'secret123' });
+   * await auth.assignRole('alice', 'analyst');
+   * ```
+   */
+  async auth() {
+    const { AuthClient: AuthClient2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+    const conn = await this.getConnection();
+    return new AuthClient2(conn);
+  }
+};
+async function createClient(dsn, options) {
+  return GeodeClient.connect(dsn, options);
+}
+async function createClientWithConfig(config, options) {
+  return GeodeClient.connectWithConfig(config, options);
+}
+
+// src/index.ts
+init_config();
+init_types();
+init_errors();
+init_protocol();
+init_validate();
+
+// src/query-builder.ts
+var NodePatternBuilder = class {
+  _variable;
+  _labels = [];
+  _properties = {};
+  /**
+   * Set the variable name.
+   */
+  as(variable) {
+    this._variable = variable;
+    return this;
+  }
+  /**
+   * Add a label.
+   */
+  label(label) {
+    this._labels.push(label);
+    return this;
+  }
+  /**
+   * Add multiple labels.
+   */
+  labels(...labels) {
+    this._labels.push(...labels);
+    return this;
+  }
+  /**
+   * Set a property.
+   */
+  prop(key, value) {
+    this._properties[key] = value;
+    return this;
+  }
+  /**
+   * Set multiple properties.
+   */
+  props(properties) {
+    Object.assign(this._properties, properties);
+    return this;
+  }
+  /**
+   * Build the pattern.
+   */
+  build() {
+    return {
+      variable: this._variable,
+      labels: this._labels.length > 0 ? this._labels : void 0,
+      properties: Object.keys(this._properties).length > 0 ? this._properties : void 0
+    };
+  }
+  /**
+   * Convert to GQL string.
+   */
+  toGQL() {
+    let result = "(";
+    if (this._variable) {
+      result += this._variable;
+    }
+    if (this._labels.length > 0) {
+      result += ":" + this._labels.join(":");
+    }
+    if (Object.keys(this._properties).length > 0) {
+      result += " " + propsToGQL(this._properties);
+    }
+    return result + ")";
+  }
+};
+var EdgePatternBuilder = class {
+  _variable;
+  _type;
+  _direction = "outgoing";
+  _properties = {};
+  _minHops;
+  _maxHops;
+  /**
+   * Set the variable name.
+   */
+  as(variable) {
+    this._variable = variable;
+    return this;
+  }
+  /**
+   * Set the relationship type.
+   */
+  type(type) {
+    this._type = type;
+    return this;
+  }
+  /**
+   * Set outgoing direction.
+   */
+  outgoing() {
+    this._direction = "outgoing";
+    return this;
+  }
+  /**
+   * Set incoming direction.
+   */
+  incoming() {
+    this._direction = "incoming";
+    return this;
+  }
+  /**
+   * Set bidirectional.
+   */
+  both() {
+    this._direction = "both";
+    return this;
+  }
+  /**
+   * Set direction.
+   */
+  direction(dir) {
+    this._direction = dir;
+    return this;
+  }
+  /**
+   * Set a property.
+   */
+  prop(key, value) {
+    this._properties[key] = value;
+    return this;
+  }
+  /**
+   * Set multiple properties.
+   */
+  props(properties) {
+    Object.assign(this._properties, properties);
+    return this;
+  }
+  /**
+   * Set variable length path.
+   */
+  hops(min, max) {
+    this._minHops = min;
+    this._maxHops = max;
+    return this;
+  }
+  /**
+   * Build the pattern.
+   */
+  build() {
+    return {
+      variable: this._variable,
+      type: this._type,
+      direction: this._direction,
+      properties: Object.keys(this._properties).length > 0 ? this._properties : void 0,
+      minHops: this._minHops,
+      maxHops: this._maxHops
+    };
+  }
+  /**
+   * Convert to GQL string.
+   */
+  toGQL() {
+    const hasContent = this._variable || this._type || Object.keys(this._properties).length > 0;
+    let inner = "";
+    if (hasContent) {
+      inner = "[";
+      if (this._variable) {
+        inner += this._variable;
+      }
+      if (this._type) {
+        inner += ":" + this._type;
+      }
+      if (this._minHops !== void 0 || this._maxHops !== void 0) {
+        inner += "*";
+        if (this._minHops !== void 0) {
+          inner += this._minHops;
+        }
+        inner += "..";
+        if (this._maxHops !== void 0) {
+          inner += this._maxHops;
+        }
+      }
+      if (Object.keys(this._properties).length > 0) {
+        inner += " " + propsToGQL(this._properties);
+      }
+      inner += "]";
+    }
+    switch (this._direction) {
+      case "outgoing":
+        return `-${inner}->`;
+      case "incoming":
+        return `<-${inner}-`;
+      case "both":
+        return `-${inner}-`;
+    }
+  }
+};
+var PatternBuilder = class {
+  _elements = [];
+  /**
+   * Add a node to the pattern.
+   */
+  node(builder) {
+    const nodeBuilder = new NodePatternBuilder();
+    if (builder) {
+      builder(nodeBuilder);
+    }
+    this._elements.push({ kind: "node", pattern: nodeBuilder.build() });
+    return this;
+  }
+  /**
+   * Add an outgoing edge to the pattern.
+   */
+  outgoing(builder) {
+    const edgeBuilder = new EdgePatternBuilder().outgoing();
+    if (builder) {
+      builder(edgeBuilder);
+    }
+    this._elements.push({ kind: "edge", pattern: edgeBuilder.build() });
+    return this;
+  }
+  /**
+   * Add an incoming edge to the pattern.
+   */
+  incoming(builder) {
+    const edgeBuilder = new EdgePatternBuilder().incoming();
+    if (builder) {
+      builder(edgeBuilder);
+    }
+    this._elements.push({ kind: "edge", pattern: edgeBuilder.build() });
+    return this;
+  }
+  /**
+   * Add a bidirectional edge to the pattern.
+   */
+  related(builder) {
+    const edgeBuilder = new EdgePatternBuilder().both();
+    if (builder) {
+      builder(edgeBuilder);
+    }
+    this._elements.push({ kind: "edge", pattern: edgeBuilder.build() });
+    return this;
+  }
+  /**
+   * Convert to GQL string.
+   */
+  toGQL() {
+    let result = "";
+    for (const element of this._elements) {
+      if (element.kind === "node") {
+        result += nodePatternToGQL(element.pattern);
+      } else {
+        result += edgePatternToGQL(element.pattern);
+      }
+    }
+    return result;
+  }
+};
+var PredicateBuilder = class {
+  _predicates = [];
+  _params = {};
+  _paramCounter = 0;
+  /**
+   * Add a comparison predicate.
+   */
+  compare(left, op, right) {
+    if (op === "IS NULL") {
+      this._predicates.push(`${left} IS NULL`);
+    } else if (op === "IS NOT NULL") {
+      this._predicates.push(`${left} IS NOT NULL`);
+    } else {
+      const paramName = this.nextParam();
+      this._predicates.push(`${left} ${op} $${paramName}`);
+      this._params[paramName] = right;
+    }
+    return this;
+  }
+  /**
+   * Add an equality predicate.
+   */
+  eq(left, right) {
+    return this.compare(left, "=", right);
+  }
+  /**
+   * Add a not-equal predicate.
+   */
+  neq(left, right) {
+    return this.compare(left, "<>", right);
+  }
+  /**
+   * Add a less-than predicate.
+   */
+  lt(left, right) {
+    return this.compare(left, "<", right);
+  }
+  /**
+   * Add a less-than-or-equal predicate.
+   */
+  lte(left, right) {
+    return this.compare(left, "<=", right);
+  }
+  /**
+   * Add a greater-than predicate.
+   */
+  gt(left, right) {
+    return this.compare(left, ">", right);
+  }
+  /**
+   * Add a greater-than-or-equal predicate.
+   */
+  gte(left, right) {
+    return this.compare(left, ">=", right);
+  }
+  /**
+   * Add an IN predicate.
+   */
+  in(left, values) {
+    const paramName = this.nextParam();
+    this._predicates.push(`${left} IN $${paramName}`);
+    this._params[paramName] = values;
+    return this;
+  }
+  /**
+   * Add a NOT IN predicate.
+   */
+  notIn(left, values) {
+    const paramName = this.nextParam();
+    this._predicates.push(`${left} NOT IN $${paramName}`);
+    this._params[paramName] = values;
+    return this;
+  }
+  /**
+   * Add a CONTAINS predicate.
+   */
+  contains(left, value) {
+    return this.compare(left, "CONTAINS", value);
+  }
+  /**
+   * Add a STARTS WITH predicate.
+   */
+  startsWith(left, value) {
+    return this.compare(left, "STARTS WITH", value);
+  }
+  /**
+   * Add an ENDS WITH predicate.
+   */
+  endsWith(left, value) {
+    return this.compare(left, "ENDS WITH", value);
+  }
+  /**
+   * Add an IS NULL predicate.
+   */
+  isNull(expr) {
+    return this.compare(expr, "IS NULL", null);
+  }
+  /**
+   * Add an IS NOT NULL predicate.
+   */
+  isNotNull(expr) {
+    return this.compare(expr, "IS NOT NULL", null);
+  }
+  /**
+   * Add a raw predicate expression.
+   */
+  raw(expr, params) {
+    this._predicates.push(expr);
+    if (params) {
+      Object.assign(this._params, params);
+    }
+    return this;
+  }
+  /**
+   * Combine predicates with AND.
+   */
+  and(builder) {
+    const sub = builder.build();
+    if (sub.predicate) {
+      this._predicates.push(`(${sub.predicate})`);
+      Object.assign(this._params, sub.params);
+    }
+    return this;
+  }
+  /**
+   * Combine predicates with OR.
+   */
+  or(builder) {
+    const sub = builder.build();
+    if (sub.predicate) {
+      if (this._predicates.length > 0) {
+        const current = this._predicates.join(" AND ");
+        this._predicates = [`(${current}) OR (${sub.predicate})`];
+      } else {
+        this._predicates.push(sub.predicate);
+      }
+      Object.assign(this._params, sub.params);
+    }
+    return this;
+  }
+  /**
+   * Build the predicate.
+   */
+  build() {
+    return {
+      predicate: this._predicates.join(" AND "),
+      params: this._params
+    };
+  }
+  nextParam() {
+    return `pred_${++this._paramCounter}`;
+  }
+};
+var QueryBuilder = class {
+  _clauses = [];
+  _params = {};
+  /**
+   * Add a MATCH clause.
+   */
+  match(pattern2) {
+    const p = typeof pattern2 === "string" ? pattern2 : pattern2.toGQL();
+    this._clauses.push(`MATCH ${p}`);
+    return this;
+  }
+  /**
+   * Add an OPTIONAL MATCH clause.
+   */
+  optionalMatch(pattern2) {
+    const p = typeof pattern2 === "string" ? pattern2 : pattern2.toGQL();
+    this._clauses.push(`OPTIONAL MATCH ${p}`);
+    return this;
+  }
+  /**
+   * Add a WHERE clause.
+   */
+  where(predicate2, params) {
+    if (typeof predicate2 === "string") {
+      this._clauses.push(`WHERE ${predicate2}`);
+      if (params) {
+        Object.assign(this._params, params);
+      }
+    } else {
+      const built = predicate2.build();
+      this._clauses.push(`WHERE ${built.predicate}`);
+      Object.assign(this._params, built.params);
+    }
+    return this;
+  }
+  /**
+   * Add a WITH clause.
+   */
+  with(...expressions) {
+    this._clauses.push(`WITH ${expressions.join(", ")}`);
+    return this;
+  }
+  /**
+   * Add a RETURN clause.
+   */
+  return(...expressions) {
+    this._clauses.push(`RETURN ${expressions.join(", ")}`);
+    return this;
+  }
+  /**
+   * Add RETURN DISTINCT.
+   */
+  returnDistinct(...expressions) {
+    this._clauses.push(`RETURN DISTINCT ${expressions.join(", ")}`);
+    return this;
+  }
+  /**
+   * Add an ORDER BY clause.
+   */
+  orderBy(...expressions) {
+    const parts = expressions.map((e) => {
+      if (typeof e === "string") {
+        return e;
+      }
+      return `${e[0]} ${e[1]}`;
+    });
+    this._clauses.push(`ORDER BY ${parts.join(", ")}`);
+    return this;
+  }
+  /**
+   * Add a SKIP clause.
+   */
+  skip(count) {
+    this._clauses.push(`SKIP ${count}`);
+    return this;
+  }
+  /**
+   * Add a LIMIT clause.
+   */
+  limit(count) {
+    this._clauses.push(`LIMIT ${count}`);
+    return this;
+  }
+  /**
+   * Add a CREATE clause.
+   */
+  create(pattern2) {
+    const p = typeof pattern2 === "string" ? pattern2 : pattern2.toGQL();
+    this._clauses.push(`CREATE ${p}`);
+    return this;
+  }
+  /**
+   * Add a MERGE clause.
+   */
+  merge(pattern2) {
+    const p = typeof pattern2 === "string" ? pattern2 : pattern2.toGQL();
+    this._clauses.push(`MERGE ${p}`);
+    return this;
+  }
+  /**
+   * Add a DELETE clause.
+   */
+  delete(...variables) {
+    this._clauses.push(`DELETE ${variables.join(", ")}`);
+    return this;
+  }
+  /**
+   * Add a DETACH DELETE clause.
+   */
+  detachDelete(...variables) {
+    this._clauses.push(`DETACH DELETE ${variables.join(", ")}`);
+    return this;
+  }
+  /**
+   * Add a SET clause.
+   */
+  set(...assignments) {
+    this._clauses.push(`SET ${assignments.join(", ")}`);
+    return this;
+  }
+  /**
+   * Add a REMOVE clause.
+   */
+  remove(...items) {
+    this._clauses.push(`REMOVE ${items.join(", ")}`);
+    return this;
+  }
+  /**
+   * Add raw clause.
+   */
+  raw(clause, params) {
+    this._clauses.push(clause);
+    if (params) {
+      Object.assign(this._params, params);
+    }
+    return this;
+  }
+  /**
+   * Add a parameter.
+   */
+  param(name, value) {
+    this._params[name] = value;
+    return this;
+  }
+  /**
+   * Add multiple parameters.
+   */
+  params(params) {
+    Object.assign(this._params, params);
+    return this;
+  }
+  /**
+   * Build the query string.
+   */
+  build() {
+    return {
+      query: this._clauses.join("\n"),
+      params: this._params
+    };
+  }
+  /**
+   * Get the query string.
+   */
+  toGQL() {
+    return this._clauses.join("\n");
+  }
+  /**
+   * Get the parameters.
+   */
+  getParams() {
+    return { ...this._params };
+  }
+};
+function propsToGQL(props) {
+  const entries = Object.entries(props).map(([k, v]) => `${k}: ${valueToGQL(v)}`);
+  return `{${entries.join(", ")}}`;
+}
+function valueToGQL(value) {
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return `'${value.replace(/'/g, "\\'")}'`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(valueToGQL).join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    return propsToGQL(value);
+  }
+  return String(value);
+}
+function nodePatternToGQL(pattern2) {
+  let result = "(";
+  if (pattern2.variable) {
+    result += pattern2.variable;
+  }
+  if (pattern2.labels && pattern2.labels.length > 0) {
+    result += ":" + pattern2.labels.join(":");
+  }
+  if (pattern2.properties && Object.keys(pattern2.properties).length > 0) {
+    result += " " + propsToGQL(pattern2.properties);
+  }
+  return result + ")";
+}
+function edgePatternToGQL(pattern2) {
+  const hasContent = pattern2.variable || pattern2.type || pattern2.properties && Object.keys(pattern2.properties).length > 0;
+  let inner = "";
+  if (hasContent) {
+    inner = "[";
+    if (pattern2.variable) {
+      inner += pattern2.variable;
+    }
+    if (pattern2.type) {
+      inner += ":" + pattern2.type;
+    }
+    if (pattern2.minHops !== void 0 || pattern2.maxHops !== void 0) {
+      inner += "*";
+      if (pattern2.minHops !== void 0) {
+        inner += pattern2.minHops;
+      }
+      inner += "..";
+      if (pattern2.maxHops !== void 0) {
+        inner += pattern2.maxHops;
+      }
+    }
+    if (pattern2.properties && Object.keys(pattern2.properties).length > 0) {
+      inner += " " + propsToGQL(pattern2.properties);
+    }
+    inner += "]";
+  }
+  switch (pattern2.direction) {
+    case "outgoing":
+      return `-${inner}->`;
+    case "incoming":
+      return `<-${inner}-`;
+    case "both":
+      return `-${inner}-`;
+  }
+}
+function query() {
+  return new QueryBuilder();
+}
+function pattern() {
+  return new PatternBuilder();
+}
+function predicate() {
+  return new PredicateBuilder();
+}
+function node() {
+  return new NodePatternBuilder();
+}
+function edge() {
+  return new EdgePatternBuilder();
+}
+
+// src/index.ts
+init_prepared();
+init_explain();
+init_batch();
+init_auth();
+
+export { AuthClient, BaseTransport, ConfigError, Connection, ConnectionPool, DEFAULT_CONFORMANCE, DEFAULT_HELLO_NAME, DEFAULT_HELLO_VERSION, DEFAULT_PAGE_SIZE, DEFAULT_PORT, DriverError, EdgePatternBuilder, ErrBadConn, ErrClosed, ErrNoTx, ErrQueryInProgress, ErrRowsClosed, ErrTxDone, ErrTxInProgress, GQLValue, GeodeClient, MAX_PAGE_SIZE, MAX_QUERY_LENGTH, MockTransport, MsgType, NodePatternBuilder, PatternBuilder, PredicateBuilder, PreparedStatement, QueryBuilder, QueryResult, QueryResultIterator, MatrixQuicTransport as QuicheTransport, RespType, SecurityError, StateError, StatusClass, Transaction, TransportError, batch, batchAll, batchFirst, batchMap, batchParallel, buildBeginMessage, buildCommitMessage, buildHelloMessage, buildPingMessage, buildPullMessage, buildRollbackMessage, buildRollbackToMessage, buildRunGQLMessage, buildSavepointMessage, buildTLSConfig, cloneConfig, countPlaceholders, createAuthClient, createClient, createClientWithConfig, createTransport, defaultConfig, edge, explain, extractParameters, formatPlan, formatProfile, frameToError, fromJSON, getAddress, getColumnsFromSchema, isBindingsFrame, isDriverError, isErrorFrame, isFinalFrame, isGeodeError, isRetryableError, isSchemaFrame, mergeParams, node, parseDSN, parseFrame, parseGQLType, parseRow, pattern, predicate, prepare, profile, query, rewritePlaceholders, rowToObject, sanitizeForLog, serializeMessage, validateConfig, validateHostname, validatePageSize, validateParamName, validateParamValue, validatePort, validateQuery, validateSavepointName, withTransaction };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map