@xbbg/core 1.2.1 → 1.2.3

package/dist/index.js

@@ -1,9 +1,9 @@
 'use strict';
 
+var apacheArrow = require('apache-arrow');
 var fs2 = require('fs');
-var path2 = require('path');
 var module$1 = require('module');
-var apacheArrow = require('apache-arrow');
+var path2 = require('path');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -11,88 +11,10 @@ var fs2__default = /*#__PURE__*/_interopDefault(fs2);
 var path2__default = /*#__PURE__*/_interopDefault(path2);
 
 // src/index.ts
-
-// src/errors.ts
-var BlpError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-  }
-};
-var BlpSessionError = class extends BlpError {
-};
-var BlpRequestError = class extends BlpError {
-  service;
-  operation;
-  request_id;
-  code;
-  constructor(message, options = {}) {
-    super(message);
-    this.service = options.service;
-    this.operation = options.operation;
-    this.request_id = options.request_id;
-    this.code = options.code;
-  }
-};
-var BlpValidationError = class extends BlpError {
-  element;
-  suggestion;
-  constructor(message, options = {}) {
-    super(message);
-    this.element = options.element;
-    this.suggestion = options.suggestion;
-  }
-};
-var BlpTimeoutError = class extends BlpError {
-};
-var BlpInternalError = class extends BlpError {
-};
-function wrapError(napiError) {
-  if (napiError instanceof BlpError) {
-    return napiError;
-  }
-  const msg = napiError instanceof Error ? napiError.message : typeof napiError === "string" ? napiError : "";
-  if (msg.includes("Session start failed") || msg.includes("session start failed") || msg.includes("Failed to start session") || msg.includes("Failed to open service") || msg.includes("failed to spawn worker") || msg.includes("connect event failed")) {
-    return new BlpSessionError(msg);
-  }
-  if (msg.includes("Request failed") || msg.includes("Subscription failed")) {
-    const options = parseRequestOptions(msg);
-    return new BlpRequestError(msg, options);
-  }
-  if (msg.includes("Invalid argument") || msg.includes("Configuration error") || msg.includes("Operation not found") || msg.includes("Schema element not found") || msg.includes("Schema type mismatch") || msg.includes("Unsupported schema") || msg.includes("invalid extractor") || msg.includes("(did you mean")) {
-    const options = parseValidationOptions(msg);
-    return new BlpValidationError(msg, options);
-  }
-  if (msg.includes("Request timed out")) {
-    return new BlpTimeoutError(msg);
-  }
-  if (msg.includes("Internal error") || msg.includes("Channel closed") || msg.includes("Stream buffer full") || msg.includes("Request was cancelled")) {
-    return new BlpInternalError(msg);
-  }
-  return new BlpError(msg);
-}
-function parseRequestOptions(msg) {
-  const options = {};
-  const serviceOpMatch = /on ([^:]+)::([^ (]+)/.exec(msg);
-  if (serviceOpMatch !== null) {
-    options.service = serviceOpMatch[1];
-    options.operation = serviceOpMatch[2];
-  }
-  const requestIdMatch = /\[request_id=([^\]]+)\]/.exec(msg);
-  if (requestIdMatch !== null) {
-    options.request_id = requestIdMatch[1];
-  }
-  return options;
-}
-function parseValidationOptions(msg) {
-  const options = {};
-  const suggestionMatch = /\(did you mean '([^']+)'\?\)/.exec(msg);
-  if (suggestionMatch !== null) {
-    options.suggestion = suggestionMatch[1];
-  }
-  return options;
-}
 var NATIVE_ARROW_BUFFERS = /* @__PURE__ */ Symbol("@xbbg/nativeArrowBuffers");
+function unsupportedNativeArrowType(type) {
+  throw new Error(`Unsupported native Arrow column type: ${String(type)}`);
+}
 function tableFromNativeArrowBatch(batch) {
   const retainedBuffers = [];
   const fields = batch.columns.map((column) => {
@@ -102,21 +24,21 @@ function tableFromNativeArrowBatch(batch) {
   const children = batch.columns.map((column) => dataFromColumn(column, retainedBuffers));
   const schema = new apacheArrow.Schema(fields);
   const structData = apacheArrow.makeData({
-    type: new apacheArrow.Struct(fields),
+    children,
     length: batch.numRows,
-    children
+    type: new apacheArrow.Struct(fields)
   });
   const table = new apacheArrow.Table(schema, new apacheArrow.RecordBatch(schema, structData));
   Object.defineProperty(table, NATIVE_ARROW_BUFFERS, {
-    value: retainedBuffers,
-    enumerable: false
+    enumerable: false,
+    value: retainedBuffers
   });
   return table;
 }
 function dataFromColumn(column, retainedBuffers) {
   const nullBitmap = optionalUint8View(column.nullBitmap, retainedBuffers);
   switch (column.type) {
-    case "bool":
+    case "bool": {
       return apacheArrow.makeData({
         type: new apacheArrow.Bool(),
         length: column.length,
@@ -124,7 +46,8 @@ function dataFromColumn(column, retainedBuffers) {
         nullBitmap,
         data: requiredUint8View(column, retainedBuffers, Math.ceil(column.length / 8))
       });
-    case "binary":
+    }
+    case "binary": {
       return apacheArrow.makeData({
         type: new apacheArrow.Binary(),
         length: column.length,
@@ -133,23 +56,32 @@ function dataFromColumn(column, retainedBuffers) {
         valueOffsets: requiredOffsets(column, retainedBuffers),
         data: requiredUint8View(column, retainedBuffers)
       });
-    case "date32":
+    }
+    case "date32": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.DateDay(), Int32Array);
-    case "date64":
+    }
+    case "date64": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.DateMillisecond(), BigInt64Array);
-    case "float32":
+    }
+    case "float32": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Float32(), Float32Array);
-    case "float64":
+    }
+    case "float64": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Float64(), Float64Array);
-    case "int8":
+    }
+    case "int8": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Int8(), Int8Array);
-    case "int16":
+    }
+    case "int16": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Int16(), Int16Array);
-    case "int32":
+    }
+    case "int32": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Int32(), Int32Array);
-    case "int64":
+    }
+    case "int64": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Int64(), BigInt64Array);
-    case "large_binary":
+    }
+    case "large_binary": {
       return apacheArrow.makeData({
         type: new apacheArrow.LargeBinary(),
         length: column.length,
@@ -158,7 +90,8 @@ function dataFromColumn(column, retainedBuffers) {
         valueOffsets: requiredLargeOffsets(column, retainedBuffers),
         data: requiredUint8View(column, retainedBuffers)
       });
-    case "large_utf8":
+    }
+    case "large_utf8": {
       return apacheArrow.makeData({
         type: new apacheArrow.LargeUtf8(),
         length: column.length,
@@ -167,20 +100,26 @@ function dataFromColumn(column, retainedBuffers) {
         valueOffsets: requiredLargeOffsets(column, retainedBuffers),
         data: requiredUint8View(column, retainedBuffers)
       });
-    case "null":
+    }
+    case "null": {
       return apacheArrow.makeData({
         type: new apacheArrow.Null(),
         length: column.length
       });
-    case "time32_ms":
+    }
+    case "time32_ms": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.TimeMillisecond(), Int32Array);
-    case "time32_s":
+    }
+    case "time32_s": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.TimeSecond(), Int32Array);
-    case "time64_us":
+    }
+    case "time64_us": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.TimeMicrosecond(), BigInt64Array);
-    case "time64_ns":
+    }
+    case "time64_ns": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.TimeNanosecond(), BigInt64Array);
-    case "timestamp_ms":
+    }
+    case "timestamp_ms": {
       return scalarData(
         column,
         retainedBuffers,
@@ -188,7 +127,8 @@ function dataFromColumn(column, retainedBuffers) {
         new apacheArrow.TimestampMillisecond(column.timezone),
         BigInt64Array
       );
-    case "timestamp_ns":
+    }
+    case "timestamp_ns": {
       return scalarData(
         column,
         retainedBuffers,
@@ -196,7 +136,8 @@ function dataFromColumn(column, retainedBuffers) {
         new apacheArrow.TimestampNanosecond(column.timezone),
         BigInt64Array
       );
-    case "timestamp_s":
+    }
+    case "timestamp_s": {
       return scalarData(
         column,
         retainedBuffers,
@@ -204,7 +145,8 @@ function dataFromColumn(column, retainedBuffers) {
         new apacheArrow.TimestampSecond(column.timezone),
         BigInt64Array
       );
-    case "timestamp_us":
+    }
+    case "timestamp_us": {
       return scalarData(
         column,
         retainedBuffers,
@@ -212,15 +154,20 @@ function dataFromColumn(column, retainedBuffers) {
         new apacheArrow.TimestampMicrosecond(column.timezone),
         BigInt64Array
       );
-    case "uint8":
+    }
+    case "uint8": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Uint8(), Uint8Array);
-    case "uint16":
+    }
+    case "uint16": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Uint16(), Uint16Array);
-    case "uint32":
+    }
+    case "uint32": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Uint32(), Uint32Array);
-    case "uint64":
+    }
+    case "uint64": {
       return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Uint64(), BigUint64Array);
-    case "utf8":
+    }
+    case "utf8": {
       return apacheArrow.makeData({
         type: new apacheArrow.Utf8(),
         length: column.length,
@@ -229,90 +176,137 @@ function dataFromColumn(column, retainedBuffers) {
         valueOffsets: requiredOffsets(column, retainedBuffers),
         data: requiredUint8View(column, retainedBuffers)
       });
+    }
   }
+  return unsupportedNativeArrowType(column.type);
 }
 function arrowType(column) {
   switch (column.type) {
-    case "bool":
+    case "bool": {
       return new apacheArrow.Bool();
-    case "binary":
+    }
+    case "binary": {
       return new apacheArrow.Binary();
-    case "date32":
+    }
+    case "date32": {
       return new apacheArrow.DateDay();
-    case "date64":
+    }
+    case "date64": {
       return new apacheArrow.DateMillisecond();
-    case "float32":
+    }
+    case "float32": {
       return new apacheArrow.Float32();
-    case "float64":
+    }
+    case "float64": {
       return new apacheArrow.Float64();
-    case "int8":
+    }
+    case "int8": {
       return new apacheArrow.Int8();
-    case "int16":
+    }
+    case "int16": {
       return new apacheArrow.Int16();
-    case "int32":
+    }
+    case "int32": {
       return new apacheArrow.Int32();
-    case "int64":
+    }
+    case "int64": {
       return new apacheArrow.Int64();
-    case "large_binary":
+    }
+    case "large_binary": {
       return new apacheArrow.LargeBinary();
-    case "large_utf8":
+    }
+    case "large_utf8": {
       return new apacheArrow.LargeUtf8();
-    case "null":
+    }
+    case "null": {
       return new apacheArrow.Null();
-    case "time32_ms":
+    }
+    case "time32_ms": {
       return new apacheArrow.TimeMillisecond();
-    case "time32_s":
+    }
+    case "time32_s": {
       return new apacheArrow.TimeSecond();
-    case "time64_us":
+    }
+    case "time64_us": {
       return new apacheArrow.TimeMicrosecond();
-    case "time64_ns":
+    }
+    case "time64_ns": {
       return new apacheArrow.TimeNanosecond();
-    case "timestamp_ms":
+    }
+    case "timestamp_ms": {
       return new apacheArrow.TimestampMillisecond(column.timezone);
-    case "timestamp_ns":
+    }
+    case "timestamp_ns": {
       return new apacheArrow.TimestampNanosecond(column.timezone);
-    case "timestamp_s":
+    }
+    case "timestamp_s": {
       return new apacheArrow.TimestampSecond(column.timezone);
-    case "timestamp_us":
+    }
+    case "timestamp_us": {
       return new apacheArrow.TimestampMicrosecond(column.timezone);
-    case "uint8":
+    }
+    case "uint8": {
       return new apacheArrow.Uint8();
-    case "uint16":
+    }
+    case "uint16": {
       return new apacheArrow.Uint16();
-    case "uint32":
+    }
+    case "uint32": {
       return new apacheArrow.Uint32();
-    case "uint64":
+    }
+    case "uint64": {
       return new apacheArrow.Uint64();
-    case "utf8":
+    }
+    case "utf8": {
       return new apacheArrow.Utf8();
+    }
   }
+  return unsupportedNativeArrowType(column.type);
 }
 function scalarData(column, retainedBuffers, nullBitmap, type, ctor) {
   return apacheArrow.makeData({
-    type,
+    data: requiredTypedView(column, ctor, retainedBuffers),
     length: column.length,
-    nullCount: column.nullCount,
     nullBitmap,
-    data: requiredTypedView(column, ctor, retainedBuffers)
+    nullCount: column.nullCount,
+    type
   });
 }
 function requiredTypedView(column, ctor, retainedBuffers) {
   const buffer = requireBuffer(column, "data");
+  assertBufferByteLength(column, "data", buffer, column.length, ctor.BYTES_PER_ELEMENT);
   retainedBuffers.push(buffer);
   return new ctor(buffer.buffer, buffer.byteOffset, column.length);
 }
 function requiredOffsets(column, retainedBuffers) {
   const buffer = requireBuffer(column, "offsets");
+  assertBufferByteLength(
+    column,
+    "offsets",
+    buffer,
+    column.length + 1,
+    Int32Array.BYTES_PER_ELEMENT
+  );
   retainedBuffers.push(buffer);
   return new Int32Array(buffer.buffer, buffer.byteOffset, column.length + 1);
 }
 function requiredLargeOffsets(column, retainedBuffers) {
   const buffer = requireBuffer(column, "offsets");
+  assertBufferByteLength(
+    column,
+    "offsets",
+    buffer,
+    column.length + 1,
+    BigInt64Array.BYTES_PER_ELEMENT
+  );
   retainedBuffers.push(buffer);
   return new BigInt64Array(buffer.buffer, buffer.byteOffset, column.length + 1);
 }
 function requiredUint8View(column, retainedBuffers, byteLength) {
   const buffer = requireBuffer(column, "data");
+  if (byteLength !== void 0) {
+    assertBufferByteLength(column, "data", buffer, byteLength, 1);
+  }
   retainedBuffers.push(buffer);
   return new Uint8Array(buffer.buffer, buffer.byteOffset, byteLength ?? buffer.byteLength);
 }
@@ -323,6 +317,19 @@ function optionalUint8View(buffer, retainedBuffers) {
   retainedBuffers.push(buffer);
   return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
 }
+function assertBufferByteLength(column, property, buffer, elements, bytesPerElement) {
+  if (!Number.isSafeInteger(elements) || elements < 0) {
+    throw new Error(
+      `native Arrow column ${column.name} has invalid ${property} element count: ${elements}`
+    );
+  }
+  const requiredBytes = elements * bytesPerElement;
+  if (!Number.isSafeInteger(requiredBytes) || buffer.byteLength < requiredBytes) {
+    throw new Error(
+      `native Arrow column ${column.name} ${property} buffer is too small: expected at least ${requiredBytes} bytes, got ${buffer.byteLength}`
+    );
+  }
+}
 function requireBuffer(column, property) {
   const buffer = column[property];
   if (buffer === void 0) {
@@ -332,9 +339,9 @@ function requireBuffer(column, property) {
 }
 
 // src/dates.ts
-var ISO_DATE_RE = /^\d{4}[-/]\d{2}[-/]\d{2}$/;
-var BBG_DATE_RE = /^\d{8}$/;
-var AMBIGUOUS_DATE_RE = /^\d{1,2}[-/]\d{1,2}[-/]\d{2,4}([T \D]|$)/;
+var ISO_DATE_RE = /^\d{4}[-/]\d{2}[-/]\d{2}$/u;
+var BBG_DATE_RE = /^\d{8}$/u;
+var AMBIGUOUS_DATE_RE = /^\d{1,2}[-/]\d{1,2}[-/]\d{2,4}([T \D]|$)/u;
 function hasToJSDate(value) {
   return typeof value === "object" && value !== null && "toJSDate" in value && typeof value.toJSDate === "function";
 }
@@ -377,9 +384,7 @@ function dateLikeToJSDate(value) {
     }
     return dt;
   }
-  throw new TypeError(
-    `Cannot convert ${typeof value} value ${String(value)} to a Date.`
-  );
+  throw new TypeError(`Cannot convert ${typeof value} value ${String(value)} to a Date.`);
 }
 function formatDate(value) {
   if (value === void 0 || value === null) {
@@ -395,7 +400,7 @@ function formatDate(value) {
     }
     rejectAmbiguousString(text);
     if (ISO_DATE_RE.test(text)) {
-      return text.replace(/[-/]/g, "");
+      return text.replaceAll(/[-/]/gu, "");
     }
   }
   const date = dateLikeToJSDate(value);
@@ -423,6 +428,87 @@ function formatDateTime(value) {
   return date.toISOString();
 }
 
+// src/errors.ts
+var BlpError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var BlpSessionError = class extends BlpError {
+};
+var BlpRequestError = class extends BlpError {
+  service;
+  operation;
+  request_id;
+  code;
+  constructor(message, options = {}) {
+    super(message);
+    this.service = options.service;
+    this.operation = options.operation;
+    this.request_id = options.request_id;
+    this.code = options.code;
+  }
+};
+var BlpValidationError = class extends BlpError {
+  element;
+  suggestion;
+  constructor(message, options = {}) {
+    super(message);
+    this.element = options.element;
+    this.suggestion = options.suggestion;
+  }
+};
+var BlpTimeoutError = class extends BlpError {
+};
+var BlpInternalError = class extends BlpError {
+};
+function wrapError(napiError) {
+  if (napiError instanceof BlpError) {
+    return napiError;
+  }
+  const msg = napiError instanceof Error ? napiError.message : typeof napiError === "string" ? napiError : "";
+  if (msg.includes("Session start failed") || msg.includes("session start failed") || msg.includes("Failed to start session") || msg.includes("Failed to open service") || msg.includes("failed to spawn worker") || msg.includes("connect event failed")) {
+    return new BlpSessionError(msg);
+  }
+  if (msg.includes("Request failed") || msg.includes("Subscription failed")) {
+    const options = parseRequestOptions(msg);
+    return new BlpRequestError(msg, options);
+  }
+  if (msg.includes("Invalid argument") || msg.includes("Configuration error") || msg.includes("Operation not found") || msg.includes("Schema element not found") || msg.includes("Schema type mismatch") || msg.includes("Unsupported schema") || msg.includes("invalid extractor") || msg.includes("(did you mean")) {
+    const options = parseValidationOptions(msg);
+    return new BlpValidationError(msg, options);
+  }
+  if (msg.includes("Request timed out")) {
+    return new BlpTimeoutError(msg);
+  }
+  if (msg.includes("Internal error") || msg.includes("Channel closed") || msg.includes("Stream buffer full") || msg.includes("Request was cancelled")) {
+    return new BlpInternalError(msg);
+  }
+  return new BlpError(msg);
+}
+function parseRequestOptions(msg) {
+  const options = {};
+  const serviceOpMatch = /on ([^:]+)::([^ (]+)/u.exec(msg);
+  if (serviceOpMatch !== null) {
+    options.service = serviceOpMatch[1];
+    options.operation = serviceOpMatch[2];
+  }
+  const requestIdMatch = /\[request_id=([^\]]+)\]/u.exec(msg);
+  if (requestIdMatch !== null) {
+    options.request_id = requestIdMatch[1];
+  }
+  return options;
+}
+function parseValidationOptions(msg) {
+  const options = {};
+  const suggestionMatch = /\(did you mean '([^']+)'\?\)/u.exec(msg);
+  if (suggestionMatch !== null) {
+    options.suggestion = suggestionMatch[1];
+  }
+  return options;
+}
+
 // src/native/platform-map.ts
 var platformPackages = Object.freeze({
   "darwin-arm64": "@xbbg/core-darwin-arm64",
@@ -454,7 +540,7 @@ function validateNativePackage(packageName, resolved) {
     throw new Error(`Invalid native package ${packageName}: missing binaryPath`);
   }
   if (typeof resolved.binaryPath !== "string") {
-    throw new Error(`Invalid native package ${packageName}: binaryPath must be a string`);
+    throw new TypeError(`Invalid native package ${packageName}: binaryPath must be a string`);
   }
   return resolved;
 }
@@ -481,11 +567,11 @@ function resolveInstalledPackage(packageName, requirePackage, existsFile) {
       );
     }
     return resolved;
-  } catch (err) {
-    if (isOptionalPackageMissing(err, packageName)) {
+  } catch (error) {
+    if (isOptionalPackageMissing(error, packageName)) {
       return null;
     }
-    throw err;
+    throw error;
   }
 }
 function resolveLocalPackage(repoRoot, packageName, requirePackage, existsFile) {
@@ -504,33 +590,65 @@ function resolveLocalPackage(repoRoot, packageName, requirePackage, existsFile)
 function resolveNativeAddonCore(options) {
   const { key, packageName, repoRoot, requirePackage, exists: existsFile } = options;
   if (packageName === null) {
-    return { key, packageName: null, binaryPath: null };
+    return { binaryPath: null, key, packageName: null };
   }
   const installed = resolveInstalledPackage(packageName, requirePackage, existsFile);
   if (installed !== null) {
-    return { key, packageName, binaryPath: installed.binaryPath };
+    return { binaryPath: installed.binaryPath, key, packageName };
   }
   const local = resolveLocalPackage(repoRoot, packageName, requirePackage, existsFile);
   if (local !== null) {
-    return { key, packageName, binaryPath: local.binaryPath };
+    return { binaryPath: local.binaryPath, key, packageName };
   }
-  return { key, packageName, binaryPath: null };
+  return { binaryPath: null, key, packageName };
 }
 function resolveNativeAddon(repoRoot) {
   const key = platformKey();
   const packageName = platformPackages[key] ?? null;
   return resolveNativeAddonCore({
+    exists,
     key,
     packageName,
     repoRoot,
-    requirePackage: (id) => nodeRequire(id),
-    exists
+    requirePackage: (id) => nodeRequire(id)
   });
 }
 
 // src/index.ts
 var nodeRequire2 = module$1.createRequire(__filename);
-var packageJson = nodeRequire2("../package.json");
+function parsePackageJsonShape(value) {
+  if (isPlainObject(value) && typeof value.version === "string") {
+    return { version: value.version };
+  }
+  throw new TypeError("@xbbg/core package.json is missing a string version field");
+}
+function isNativeAddon(value) {
+  return isPlainObject(value) && typeof value.JsEngine === "function" && typeof value.getLogLevel === "function" && typeof value.setLogLevel === "function";
+}
+function requireNativeAddon(modulePath) {
+  const loaded = nodeRequire2(modulePath);
+  if (isNativeAddon(loaded)) {
+    return loaded;
+  }
+  throw new TypeError(`Native addon ${modulePath} does not expose the expected @xbbg/core surface`);
+}
+function isPolarsModule(value) {
+  return isPlainObject(value) && typeof value.readIPC === "function";
+}
+function requirePolarsModule() {
+  const loaded = nodeRequire2("nodejs-polars");
+  if (isPolarsModule(loaded)) {
+    return loaded;
+  }
+  throw new TypeError("nodejs-polars did not expose readIPC(buffer)");
+}
+function isBdhOptionsInput(value) {
+  return isPlainObject(value) && !(value instanceof Date) && !hasToJSDate(value);
+}
+function isBdibOptionsInput(value) {
+  return isPlainObject(value) && !(value instanceof Date) && !hasToJSDate(value);
+}
+var packageJson = parsePackageJsonShape(nodeRequire2("../package.json"));
 function containsBlpapiRuntime(dir) {
   if (dir.length === 0 || !fs2__default.default.existsSync(dir)) {
     return false;
@@ -560,8 +678,12 @@ function compareSdkRoots(left, right) {
       }
     }
   }
-  if (leftParts !== null) return -1;
-  if (rightParts !== null) return 1;
+  if (leftParts !== null) {
+    return -1;
+  }
+  if (rightParts !== null) {
+    return 1;
+  }
   return right.localeCompare(left);
 }
 function pushSdkRuntimeCandidates(candidates, sdkRoot) {
@@ -632,12 +754,12 @@ function loadNative() {
   ];
   for (const candidate of candidates) {
     if (fs2__default.default.existsSync(candidate)) {
-      return nodeRequire2(candidate);
+      return requireNativeAddon(candidate);
     }
   }
   const { key, packageName, binaryPath } = resolveNativeAddon(root);
   if (binaryPath !== null) {
-    return nodeRequire2(binaryPath);
+    return requireNativeAddon(binaryPath);
   }
   if (packageName === null) {
     throw new Error(
@@ -691,72 +813,67 @@ var CDX_RISK_FIELDS = Object.freeze([
   "CDS_RECOVERY_RT"
 ]);
 var TA_STUDIES = Object.freeze({
-  smavg: "smavgStudyAttributes",
-  sma: "smavgStudyAttributes",
-  emavg: "emavgStudyAttributes",
+  ado: "adoStudyAttributes",
+  adx: "dmiStudyAttributes",
+  al: "alStudyAttributes",
+  atr: "atrStudyAttributes",
+  bb: "bollStudyAttributes",
+  boll: "bollStudyAttributes",
+  bs: "bsStudyAttributes",
+  chko: "chkoStudyAttributes",
+  cmci: "cmciStudyAttributes",
+  dmi: "dmiStudyAttributes",
   ema: "emavgStudyAttributes",
-  wmavg: "wmavgStudyAttributes",
-  wma: "wmavgStudyAttributes",
-  vmavg: "vmavgStudyAttributes",
-  vma: "vmavgStudyAttributes",
-  tmavg: "tmavgStudyAttributes",
-  tma: "tmavgStudyAttributes",
+  emavg: "emavgStudyAttributes",
+  etd: "etdStudyAttributes",
+  fear_greed: "fgStudyAttributes",
+  fg: "fgStudyAttributes",
+  goc: "gocStudyAttributes",
+  hurst: "hurstStudyAttributes",
+  ichimoku: "gocStudyAttributes",
   ipmavg: "ipmavgStudyAttributes",
-  rsi: "rsiStudyAttributes",
+  keltner: "kltnStudyAttributes",
+  kltn: "kltnStudyAttributes",
   macd: "macdStudyAttributes",
+  mae: "maeStudyAttributes",
   mao: "maoStudyAttributes",
-  momentum: "momentumStudyAttributes",
+  maxmin: "maxminStudyAttributes",
   mom: "momentumStudyAttributes",
+  momentum: "momentumStudyAttributes",
+  or: "orStudyAttributes",
+  parabolic: "ptpsStudyAttributes",
+  pcr: "pcrStudyAttributes",
+  pd: "pdStudyAttributes",
+  pivot: "pivotStudyAttributes",
+  ptps: "ptpsStudyAttributes",
+  rex: "rexStudyAttributes",
   roc: "rocStudyAttributes",
-  boll: "bollStudyAttributes",
-  bb: "bollStudyAttributes",
-  kltn: "kltnStudyAttributes",
-  keltner: "kltnStudyAttributes",
-  mae: "maeStudyAttributes",
-  te: "teStudyAttributes",
-  al: "alStudyAttributes",
-  dmi: "dmiStudyAttributes",
-  adx: "dmiStudyAttributes",
-  tas: "tasStudyAttributes",
+  rsi: "rsiStudyAttributes",
+  rv: "rvStudyAttributes",
+  sar: "ptpsStudyAttributes",
+  sma: "smavgStudyAttributes",
+  smavg: "smavgStudyAttributes",
   stoch: "tasStudyAttributes",
+  tas: "tasStudyAttributes",
+  te: "teStudyAttributes",
+  tma: "tmavgStudyAttributes",
+  tmavg: "tmavgStudyAttributes",
   trender: "trenderStudyAttributes",
-  ptps: "ptpsStudyAttributes",
-  parabolic: "ptpsStudyAttributes",
-  sar: "ptpsStudyAttributes",
-  chko: "chkoStudyAttributes",
-  ado: "adoStudyAttributes",
-  vat: "vatStudyAttributes",
   tvat: "tvatStudyAttributes",
-  atr: "atrStudyAttributes",
-  hurst: "hurstStudyAttributes",
-  fg: "fgStudyAttributes",
-  fear_greed: "fgStudyAttributes",
-  goc: "gocStudyAttributes",
-  ichimoku: "gocStudyAttributes",
-  cmci: "cmciStudyAttributes",
-  wlpr: "wlprStudyAttributes",
+  vat: "vatStudyAttributes",
+  vma: "vmavgStudyAttributes",
+  vmavg: "vmavgStudyAttributes",
   williams: "wlprStudyAttributes",
-  maxmin: "maxminStudyAttributes",
-  rex: "rexStudyAttributes",
-  etd: "etdStudyAttributes",
-  pd: "pdStudyAttributes",
-  rv: "rvStudyAttributes",
-  pivot: "pivotStudyAttributes",
-  or: "orStudyAttributes",
-  pcr: "pcrStudyAttributes",
-  bs: "bsStudyAttributes"
+  wlpr: "wlprStudyAttributes",
+  wma: "wmavgStudyAttributes",
+  wmavg: "wmavgStudyAttributes"
 });
 var TA_DEFAULTS = Object.freeze({
-  smavgStudyAttributes: Object.freeze({ period: 20, priceSourceClose: "PX_LAST" }),
-  emavgStudyAttributes: Object.freeze({ period: 20, priceSourceClose: "PX_LAST" }),
-  wmavgStudyAttributes: Object.freeze({ period: 20, priceSourceClose: "PX_LAST" }),
-  vmavgStudyAttributes: Object.freeze({ period: 20, priceSourceClose: "PX_LAST" }),
-  tmavgStudyAttributes: Object.freeze({ period: 20, priceSourceClose: "PX_LAST" }),
-  rsiStudyAttributes: Object.freeze({ period: 14, priceSourceClose: "PX_LAST" }),
-  macdStudyAttributes: Object.freeze({
-    maPeriod1: 12,
-    maPeriod2: 26,
-    sigPeriod: 9,
+  atrStudyAttributes: Object.freeze({
+    maType: "Simple",
+    period: 14,
+    priceSourceHigh: "PX_HIGH",
+    priceSourceLow: "PX_LOW",
     priceSourceClose: "PX_LAST"
   }),
   bollStudyAttributes: Object.freeze({
@@ -771,13 +888,15 @@ var TA_DEFAULTS = Object.freeze({
     priceSourceLow: "PX_LOW",
     priceSourceClose: "PX_LAST"
   }),
-  atrStudyAttributes: Object.freeze({
-    maType: "Simple",
-    period: 14,
-    priceSourceHigh: "PX_HIGH",
-    priceSourceLow: "PX_LOW",
+  emavgStudyAttributes: Object.freeze({ period: 20, priceSourceClose: "PX_LAST" }),
+  macdStudyAttributes: Object.freeze({
+    maPeriod1: 12,
+    maPeriod2: 26,
+    sigPeriod: 9,
     priceSourceClose: "PX_LAST"
   }),
+  rsiStudyAttributes: Object.freeze({ period: 14, priceSourceClose: "PX_LAST" }),
+  smavgStudyAttributes: Object.freeze({ period: 20, priceSourceClose: "PX_LAST" }),
   tasStudyAttributes: Object.freeze({
     periodK: 14,
     periodD: 3,
@@ -786,7 +905,10 @@ var TA_DEFAULTS = Object.freeze({
     priceSourceHigh: "PX_HIGH",
     priceSourceLow: "PX_LOW",
     priceSourceClose: "PX_LAST"
-  })
+  }),
+  tmavgStudyAttributes: Object.freeze({ period: 20, priceSourceClose: "PX_LAST" }),
+  vmavgStudyAttributes: Object.freeze({ period: 20, priceSourceClose: "PX_LAST" }),
+  wmavgStudyAttributes: Object.freeze({ period: 20, priceSourceClose: "PX_LAST" })
 });
 var MKTDATA_SERVICE = "//blp/mktdata";
 function toArrowTableFromNative(batch) {
@@ -843,6 +965,39 @@ function toStringArray(value) {
   }
   return [toRequestString(value)];
 }
+function encodeVolFieldSpec(field, spec) {
+  if (spec === void 0) {
+    return field;
+  }
+  return [
+    field,
+    spec.metric ?? "",
+    spec.tenor ?? "",
+    spec.pointType ?? "",
+    spec.point === void 0 ? "" : String(spec.point)
+  ].join("|");
+}
+function isVolFieldSpecMap(fields) {
+  return fields !== void 0 && !Array.isArray(fields);
+}
+function normalizeVolFieldSpecs(fields) {
+  if (fields === void 0) {
+    return null;
+  }
+  if (!isVolFieldSpecMap(fields)) {
+    return fields.map((field) => toRequestString(field));
+  }
+  return Object.entries(fields).map(([field, spec]) => encodeVolFieldSpec(field, spec));
+}
+function isVolSurfacePresetArray(preset) {
+  return Array.isArray(preset);
+}
+function normalizeVolPresets(preset) {
+  if (preset === void 0 || preset === null) {
+    return null;
+  }
+  return isVolSurfacePresetArray(preset) ? [...preset] : [preset];
+}
 function subscriptionOptionKey(option) {
   return normalizeSubscriptionOption(option).split("=")[0]?.trim().toLowerCase() ?? "";
 }
@@ -855,7 +1010,7 @@ function normalizeSubscriptionOption(option) {
 }
 function buildStreamSubscriptionOptions(service, options) {
   const rawOptions = options.options;
-  const conflate = options.conflate;
+  const { conflate } = options;
   if (rawOptions === void 0 && conflate !== true) {
     return void 0;
   }
@@ -896,9 +1051,7 @@ function normalizeConfigureArgs(configOrHost, port) {
   if (isPlainObject(configOrHost)) {
     return { ...configOrHost };
   }
-  throw new TypeError(
-    "configure expects either a config object or host/port arguments"
-  );
+  throw new TypeError("configure expects either a config object or host/port arguments");
 }
 function normalizeRecoveryOptions(options = {}) {
   const normalized = { ...options };
@@ -907,7 +1060,7 @@ function normalizeRecoveryOptions(options = {}) {
   delete normalized.recovery_rate;
   if (recoveryRate !== void 0) {
     normalized.overrides = {
-      ...normalized.overrides ?? {},
+      ...normalized.overrides,
       CDS_RR: toRequestString(recoveryRate)
     };
   }
@@ -920,15 +1073,15 @@ function fullDayRange(dt) {
   }
   const day = `${formatted.slice(0, 4)}-${formatted.slice(4, 6)}-${formatted.slice(6, 8)}`;
   return {
-    start: `${day}T00:00:00`,
-    end: `${day}T23:59:59`
+    end: `${day}T23:59:59`,
+    start: `${day}T00:00:00`
   };
 }
 function normalizeDate(value) {
   return formatDate(value);
 }
 function getStudyAttrName(study) {
-  const normalized = study.toLowerCase().replace(/-/g, "_").replace(/ /g, "_");
+  const normalized = study.toLowerCase().replaceAll(/-/gu, "_").replaceAll(/ /gu, "_");
   const mapped = TA_STUDIES[normalized];
   if (mapped !== void 0) {
     return mapped;
@@ -942,14 +1095,16 @@ function buildTaRequest(ticker, study, options = {}) {
   const rawStudy = typeof study === "string" ? { studyType: study } : { ...study };
   const studyType = rawStudy.studyType ?? rawStudy.study ?? (typeof study === "string" ? study : "");
   const attrName = getStudyAttrName(toRequestString(studyType));
-  const kwargs = { ...options.kwargs ?? {} };
+  const kwargs = { ...options.kwargs };
   const startDate = normalizeDate(
     stringOrUndef(kwargs.startDate) ?? stringOrUndef(kwargs.start_date) ?? options.startDate ?? options.start_date
   );
   const endDate = normalizeDate(
     stringOrUndef(kwargs.endDate) ?? stringOrUndef(kwargs.end_date) ?? options.endDate ?? options.end_date
   );
-  const periodicity = toRequestString(stringOrUndef(kwargs.periodicitySelection) ?? stringOrUndef(kwargs.periodicity) ?? rawStudy.calcInterval ?? options.periodicity ?? "DAILY").toUpperCase();
+  const periodicity = toRequestString(
+    stringOrUndef(kwargs.periodicitySelection) ?? stringOrUndef(kwargs.periodicity) ?? rawStudy.calcInterval ?? options.periodicity ?? "DAILY"
+  ).toUpperCase();
   const interval = kwargs.interval ?? rawStudy.interval ?? options.interval;
   delete kwargs.startDate;
   delete kwargs.start_date;
@@ -965,8 +1120,8 @@ function buildTaRequest(ticker, study, options = {}) {
   }
   delete rawStudy.length;
   const params = {
-    ...TA_DEFAULTS[attrName] ?? {},
-    ...options.studyParams ?? {},
+    ...TA_DEFAULTS[attrName],
+    ...options.studyParams,
     ...rawStudy
   };
   if (params.length !== void 0 && params.period === void 0) {
@@ -1022,7 +1177,7 @@ function cachePolarsLoadError(err) {
   const error = new Error(
     "nodejs-polars is required for Polars backend. Install: npm install nodejs-polars"
   );
-  Object.defineProperty(error, "cause", { value: err, configurable: true });
+  Object.defineProperty(error, "cause", { configurable: true, value: err });
   polarsLoadError = error;
   return error;
 }
@@ -1034,10 +1189,10 @@ function loadPolars() {
     throw polarsLoadError;
   }
   try {
-    polarsModule = nodeRequire2("nodejs-polars");
+    polarsModule = requirePolarsModule();
     return polarsModule;
-  } catch (err) {
-    throw cachePolarsLoadError(err);
+  } catch (error) {
+    throw cachePolarsLoadError(error);
   }
 }
 function normalizeBackend(backend) {
@@ -1054,7 +1209,7 @@ function normalizeBackend(backend) {
 function ipcToBackend(buffer, backend) {
   const selected = normalizeBackend(backend);
   if (selected === Backend.JSON) {
-    return Array.from(apacheArrow.tableFromIPC(buffer));
+    return [...apacheArrow.tableFromIPC(buffer)];
   }
   if (selected === Backend.POLARS) {
     return loadPolars().readIPC(buffer);
@@ -1067,10 +1222,13 @@ function clearConfiguredEngine() {
   const existing = configuredEnginePromise;
   configuredEnginePromise = void 0;
   if (existing !== void 0) {
-    existing.then((engine) => {
-      engine.signalShutdown();
-    }).catch(() => {
-    });
+    void (async () => {
+      try {
+        const engine = await existing;
+        engine.signalShutdown();
+      } catch {
+      }
+    })();
   }
 }
 async function getConfiguredEngine() {
@@ -1092,28 +1250,32 @@ var FieldHandle = class {
   name;
 };
 var Tick = class {
-  constructor(_update) {
-    this._update = _update;
-    this._positions = new Map(_update.fields.map((field, index) => [field, index]));
+  constructor(update) {
+    this.update = update;
+    this.positions = new Map(update.fields.map((field, index) => [field, index]));
   }
-  _update;
-  _positions;
+  update;
+  positions;
   get topic() {
-    return this._update.topic;
+    return this.update.topic;
   }
   get timestampUs() {
-    return this._update.timestampUs;
+    return this.update.timestampUs;
   }
   get layoutVersion() {
-    return this._update.layoutVersion;
+    return this.update.layoutVersion;
   }
   get(field) {
     const name = typeof field === "string" ? field : field.name;
-    const index = this._positions.get(name);
-    if (index === void 0) return null;
-    const value = this._update.values[index] ?? null;
-    const kind = this._update.valueKinds[index] ?? "unknown";
-    if (value === null) return null;
+    const index = this.positions.get(name);
+    if (index === void 0) {
+      return null;
+    }
+    const value = this.update.values[index] ?? null;
+    const kind = this.update.valueKinds[index] ?? "unknown";
+    if (value === null) {
+      return null;
+    }
     if (kind === "i64" || kind === "time64_us" || kind === "timestamp_us") {
       try {
         return BigInt(String(value));
@@ -1128,13 +1290,17 @@ var Tick = class {
   }
   f64(field) {
     const value = this.get(field);
-    if (value === null) return null;
+    if (value === null) {
+      return null;
+    }
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : null;
   }
   i64(field) {
     const value = this.get(field);
-    if (value === null) return null;
+    if (value === null) {
+      return null;
+    }
     try {
       return BigInt(String(value));
     } catch {
@@ -1146,35 +1312,35 @@ var Tick = class {
     return value === null ? null : String(value);
   }
   toObject() {
-    const out = { topic: this.topic, timestampUs: this.timestampUs };
-    for (const field of this._update.fields) {
+    const out = { timestampUs: this.timestampUs, topic: this.topic };
+    for (const field of this.update.fields) {
       out[field] = this.get(field);
     }
     return out;
   }
 };
 var ArrowSubscription = class {
-  constructor(_inner) {
-    this._inner = _inner;
+  constructor(inner) {
+    this.inner = inner;
   }
-  _inner;
+  inner;
   async next() {
     try {
-      const batch = await this._inner.nextArrow();
+      const batch = await this.inner.nextArrow();
       if (batch === null) {
         return { done: true, value: void 0 };
       }
       return { done: false, value: toArrowTableFromNative(batch) };
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async unsubscribe(drain = false) {
     try {
-      const drained = await this._inner.unsubscribeArrow(drain);
+      const drained = await this.inner.unsubscribeArrow(drain);
       return drained?.map(toArrowTableFromNative) ?? [];
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   [Symbol.asyncIterator]() {
@@ -1182,63 +1348,63 @@ var ArrowSubscription = class {
   }
 };
 var Subscription = class {
-  _inner;
+  inner;
   constructor(inner) {
-    this._inner = inner;
+    this.inner = inner;
   }
   async next() {
     try {
-      const update = await this._inner.nextUpdate();
+      const update = await this.inner.nextUpdate();
       if (update === null) {
         return { done: true, value: void 0 };
       }
       return { done: false, value: new Tick(update) };
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async add(tickers) {
     try {
-      await this._inner.add(tickers);
-    } catch (err) {
-      throw wrapError(err);
+      await this.inner.add(tickers);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async remove(tickers) {
     try {
-      await this._inner.remove(tickers);
-    } catch (err) {
-      throw wrapError(err);
+      await this.inner.remove(tickers);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async unsubscribe(drain = false) {
     try {
-      const drained = await this._inner.unsubscribe(drain);
+      const drained = await this.inner.unsubscribe(drain);
       if (drained === null) {
         return [];
       }
       return drained.map((update) => new Tick(update));
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   field(name) {
     return new FieldHandle(name);
   }
   arrow() {
-    return new ArrowSubscription(this._inner);
+    return new ArrowSubscription(this.inner);
   }
   get tickers() {
-    return this._inner.tickers;
+    return this.inner.tickers;
   }
   get fields() {
-    return this._inner.fields;
+    return this.inner.fields;
   }
   get isActive() {
-    return this._inner.isActive;
+    return this.inner.isActive;
   }
   get stats() {
-    return this._inner.stats;
+    return this.inner.stats;
   }
   [Symbol.asyncIterator]() {
     return this;
@@ -1246,20 +1412,24 @@ var Subscription = class {
 };
 var Engine = class _Engine {
   // Set via constructor or via `withConfig` (which instantiates via Object.create).
-  _inner;
+  inner;
   constructor(host = "localhost", port = 8194) {
     try {
-      this._inner = new native.JsEngine(host, port);
-    } catch (err) {
-      throw wrapError(err);
+      this.inner = new native.JsEngine(host, port);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   static withConfig(config = {}) {
-    const engine = Object.create(_Engine.prototype);
+    const maybeEngine = Object.create(_Engine.prototype);
+    if (!(maybeEngine instanceof _Engine)) {
+      throw new TypeError("Failed to allocate Engine instance");
+    }
+    const engine = maybeEngine;
     try {
-      engine._inner = native.JsEngine.withConfig(config);
-    } catch (err) {
-      throw wrapError(err);
+      engine.inner = native.JsEngine.withConfig(config);
+    } catch (error) {
+      throw wrapError(error);
     }
     return engine;
   }
@@ -1267,104 +1437,104 @@ var Engine = class _Engine {
     const backend = normalizeBackend(params.backend);
     const { backend: _discarded, ...nativeParams } = params;
     try {
-      const buffer = await this._inner.request(nativeParams);
+      const buffer = await this.inner.request(nativeParams);
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async requestRaw(params) {
     try {
-      return await this._inner.request(params);
-    } catch (err) {
-      throw wrapError(err);
+      return await this.inner.request(params);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async bdp(tickers, fields, options = {}) {
     return await this.request({
-      service: "//blp/refdata",
-      operation: "ReferenceDataRequest",
-      securities: tickers,
+      backend: options.backend,
+      extractor: "refdata",
       fields,
-      overrides: mapObjectToPairs(options.overrides),
-      kwargs: mapObjectToPairs(options.kwargs),
       format: options.format,
-      backend: options.backend,
       includeSecurityErrors: Boolean(options.includeSecurityErrors),
-      validateFields: options.validateFields,
-      extractor: "refdata"
+      kwargs: mapObjectToPairs(options.kwargs),
+      operation: "ReferenceDataRequest",
+      overrides: mapObjectToPairs(options.overrides),
+      securities: tickers,
+      service: "//blp/refdata",
+      validateFields: options.validateFields
     });
   }
   async bds(tickers, fields, options = {}) {
     return await this.request({
-      service: "//blp/refdata",
-      operation: "ReferenceDataRequest",
-      securities: tickers,
+      backend: options.backend,
+      extractor: "bulk",
       fields,
-      overrides: mapObjectToPairs(options.overrides),
-      kwargs: mapObjectToPairs(options.kwargs),
       format: options.format,
-      backend: options.backend,
-      validateFields: options.validateFields,
-      extractor: "bulk"
+      kwargs: mapObjectToPairs(options.kwargs),
+      operation: "ReferenceDataRequest",
+      overrides: mapObjectToPairs(options.overrides),
+      securities: tickers,
+      service: "//blp/refdata",
+      validateFields: options.validateFields
     });
   }
   async bdh(tickers, fields, options = {}) {
     return await this.request({
-      service: "//blp/refdata",
+      backend: options.backend,
+      endDate: formatDate(options.end),
+      extractor: "histdata",
+      fields,
+      format: options.format,
+      kwargs: mapObjectToPairs(options.kwargs),
       operation: "HistoricalDataRequest",
+      overrides: mapObjectToPairs(options.overrides),
       securities: tickers,
-      fields,
+      service: "//blp/refdata",
       startDate: formatDate(options.start),
-      endDate: formatDate(options.end),
-      overrides: mapObjectToPairs(options.overrides),
-      kwargs: mapObjectToPairs(options.kwargs),
-      format: options.format,
-      backend: options.backend,
-      validateFields: options.validateFields,
-      extractor: "histdata"
+      validateFields: options.validateFields
     });
   }
   async bdib(ticker, options = {}) {
     return await this.request({
-      service: "//blp/refdata",
-      operation: "IntradayBarRequest",
-      security: ticker,
+      backend: options.backend,
+      endDatetime: formatDateTime(options.end),
       eventType: options.eventType ?? "TRADE",
+      extractor: "intraday_bar",
       interval: options.interval ?? 1,
-      startDatetime: formatDateTime(options.start),
-      endDatetime: formatDateTime(options.end),
-      requestTz: options.requestTz,
-      outputTz: options.outputTz,
       kwargs: mapObjectToPairs(options.kwargs),
-      backend: options.backend,
-      extractor: "intraday_bar"
+      operation: "IntradayBarRequest",
+      outputTz: options.outputTz,
+      requestTz: options.requestTz,
+      security: ticker,
+      service: "//blp/refdata",
+      startDatetime: formatDateTime(options.start)
     });
   }
   async bdtick(ticker, options = {}) {
     return await this.request({
-      service: "//blp/refdata",
-      operation: "IntradayTickRequest",
-      security: ticker,
-      eventTypes: options.eventTypes ?? ["TRADE"],
-      startDatetime: formatDateTime(options.start),
+      backend: options.backend,
       endDatetime: formatDateTime(options.end),
-      requestTz: options.requestTz,
-      outputTz: options.outputTz,
+      eventTypes: options.eventTypes ?? ["TRADE"],
+      extractor: "intraday_tick",
       kwargs: buildBdtickKwargs(options),
-      backend: options.backend,
-      extractor: "intraday_tick"
+      operation: "IntradayTickRequest",
+      outputTz: options.outputTz,
+      requestTz: options.requestTz,
+      security: ticker,
+      service: "//blp/refdata",
+      startDatetime: formatDateTime(options.start)
     });
   }
   async bql(query, options = {}) {
     return await this.request({
-      service: "//blp/bqlsvc",
-      operation: "sendQuery",
-      elements: [{ key: "expression", value: toRequestString(query) }],
       backend: options.backend,
-      kwargs: mapObjectToPairs(options.kwargs),
+      elements: [{ key: "expression", value: toRequestString(query) }],
+      extractor: "bql",
       format: options.format,
-      extractor: "bql"
+      kwargs: mapObjectToPairs(options.kwargs),
+      operation: "sendQuery",
+      service: "//blp/bqlsvc"
     });
   }
   async beqs(screen, options = {}) {
@@ -1379,108 +1549,108 @@ var Engine = class _Engine {
         elements.push({ key: "asOfDate", value: asofFormatted });
       }
     }
-    const overrides = { ...options.overrides ?? {} };
+    const overrides = { ...options.overrides };
     return await this.request({
-      service: "//blp/refdata",
-      operation: "BeqsRequest",
-      elements,
       backend: options.backend,
+      elements,
+      extractor: "generic",
+      format: options.format,
       kwargs: mapObjectToPairs(options.kwargs),
+      operation: "BeqsRequest",
       overrides: mapObjectToPairs(overrides),
-      format: options.format,
-      extractor: "generic"
+      service: "//blp/refdata"
     });
   }
   async bsrch(searchSpec, options = {}) {
     const elements = {
       Domain: toRequestString(searchSpec),
-      ...options.overrides ?? {},
-      ...options.kwargs ?? {}
+      ...options.overrides,
+      ...options.kwargs
     };
     return await this.request({
-      service: "//blp/exrsvc",
-      operation: "ExcelGetGridRequest",
       backend: options.backend,
       elements: mapObjectToPairs(elements),
+      extractor: "bsrch",
       format: options.format,
-      extractor: "bsrch"
+      operation: "ExcelGetGridRequest",
+      service: "//blp/exrsvc"
     });
   }
   async bta(ticker, study, options = {}) {
     return await this.request({
-      service: "//blp/tasvc",
-      operation: "studyRequest",
-      elements: buildTaRequest(ticker, study, options),
       backend: options.backend,
+      elements: buildTaRequest(ticker, study, options),
+      extractor: "generic",
       format: options.format,
-      extractor: "generic"
+      operation: "studyRequest",
+      service: "//blp/tasvc"
     });
   }
   async bflds(options = {}) {
     if (options.searchSpec !== void 0) {
       return await this.request({
-        service: "//blp/apiflds",
-        operation: "FieldSearchRequest",
-        searchSpec: toRequestString(options.searchSpec),
         backend: options.backend,
+        format: options.format,
         kwargs: mapObjectToPairs(options.kwargs),
-        format: options.format
+        operation: "FieldSearchRequest",
+        searchSpec: toRequestString(options.searchSpec),
+        service: "//blp/apiflds"
       });
     }
-    const fields = Array.isArray(options.fields) ? options.fields : typeof options.fields === "string" ? [options.fields] : [];
+    const fields = toStringArray(options.fields);
     return await this.request({
-      service: "//blp/apiflds",
-      operation: "FieldInfoRequest",
-      fieldIds: fields,
       backend: options.backend,
+      fieldIds: fields,
+      format: options.format,
       kwargs: mapObjectToPairs(options.kwargs),
-      format: options.format
+      operation: "FieldInfoRequest",
+      service: "//blp/apiflds"
     });
   }
   async blkp(query, options = {}) {
     return await this.request({
-      service: "//blp/instruments",
-      operation: "instrumentListRequest",
-      elements: [{ key: "query", value: toRequestString(query) }],
       backend: options.backend,
+      elements: [{ key: "query", value: toRequestString(query) }],
+      format: options.format,
       kwargs: mapObjectToPairs(options.kwargs),
-      format: options.format
+      operation: "instrumentListRequest",
+      service: "//blp/instruments"
     });
   }
   async bport(portfolio, fields, options = {}) {
     return await this.request({
-      service: "//blp/refdata",
-      operation: "PortfolioDataRequest",
-      security: toRequestString(portfolio),
-      fields: Array.isArray(fields) ? fields : [toRequestString(fields)],
       backend: options.backend,
-      overrides: mapObjectToPairs(options.overrides),
+      fields: Array.isArray(fields) ? fields : [toRequestString(fields)],
+      format: options.format,
       kwargs: mapObjectToPairs(options.kwargs),
-      format: options.format
+      operation: "PortfolioDataRequest",
+      overrides: mapObjectToPairs(options.overrides),
+      security: toRequestString(portfolio),
+      service: "//blp/refdata"
     });
   }
   async bcurves(ticker, options = {}) {
     return await this.request({
-      service: "//blp/instruments",
-      operation: "curveListRequest",
-      elements: [{ key: "query", value: toRequestString(ticker) }],
       backend: options.backend,
+      elements: [{ key: "query", value: toRequestString(ticker) }],
+      format: options.format,
       kwargs: mapObjectToPairs(options.kwargs),
-      format: options.format
+      operation: "curveListRequest",
+      service: "//blp/instruments"
     });
   }
   async bgovts(ticker, options = {}) {
     return await this.request({
-      service: "//blp/instruments",
-      operation: "govtListRequest",
-      elements: [{ key: "query", value: toRequestString(ticker) }],
       backend: options.backend,
+      elements: [{ key: "query", value: toRequestString(ticker) }],
+      format: options.format,
       kwargs: mapObjectToPairs(options.kwargs),
-      format: options.format
+      operation: "govtListRequest",
+      service: "//blp/instruments"
     });
   }
   async resolveFieldTypes(fields, overrides, defaultType = "string") {
-    const items = await this._inner.resolveFieldTypes(
+    const items = await this.inner.resolveFieldTypes(
       fields,
       mapObjectToPairs(overrides),
       defaultType
@@ -1488,55 +1658,55 @@ var Engine = class _Engine {
     return Object.fromEntries(items.map((item) => [item.key, item.value]));
   }
   getFieldInfo(field) {
-    return this._inner.getFieldInfo(field);
+    return this.inner.getFieldInfo(field);
   }
   clearFieldCache() {
-    this._inner.clearFieldCache();
+    this.inner.clearFieldCache();
   }
   saveFieldCache() {
-    this._inner.saveFieldCache();
+    this.inner.saveFieldCache();
   }
   async validateFields(fields) {
-    return await this._inner.validateFields(fields);
+    return await this.inner.validateFields(fields);
   }
   isFieldValidationEnabled() {
-    return this._inner.isFieldValidationEnabled();
+    return this.inner.isFieldValidationEnabled();
   }
   async getSchema(service) {
-    const json = await this._inner.getSchema(service);
+    const json = await this.inner.getSchema(service);
     return JSON.parse(json);
   }
   async getOperation(service, operation) {
-    const json = await this._inner.getOperation(service, operation);
+    const json = await this.inner.getOperation(service, operation);
     return JSON.parse(json);
   }
   async listOperations(service) {
-    return await this._inner.listOperations(service);
+    return await this.inner.listOperations(service);
   }
   getCachedSchema(service) {
-    const json = this._inner.getCachedSchema(service);
+    const json = this.inner.getCachedSchema(service);
     return json === null ? null : JSON.parse(json);
   }
   invalidateSchema(service) {
-    this._inner.invalidateSchema(service);
+    this.inner.invalidateSchema(service);
   }
   clearSchemaCache() {
-    this._inner.clearSchemaCache();
+    this.inner.clearSchemaCache();
   }
   listCachedSchemas() {
-    return this._inner.listCachedSchemas();
+    return this.inner.listCachedSchemas();
   }
   async getEnumValues(service, operation, element) {
-    return await this._inner.getEnumValues(service, operation, element);
+    return await this.inner.getEnumValues(service, operation, element);
   }
   async listValidElements(service, operation) {
-    return await this._inner.listValidElements(service, operation);
+    return await this.inner.listValidElements(service, operation);
   }
   async subscribe(tickers, fields, options = {}) {
     try {
       const subscriptionOptions = buildStreamSubscriptionOptions(MKTDATA_SERVICE, options);
       const useOptions = subscriptionOptions !== void 0 || options.flushThreshold !== void 0 || options.overflowPolicy !== void 0 || options.streamCapacity !== void 0;
-      const stream = useOptions ? await this._inner.subscribeWithOptions(
+      const stream = useOptions ? await this.inner.subscribeWithOptions(
         MKTDATA_SERVICE,
         tickers,
         fields,
@@ -1545,15 +1715,15 @@ var Engine = class _Engine {
         options.overflowPolicy,
         options.streamCapacity,
         options.allFields
-      ) : await this._inner.subscribe(tickers, fields, options.allFields);
+      ) : await this.inner.subscribe(tickers, fields, options.allFields);
       return new Subscription(stream);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async subscribeWithOptions(service, tickers, fields, options, flushThreshold, overflowPolicy, streamCapacity, allFields) {
     try {
-      const stream = await this._inner.subscribeWithOptions(
+      const stream = await this.inner.subscribeWithOptions(
         service,
         tickers,
         fields,
@@ -1564,15 +1734,15 @@ var Engine = class _Engine {
         allFields
       );
       return new Subscription(stream);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   signalShutdown() {
-    this._inner.signalShutdown();
+    this.inner.signalShutdown();
   }
   isAvailable() {
-    return this._inner.isAvailable();
+    return this.inner.isAvailable();
   }
   async stream(tickers, fields, options = {}) {
     return await this.subscribeWithOptions(
@@ -1635,19 +1805,19 @@ var Engine = class _Engine {
     );
   }
   async bops(service) {
-    return await this._inner.listOperations(service);
+    return await this.inner.listOperations(service);
   }
   async bschema(service, operation) {
     if (operation !== void 0) {
-      const json2 = await this._inner.getOperation(service, operation);
+      const json2 = await this.inner.getOperation(service, operation);
       return JSON.parse(json2);
     }
-    const json = await this._inner.getSchema(service);
+    const json = await this.inner.getSchema(service);
     return JSON.parse(json);
   }
   async fieldInfo(fields, options = {}) {
     return await this.bflds({
-      fields: Array.isArray(fields) ? fields : [toRequestString(fields)],
+      fields: toStringArray(fields),
       ...options
     });
   }
@@ -1658,7 +1828,7 @@ var Engine = class _Engine {
   async bqr(ticker, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeBqr(
+      const buffer = await this.inner.recipeBqr(
         toRequestString(ticker),
         formatDateTime(options.startDatetime),
         formatDateTime(options.endDatetime),
@@ -1666,14 +1836,14 @@ var Engine = class _Engine {
         options.includeBrokerCodes !== false
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async yas(tickers, fields, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeYas(
+      const buffer = await this.inner.recipeYas(
         toStringArray(tickers),
         toStringArray(fields),
         formatDate(options.settleDt),
@@ -1684,105 +1854,135 @@ var Engine = class _Engine {
         options.benchmark ?? void 0
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async preferreds(equityTicker, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipePreferreds(
+      const buffer = await this.inner.recipePreferreds(
         toRequestString(equityTicker),
         options.fields !== void 0 ? toStringArray(options.fields) : null
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async corporateBonds(ticker, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeCorporateBonds(
+      const buffer = await this.inner.recipeCorporateBonds(
         toRequestString(ticker),
         options.ccy ?? void 0,
         options.fields !== void 0 ? toStringArray(options.fields) : null,
         options.activeOnly !== false
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async futTicker(genTicker, dt, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeFutTicker(
+      const buffer = await this.inner.recipeFutTicker(
         toRequestString(genTicker),
         formatDate(dt) ?? "",
         options.freq ?? void 0
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async activeFutures(genTicker, dt, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeActiveFutures(
+      const buffer = await this.inner.recipeActiveFutures(
         toRequestString(genTicker),
         formatDate(dt) ?? "",
         options.freq ?? void 0
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
+    }
+  }
+  async futuresCurve(genTicker, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this.inner.recipeFuturesCurve(
+        toRequestString(genTicker),
+        options.asof === void 0 ? void 0 : formatDate(options.asof) ?? "",
+        options.chainField ?? void 0,
+        options.fields !== void 0 ? toStringArray(options.fields) : null,
+        options.maxContracts ?? void 0
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async cdxTicker(genTicker, dt, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeCdxTicker(
+      const buffer = await this.inner.recipeCdxTicker(
         toRequestString(genTicker),
         formatDate(dt) ?? ""
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async activeCdx(genTicker, dt, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeActiveCdx(
+      const buffer = await this.inner.recipeActiveCdx(
         toRequestString(genTicker),
         formatDate(dt) ?? "",
         options.lookbackDays ?? void 0
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async dividend(tickers, startDate, endDate, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeDividend(
+      const buffer = await this.inner.recipeDividend(
         toStringArray(tickers),
         formatDate(startDate) ?? "",
         formatDate(endDate) ?? "",
         options.dvdType ?? void 0
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
+    }
+  }
+  async dividendYield(tickers, startDate, endDate, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this.inner.recipeDividendYield(
+        toStringArray(tickers),
+        formatDate(startDate) ?? "",
+        formatDate(endDate) ?? "",
+        options.dividendTypes !== void 0 ? toStringArray(options.dividendTypes) : null,
+        options.windowDays ?? void 0
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async turnover(tickers, startDate, endDate, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeTurnover(
+      const buffer = await this.inner.recipeTurnover(
         toStringArray(tickers),
         formatDate(startDate) ?? "",
         formatDate(endDate) ?? "",
@@ -1790,41 +1990,89 @@ var Engine = class _Engine {
         options.factor ?? void 0
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async etfHoldings(etfTicker, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeEtfHoldings(
+      const buffer = await this.inner.recipeEtfHoldings(
         toRequestString(etfTicker),
         options.fields !== void 0 ? toStringArray(options.fields) : null
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
+    }
+  }
+  async volSurface(tickers, startDate, endDate, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this.inner.recipeVolSurface(
+        toStringArray(tickers),
+        formatDate(startDate) ?? "",
+        formatDate(endDate) ?? "",
+        normalizeVolPresets(options.preset ?? "MONEYNESS_30D"),
+        normalizeVolFieldSpecs(options.fields),
+        options.asDecimal ?? true,
+        options.includeDerived ?? false,
+        options.riskFreeRate ?? void 0,
+        options.dividendYieldField ?? void 0
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (error) {
+      throw wrapError(error);
+    }
+  }
+  async indexMembers(index, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this.inner.recipeIndexMembers(
+        toRequestString(index),
+        options.field ?? void 0,
+        options.asof === void 0 ? void 0 : formatDate(options.asof) ?? ""
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (error) {
+      throw wrapError(error);
+    }
+  }
+  async resolveIsins(isins, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this.inner.recipeResolveIsins(toStringArray(isins));
+      return ipcToBackend(buffer, backend);
+    } catch (error) {
+      throw wrapError(error);
+    }
+  }
+  async issuerIsins(bondIsins, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this.inner.recipeIssuerIsins(toStringArray(bondIsins));
+      return ipcToBackend(buffer, backend);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
   async currencyConversion(ticker, targetCcy, startDate, endDate, options = {}) {
     const backend = normalizeBackend(options.backend);
     try {
-      const buffer = await this._inner.recipeCurrencyConversion(
+      const buffer = await this.inner.recipeCurrencyConversion(
         toRequestString(ticker),
         toRequestString(targetCcy),
         formatDate(startDate) ?? "",
         formatDate(endDate) ?? ""
       );
       return ipcToBackend(buffer, backend);
-    } catch (err) {
-      throw wrapError(err);
+    } catch (error) {
+      throw wrapError(error);
     }
   }
 };
 async function connect(config) {
-  return await Promise.resolve(
-    config === void 0 ? new Engine() : Engine.withConfig(config)
-  );
+  return await Promise.resolve(config === void 0 ? new Engine() : Engine.withConfig(config));
 }
 function configure(configOrHost, port) {
   configuredEngineConfig = normalizeConfigureArgs(configOrHost, port);
@@ -1840,17 +2088,16 @@ async function bdp(tickers, fields, options = {}) {
 }
 async function abdh(tickers, fields, start, end, options = {}) {
   const engine = await getConfiguredEngine();
-  if (isPlainObject(start) && !(start instanceof Date) && !hasToJSDate(start) && end === void 0) {
-    return await engine.bdh(
-      toStringArray(tickers),
-      toStringArray(fields),
-      start
-    );
+  if (isBdhOptionsInput(start)) {
+    if (end !== void 0) {
+      throw new TypeError("abdh options object cannot be combined with a positional end date");
+    }
+    return await engine.bdh(toStringArray(tickers), toStringArray(fields), start);
   }
   return await engine.bdh(toStringArray(tickers), toStringArray(fields), {
     ...options,
-    start,
-    end
+    end,
+    start
   });
 }
 async function bdh(tickers, fields, options = {}) {
@@ -1858,25 +2105,20 @@ async function bdh(tickers, fields, options = {}) {
 }
 async function abds(tickers, fields, overrides, options = {}) {
   const engine = await getConfiguredEngine();
-  const normalizedOptions = isPlainObject(overrides) ? { ...options, overrides: { ...options.overrides ?? {}, ...overrides } } : options;
-  return await engine.bds(
-    toStringArray(tickers),
-    toStringArray(fields),
-    normalizedOptions
-  );
+  const normalizedOptions = isPlainObject(overrides) ? { ...options, overrides: { ...options.overrides, ...overrides } } : options;
+  return await engine.bds(toStringArray(tickers), toStringArray(fields), normalizedOptions);
 }
 async function bds(tickers, fields, options = {}) {
   return await abds(tickers, fields, void 0, options);
 }
 async function abdib(ticker, dt, interval = 1, options = {}) {
   const engine = await getConfiguredEngine();
-  const dtIsOptions = isPlainObject(dt) && !(dt instanceof Date) && !hasToJSDate(dt);
-  if (dtIsOptions && interval === 1 && Object.keys(options).length === 0) {
+  if (isBdibOptionsInput(dt) && interval === 1 && Object.keys(options).length === 0) {
     return await engine.bdib(toRequestString(ticker), dt);
   }
-  const normalizedOptions = isPlainObject(interval) ? { ...interval } : { ...options, interval: typeof interval === "number" ? interval : 1 };
+  const normalizedOptions = isBdibOptionsInput(interval) ? { ...interval } : { ...options, interval: typeof interval === "number" ? interval : 1 };
   if (normalizedOptions.start === void 0 && normalizedOptions.end === void 0) {
-    if (dt === void 0) {
+    if (dt === void 0 || isBdibOptionsInput(dt)) {
       throw new TypeError("abdib requires dt or explicit start/end options");
     }
     const range = fullDayRange(dt);
@@ -1893,7 +2135,7 @@ async function abdtick(ticker, start, end, options = {}) {
     throw new TypeError("abdtick requires both start and end datetimes");
   }
   const engine = await getConfiguredEngine();
-  return await engine.bdtick(toRequestString(ticker), { ...options, start, end });
+  return await engine.bdtick(toRequestString(ticker), { ...options, end, start });
 }
 async function bdtick(ticker, options = {}) {
   const engine = await getConfiguredEngine();
@@ -1927,76 +2169,76 @@ async function acdxRisk(ticker, options = {}) {
   );
 }
 var blp = Object.freeze({
-  bdp,
-  bdh,
-  bds,
-  bdib,
-  bdtick,
-  subscribe,
-  abdp,
   abdh,
-  abds,
   abdib,
+  abdp,
+  abds,
   abdtick,
-  asubscribe
+  asubscribe,
+  bdh,
+  bdib,
+  bdp,
+  bds,
+  bdtick,
+  subscribe
 });
 var ext = Object.freeze({
+  buildCorporateBondsQuery: native.extBuildCorporateBondsQuery,
+  buildEarningHeaderRename: native.extBuildEarningHeaderRename,
+  buildEtfHoldingsQuery: native.extBuildEtfHoldingsQuery,
+  buildFuturesTicker: native.extBuildFuturesTicker,
+  buildFxPair: native.extBuildFxPair,
+  buildPreferredsQuery: native.extBuildPreferredsQuery,
+  buildYasOverrides: native.extBuildYasOverrides,
+  calculateLevelPercentages: native.extCalculateLevelPercentages,
   cdx: Object.freeze({
     acdx_info: acdxInfo,
     acdx_pricing: acdxPricing,
     acdx_risk: acdxRisk
   }),
-  parseDate: native.extParseDate,
-  fmtDate: native.extFmtDate,
-  pivotToWide: native.extPivotToWide,
-  isLongFormat: native.extIsLongFormat,
-  parseTicker: native.extParseTicker,
-  isSpecificContract: native.extIsSpecificContract,
-  buildFuturesTicker: native.extBuildFuturesTicker,
-  normalizeTickers: native.extNormalizeTickers,
-  filterEquityTickers: native.extFilterEquityTickers,
-  generateFuturesCandidates: native.extGenerateFuturesCandidates,
-  validateGenericTicker: native.extValidateGenericTicker,
+  cdxGenToSpecific: native.extCdxGenToSpecific,
+  clearExchangeOverride: native.extClearExchangeOverride,
   contractIndex: native.extContractIndex,
+  currenciesNeedingConversion: native.extCurrenciesNeedingConversion,
+  defaultBqrDatetimes: native.extDefaultBqrDatetimes,
+  defaultTurnoverDates: native.extDefaultTurnoverDates,
+  deriveSessions: native.extDeriveSessions,
   filterCandidatesByCycle: native.extFilterCandidatesByCycle,
+  filterEquityTickers: native.extFilterEquityTickers,
   filterValidContracts: native.extFilterValidContracts,
-  parseCdxTicker: native.extParseCdxTicker,
-  previousCdxSeries: native.extPreviousCdxSeries,
-  cdxGenToSpecific: native.extCdxGenToSpecific,
-  buildFxPair: native.extBuildFxPair,
-  sameCurrency: native.extSameCurrency,
-  currenciesNeedingConversion: native.extCurrenciesNeedingConversion,
-  renameDividendColumns: native.extRenameDividendColumns,
-  renameEtfColumns: native.extRenameEtfColumns,
-  getMonthCode: native.extGetMonthCode,
-  getMonthName: native.extGetMonthName,
-  getFuturesMonths: native.extGetFuturesMonths,
+  fmtDate: native.extFmtDate,
+  generateFuturesCandidates: native.extGenerateFuturesCandidates,
+  getDvdCols: native.extGetDvdCols,
   getDvdType: native.extGetDvdType,
   getDvdTypes: native.extGetDvdTypes,
-  getDvdCols: native.extGetDvdCols,
   getEtfCols: native.extGetEtfCols,
-  buildYasOverrides: native.extBuildYasOverrides,
-  buildEarningHeaderRename: native.extBuildEarningHeaderRename,
-  calculateLevelPercentages: native.extCalculateLevelPercentages,
-  buildPreferredsQuery: native.extBuildPreferredsQuery,
-  buildCorporateBondsQuery: native.extBuildCorporateBondsQuery,
-  buildEtfHoldingsQuery: native.extBuildEtfHoldingsQuery,
-  defaultTurnoverDates: native.extDefaultTurnoverDates,
-  defaultBqrDatetimes: native.extDefaultBqrDatetimes,
-  deriveSessions: native.extDeriveSessions,
+  getExchangeOverride: native.extGetExchangeOverride,
+  getFuturesMonths: native.extGetFuturesMonths,
   getMarketRule: native.extGetMarketRule,
+  getMonthCode: native.extGetMonthCode,
+  getMonthName: native.extGetMonthName,
   inferTimezone: native.extInferTimezone,
-  setExchangeOverride: native.extSetExchangeOverride,
-  getExchangeOverride: native.extGetExchangeOverride,
-  clearExchangeOverride: native.extClearExchangeOverride,
+  isLongFormat: native.extIsLongFormat,
+  isSpecificContract: native.extIsSpecificContract,
   listExchangeOverrides: native.extListExchangeOverrides,
-  sessionTimesToUtc: native.extSessionTimesToUtc
+  normalizeTickers: native.extNormalizeTickers,
+  parseCdxTicker: native.extParseCdxTicker,
+  parseDate: native.extParseDate,
+  parseTicker: native.extParseTicker,
+  pivotToWide: native.extPivotToWide,
+  previousCdxSeries: native.extPreviousCdxSeries,
+  renameDividendColumns: native.extRenameDividendColumns,
+  renameEtfColumns: native.extRenameEtfColumns,
+  sameCurrency: native.extSameCurrency,
+  sessionTimesToUtc: native.extSessionTimesToUtc,
+  setExchangeOverride: native.extSetExchangeOverride,
+  validateGenericTicker: native.extValidateGenericTicker
 });
 function version() {
   return packageJson.version;
 }
-var setLogLevel = native.setLogLevel;
-var getLogLevel = native.getLogLevel;
+var { setLogLevel } = native;
+var { getLogLevel } = native;
 
 exports.ArrowSubscription = ArrowSubscription;
 exports.Backend = Backend;