@xbbg/core 1.1.2 → 1.1.4

package/dist/index.js

@@ -0,0 +1,1996 @@
+'use strict';
+
+var fs2 = require('fs');
+var path2 = require('path');
+var module$1 = require('module');
+var apacheArrow = require('apache-arrow');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+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) {
+  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 tableFromNativeArrowBatch(batch) {
+  const retainedBuffers = [];
+  const fields = batch.columns.map((column) => {
+    const type = arrowType(column);
+    return new apacheArrow.Field(column.name, type, column.nullable);
+  });
+  const children = batch.columns.map((column) => dataFromColumn(column, retainedBuffers));
+  const schema = new apacheArrow.Schema(fields);
+  const structData = apacheArrow.makeData({
+    type: new apacheArrow.Struct(fields),
+    length: batch.numRows,
+    children
+  });
+  const table = new apacheArrow.Table(schema, new apacheArrow.RecordBatch(schema, structData));
+  Object.defineProperty(table, NATIVE_ARROW_BUFFERS, {
+    value: retainedBuffers,
+    enumerable: false
+  });
+  return table;
+}
+function dataFromColumn(column, retainedBuffers) {
+  const nullBitmap = optionalUint8View(column.nullBitmap, retainedBuffers);
+  switch (column.type) {
+    case "bool":
+      return apacheArrow.makeData({
+        type: new apacheArrow.Bool(),
+        length: column.length,
+        nullCount: column.nullCount,
+        nullBitmap,
+        data: requiredUint8View(column, retainedBuffers, Math.ceil(column.length / 8))
+      });
+    case "binary":
+      return apacheArrow.makeData({
+        type: new apacheArrow.Binary(),
+        length: column.length,
+        nullCount: column.nullCount,
+        nullBitmap,
+        valueOffsets: requiredOffsets(column, retainedBuffers),
+        data: requiredUint8View(column, retainedBuffers)
+      });
+    case "date32":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.DateDay(), Int32Array);
+    case "date64":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.DateMillisecond(), BigInt64Array);
+    case "float32":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Float32(), Float32Array);
+    case "float64":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Float64(), Float64Array);
+    case "int8":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Int8(), Int8Array);
+    case "int16":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Int16(), Int16Array);
+    case "int32":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Int32(), Int32Array);
+    case "int64":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Int64(), BigInt64Array);
+    case "large_binary":
+      return apacheArrow.makeData({
+        type: new apacheArrow.LargeBinary(),
+        length: column.length,
+        nullCount: column.nullCount,
+        nullBitmap,
+        valueOffsets: requiredLargeOffsets(column, retainedBuffers),
+        data: requiredUint8View(column, retainedBuffers)
+      });
+    case "large_utf8":
+      return apacheArrow.makeData({
+        type: new apacheArrow.LargeUtf8(),
+        length: column.length,
+        nullCount: column.nullCount,
+        nullBitmap,
+        valueOffsets: requiredLargeOffsets(column, retainedBuffers),
+        data: requiredUint8View(column, retainedBuffers)
+      });
+    case "null":
+      return apacheArrow.makeData({
+        type: new apacheArrow.Null(),
+        length: column.length
+      });
+    case "time32_ms":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.TimeMillisecond(), Int32Array);
+    case "time32_s":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.TimeSecond(), Int32Array);
+    case "time64_us":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.TimeMicrosecond(), BigInt64Array);
+    case "time64_ns":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.TimeNanosecond(), BigInt64Array);
+    case "timestamp_ms":
+      return scalarData(
+        column,
+        retainedBuffers,
+        nullBitmap,
+        new apacheArrow.TimestampMillisecond(column.timezone),
+        BigInt64Array
+      );
+    case "timestamp_ns":
+      return scalarData(
+        column,
+        retainedBuffers,
+        nullBitmap,
+        new apacheArrow.TimestampNanosecond(column.timezone),
+        BigInt64Array
+      );
+    case "timestamp_s":
+      return scalarData(
+        column,
+        retainedBuffers,
+        nullBitmap,
+        new apacheArrow.TimestampSecond(column.timezone),
+        BigInt64Array
+      );
+    case "timestamp_us":
+      return scalarData(
+        column,
+        retainedBuffers,
+        nullBitmap,
+        new apacheArrow.TimestampMicrosecond(column.timezone),
+        BigInt64Array
+      );
+    case "uint8":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Uint8(), Uint8Array);
+    case "uint16":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Uint16(), Uint16Array);
+    case "uint32":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Uint32(), Uint32Array);
+    case "uint64":
+      return scalarData(column, retainedBuffers, nullBitmap, new apacheArrow.Uint64(), BigUint64Array);
+    case "utf8":
+      return apacheArrow.makeData({
+        type: new apacheArrow.Utf8(),
+        length: column.length,
+        nullCount: column.nullCount,
+        nullBitmap,
+        valueOffsets: requiredOffsets(column, retainedBuffers),
+        data: requiredUint8View(column, retainedBuffers)
+      });
+  }
+}
+function arrowType(column) {
+  switch (column.type) {
+    case "bool":
+      return new apacheArrow.Bool();
+    case "binary":
+      return new apacheArrow.Binary();
+    case "date32":
+      return new apacheArrow.DateDay();
+    case "date64":
+      return new apacheArrow.DateMillisecond();
+    case "float32":
+      return new apacheArrow.Float32();
+    case "float64":
+      return new apacheArrow.Float64();
+    case "int8":
+      return new apacheArrow.Int8();
+    case "int16":
+      return new apacheArrow.Int16();
+    case "int32":
+      return new apacheArrow.Int32();
+    case "int64":
+      return new apacheArrow.Int64();
+    case "large_binary":
+      return new apacheArrow.LargeBinary();
+    case "large_utf8":
+      return new apacheArrow.LargeUtf8();
+    case "null":
+      return new apacheArrow.Null();
+    case "time32_ms":
+      return new apacheArrow.TimeMillisecond();
+    case "time32_s":
+      return new apacheArrow.TimeSecond();
+    case "time64_us":
+      return new apacheArrow.TimeMicrosecond();
+    case "time64_ns":
+      return new apacheArrow.TimeNanosecond();
+    case "timestamp_ms":
+      return new apacheArrow.TimestampMillisecond(column.timezone);
+    case "timestamp_ns":
+      return new apacheArrow.TimestampNanosecond(column.timezone);
+    case "timestamp_s":
+      return new apacheArrow.TimestampSecond(column.timezone);
+    case "timestamp_us":
+      return new apacheArrow.TimestampMicrosecond(column.timezone);
+    case "uint8":
+      return new apacheArrow.Uint8();
+    case "uint16":
+      return new apacheArrow.Uint16();
+    case "uint32":
+      return new apacheArrow.Uint32();
+    case "uint64":
+      return new apacheArrow.Uint64();
+    case "utf8":
+      return new apacheArrow.Utf8();
+  }
+}
+function scalarData(column, retainedBuffers, nullBitmap, type, ctor) {
+  return apacheArrow.makeData({
+    type,
+    length: column.length,
+    nullCount: column.nullCount,
+    nullBitmap,
+    data: requiredTypedView(column, ctor, retainedBuffers)
+  });
+}
+function requiredTypedView(column, ctor, retainedBuffers) {
+  const buffer = requireBuffer(column, "data");
+  retainedBuffers.push(buffer);
+  return new ctor(buffer.buffer, buffer.byteOffset, column.length);
+}
+function requiredOffsets(column, retainedBuffers) {
+  const buffer = requireBuffer(column, "offsets");
+  retainedBuffers.push(buffer);
+  return new Int32Array(buffer.buffer, buffer.byteOffset, column.length + 1);
+}
+function requiredLargeOffsets(column, retainedBuffers) {
+  const buffer = requireBuffer(column, "offsets");
+  retainedBuffers.push(buffer);
+  return new BigInt64Array(buffer.buffer, buffer.byteOffset, column.length + 1);
+}
+function requiredUint8View(column, retainedBuffers, byteLength) {
+  const buffer = requireBuffer(column, "data");
+  retainedBuffers.push(buffer);
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, byteLength ?? buffer.byteLength);
+}
+function optionalUint8View(buffer, retainedBuffers) {
+  if (buffer === void 0) {
+    return void 0;
+  }
+  retainedBuffers.push(buffer);
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+}
+function requireBuffer(column, property) {
+  const buffer = column[property];
+  if (buffer === void 0) {
+    throw new Error(`native Arrow column ${column.name} is missing ${property} buffer`);
+  }
+  return buffer;
+}
+
+// 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]|$)/;
+function hasToJSDate(value) {
+  return typeof value === "object" && value !== null && "toJSDate" in value && typeof value.toJSDate === "function";
+}
+function rejectAmbiguousString(value) {
+  if (AMBIGUOUS_DATE_RE.test(value) && !ISO_DATE_RE.test(value.trim())) {
+    throw new TypeError(
+      `Ambiguous date format ${JSON.stringify(value)}: month/day order cannot be inferred. Use ISO 8601 (YYYY-MM-DD), Bloomberg-native (YYYYMMDD), or pass a Date / Luxon DateTime.`
+    );
+  }
+}
+function dateLikeToJSDate(value) {
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === "number") {
+    return new Date(value);
+  }
+  if (hasToJSDate(value)) {
+    return value.toJSDate();
+  }
+  if (typeof value === "string") {
+    const text = value.trim();
+    rejectAmbiguousString(text);
+    if (BBG_DATE_RE.test(text)) {
+      const year = Number(text.slice(0, 4));
+      const month = Number(text.slice(4, 6)) - 1;
+      const day = Number(text.slice(6, 8));
+      const dt2 = new Date(Date.UTC(year, month, day));
+      if (Number.isNaN(dt2.getTime())) {
+        throw new TypeError(`Invalid Bloomberg-native date ${JSON.stringify(value)}`);
+      }
+      return dt2;
+    }
+    const normalized = text.replace(" ", "T");
+    const dt = new Date(normalized);
+    if (Number.isNaN(dt.getTime())) {
+      throw new TypeError(
+        `Cannot parse ${JSON.stringify(value)} as a date. Expected ISO 8601, Bloomberg-native YYYYMMDD, Date, epoch ms, or Luxon DateTime.`
+      );
+    }
+    return dt;
+  }
+  throw new TypeError(
+    `Cannot convert ${typeof value} value ${String(value)} to a Date.`
+  );
+}
+function formatDate(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const text = value.trim();
+    if (text.length === 0) {
+      return void 0;
+    }
+    if (BBG_DATE_RE.test(text)) {
+      return text;
+    }
+    rejectAmbiguousString(text);
+    if (ISO_DATE_RE.test(text)) {
+      return text.replace(/[-/]/g, "");
+    }
+  }
+  const date = dateLikeToJSDate(value);
+  const y = String(date.getUTCFullYear()).padStart(4, "0");
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  return `${y}${m}${d}`;
+}
+function formatDateTime(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const text = value.trim();
+    if (text.length === 0) {
+      return void 0;
+    }
+    rejectAmbiguousString(text);
+    if (BBG_DATE_RE.test(text)) {
+      return `${text.slice(0, 4)}-${text.slice(4, 6)}-${text.slice(6, 8)}T00:00:00`;
+    }
+    return text.replace(" ", "T");
+  }
+  const date = dateLikeToJSDate(value);
+  return date.toISOString();
+}
+
+// src/native/platform-map.ts
+var platformPackages = Object.freeze({
+  "darwin-arm64": "@xbbg/core-darwin-arm64",
+  "linux-x64": "@xbbg/core-linux-x64",
+  "win32-x64": "@xbbg/core-win32-x64"
+});
+function platformKey(platform = process.platform, arch = process.arch) {
+  return `${platform}-${arch}`;
+}
+
+// src/native/resolve-native.ts
+var nodeRequire = module$1.createRequire(__filename);
+function exists(target) {
+  try {
+    fs2__default.default.accessSync(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isResolutionObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateNativePackage(packageName, resolved) {
+  if (!isResolutionObject(resolved)) {
+    throw new Error(`Invalid native package ${packageName}: expected an object with binaryPath`);
+  }
+  if (!("binaryPath" in 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`);
+  }
+  return resolved;
+}
+function localPackageIndex(repoRoot, packageName) {
+  const dirName = packageName.replace("@xbbg/", "xbbg-");
+  return path2__default.default.join(repoRoot, "packages", dirName, "index.js");
+}
+function isOptionalPackageMissing(err, packageName) {
+  if (!(err instanceof Error)) {
+    return false;
+  }
+  const code = "code" in err ? err.code : void 0;
+  if (code !== "MODULE_NOT_FOUND") {
+    return false;
+  }
+  return err.message.includes(`Cannot find module '${packageName}'`) || err.message.includes(`Cannot find module "${packageName}"`) || err.message.includes(`Cannot find package '${packageName}'`) || err.message.includes(`Cannot find package "${packageName}"`);
+}
+function resolveInstalledPackage(packageName, requirePackage, existsFile) {
+  try {
+    const resolved = validateNativePackage(packageName, requirePackage(packageName));
+    if (!existsFile(resolved.binaryPath)) {
+      throw new Error(
+        `Invalid native package ${packageName}: binaryPath does not exist: ${resolved.binaryPath}`
+      );
+    }
+    return resolved;
+  } catch (err) {
+    if (isOptionalPackageMissing(err, packageName)) {
+      return null;
+    }
+    throw err;
+  }
+}
+function resolveLocalPackage(repoRoot, packageName, requirePackage, existsFile) {
+  const localIndex = localPackageIndex(repoRoot, packageName);
+  if (!existsFile(localIndex)) {
+    return null;
+  }
+  const resolved = validateNativePackage(packageName, requirePackage(localIndex));
+  if (!existsFile(resolved.binaryPath)) {
+    throw new Error(
+      `Invalid native package ${packageName}: binaryPath does not exist: ${resolved.binaryPath}`
+    );
+  }
+  return resolved;
+}
+function resolveNativeAddonCore(options) {
+  const { key, packageName, repoRoot, requirePackage, exists: existsFile } = options;
+  if (packageName === null) {
+    return { key, packageName: null, binaryPath: null };
+  }
+  const installed = resolveInstalledPackage(packageName, requirePackage, existsFile);
+  if (installed !== null) {
+    return { key, packageName, binaryPath: installed.binaryPath };
+  }
+  const local = resolveLocalPackage(repoRoot, packageName, requirePackage, existsFile);
+  if (local !== null) {
+    return { key, packageName, binaryPath: local.binaryPath };
+  }
+  return { key, packageName, binaryPath: null };
+}
+function resolveNativeAddon(repoRoot) {
+  const key = platformKey();
+  const packageName = platformPackages[key] ?? null;
+  return resolveNativeAddonCore({
+    key,
+    packageName,
+    repoRoot,
+    requirePackage: (id) => nodeRequire(id),
+    exists
+  });
+}
+
+// src/index.ts
+var nodeRequire2 = module$1.createRequire(__filename);
+var packageJson = nodeRequire2("../package.json");
+function containsBlpapiRuntime(dir) {
+  if (dir.length === 0 || !fs2__default.default.existsSync(dir)) {
+    return false;
+  }
+  return [
+    "blpapi3_64.dll",
+    "blpapi3_32.dll",
+    "libblpapi3.dylib",
+    "libblpapi3_64.so",
+    "libblpapi3.so"
+  ].some((name) => fs2__default.default.existsSync(path2__default.default.join(dir, name)));
+}
+function parseVersionParts(name) {
+  const parts = name.split(".").map((part) => Number(part));
+  return parts.every((part) => Number.isInteger(part) && part >= 0) ? parts : null;
+}
+function compareSdkRoots(left, right) {
+  const leftParts = parseVersionParts(path2__default.default.basename(left));
+  const rightParts = parseVersionParts(path2__default.default.basename(right));
+  if (leftParts !== null && rightParts !== null) {
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+      const leftPart = leftParts[index] ?? 0;
+      const rightPart = rightParts[index] ?? 0;
+      if (leftPart !== rightPart) {
+        return rightPart - leftPart;
+      }
+    }
+  }
+  if (leftParts !== null) return -1;
+  if (rightParts !== null) return 1;
+  return right.localeCompare(left);
+}
+function pushSdkRuntimeCandidates(candidates, sdkRoot) {
+  const resolved = path2__default.default.resolve(sdkRoot);
+  candidates.push(resolved, path2__default.default.join(resolved, "bin"), path2__default.default.join(resolved, "lib"));
+}
+function resolveVendorSdkRoot(repoRoot) {
+  const vendorDir = path2__default.default.join(repoRoot, "vendor", "blpapi-sdk");
+  if (!fs2__default.default.existsSync(vendorDir)) {
+    return null;
+  }
+  const candidates = [vendorDir];
+  for (const entry of fs2__default.default.readdirSync(vendorDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      candidates.push(path2__default.default.join(vendorDir, entry.name));
+    }
+  }
+  candidates.sort(compareSdkRoots);
+  return candidates.find((candidate) => {
+    const dirs = [candidate, path2__default.default.join(candidate, "bin"), path2__default.default.join(candidate, "lib")];
+    return dirs.some(containsBlpapiRuntime);
+  }) ?? null;
+}
+function configureRuntimeSearchPath() {
+  if (process.platform !== "win32") {
+    return;
+  }
+  const candidates = [];
+  const libDir = process.env.BLPAPI_LIB_DIR;
+  if (libDir !== void 0 && libDir.length > 0) {
+    candidates.push(path2__default.default.resolve(libDir));
+  }
+  const root = process.env.BLPAPI_ROOT;
+  if (root !== void 0 && root.length > 0) {
+    pushSdkRuntimeCandidates(candidates, root);
+  }
+  const repoRoot = path2__default.default.resolve(__dirname, "..", "..");
+  const devRoot = process.env.XBBG_DEV_SDK_ROOT;
+  if (devRoot !== void 0 && devRoot.length > 0) {
+    pushSdkRuntimeCandidates(
+      candidates,
+      path2__default.default.isAbsolute(devRoot) ? devRoot : path2__default.default.resolve(repoRoot, devRoot)
+    );
+  }
+  const vendorRoot = resolveVendorSdkRoot(repoRoot);
+  if (vendorRoot !== null) {
+    pushSdkRuntimeCandidates(candidates, vendorRoot);
+  }
+  for (const candidate of candidates) {
+    if (!containsBlpapiRuntime(candidate)) {
+      continue;
+    }
+    const currentPath = process.env.PATH ?? "";
+    const parts = currentPath.split(";").filter((part) => part.length > 0);
+    if (!parts.includes(candidate)) {
+      process.env.PATH = currentPath.length > 0 ? `${candidate};${currentPath}` : candidate;
+    }
+    break;
+  }
+}
+configureRuntimeSearchPath();
+function loadNative() {
+  const root = path2__default.default.resolve(__dirname, "..", "..");
+  const candidates = [
+    path2__default.default.join(__dirname, "napi_xbbg.node"),
+    path2__default.default.join(__dirname, "..", "napi_xbbg.node"),
+    path2__default.default.join(__dirname, "napi-xbbg.node")
+  ];
+  for (const candidate of candidates) {
+    if (fs2__default.default.existsSync(candidate)) {
+      return nodeRequire2(candidate);
+    }
+  }
+  const { key, packageName, binaryPath } = resolveNativeAddon(root);
+  if (binaryPath !== null) {
+    return nodeRequire2(binaryPath);
+  }
+  if (packageName === null) {
+    throw new Error(
+      `No packaged @xbbg/core native addon is available for ${key}. Build it locally with "npm run build" from js-xbbg.`
+    );
+  }
+  throw new Error(
+    `Unable to load native napi-xbbg module for ${key}. Install ${packageName} via Bun/npm, or build it locally with "npm run build" from js-xbbg.`
+  );
+}
+var native = loadNative();
+var Backend = Object.freeze({
+  ARROW: "arrow",
+  JSON: "json",
+  POLARS: "polars"
+});
+var Format = Object.freeze({
+  LONG: "long",
+  LONG_TYPED: "long_typed",
+  LONG_WITH_METADATA: "long_with_metadata",
+  SEMI_LONG: "semi_long"
+});
+var CDX_INFO_FIELDS = Object.freeze([
+  "ROLLING_SERIES",
+  "VERSION",
+  "ON_THE_RUN_CURRENT_BD_INDICATOR",
+  "CDS_FIRST_ACCRUAL_START_DATE",
+  "NAME",
+  "NUM_CURRENT_COMPANIES_CCY_TKR",
+  "NUM_ORIG_COMPANIES_CRNCY_TKR",
+  "PX_LAST"
+]);
+var CDX_PRICING_FIELDS = Object.freeze([
+  "PX_LAST",
+  "PX_BID",
+  "PX_ASK",
+  "UPFRONT_LAST",
+  "UPFRONT_BID",
+  "UPFRONT_ASK",
+  "CDS_FLAT_SPREAD",
+  "UPFRONT_FEE",
+  "PV_CDS_PREMIUM_LEG",
+  "PV_CDS_DEFAULT_LEG"
+]);
+var CDX_RISK_FIELDS = Object.freeze([
+  "SW_CNV_BPV",
+  "SW_EQV_BPV",
+  "CDS_SPREAD_MID_MODIFIED_DURATION",
+  "CDS_SPREAD_MID_CONVEXITY",
+  "RECOVERY_RATE_SEN",
+  "CDS_RECOVERY_RT"
+]);
+var TA_STUDIES = Object.freeze({
+  smavg: "smavgStudyAttributes",
+  sma: "smavgStudyAttributes",
+  emavg: "emavgStudyAttributes",
+  ema: "emavgStudyAttributes",
+  wmavg: "wmavgStudyAttributes",
+  wma: "wmavgStudyAttributes",
+  vmavg: "vmavgStudyAttributes",
+  vma: "vmavgStudyAttributes",
+  tmavg: "tmavgStudyAttributes",
+  tma: "tmavgStudyAttributes",
+  ipmavg: "ipmavgStudyAttributes",
+  rsi: "rsiStudyAttributes",
+  macd: "macdStudyAttributes",
+  mao: "maoStudyAttributes",
+  momentum: "momentumStudyAttributes",
+  mom: "momentumStudyAttributes",
+  roc: "rocStudyAttributes",
+  boll: "bollStudyAttributes",
+  bb: "bollStudyAttributes",
+  kltn: "kltnStudyAttributes",
+  keltner: "kltnStudyAttributes",
+  mae: "maeStudyAttributes",
+  te: "teStudyAttributes",
+  al: "alStudyAttributes",
+  dmi: "dmiStudyAttributes",
+  adx: "dmiStudyAttributes",
+  tas: "tasStudyAttributes",
+  stoch: "tasStudyAttributes",
+  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",
+  williams: "wlprStudyAttributes",
+  maxmin: "maxminStudyAttributes",
+  rex: "rexStudyAttributes",
+  etd: "etdStudyAttributes",
+  pd: "pdStudyAttributes",
+  rv: "rvStudyAttributes",
+  pivot: "pivotStudyAttributes",
+  or: "orStudyAttributes",
+  pcr: "pcrStudyAttributes",
+  bs: "bsStudyAttributes"
+});
+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,
+    priceSourceClose: "PX_LAST"
+  }),
+  bollStudyAttributes: Object.freeze({
+    period: 20,
+    upperBand: 2,
+    lowerBand: 2,
+    priceSourceClose: "PX_LAST"
+  }),
+  dmiStudyAttributes: Object.freeze({
+    period: 14,
+    priceSourceHigh: "PX_HIGH",
+    priceSourceLow: "PX_LOW",
+    priceSourceClose: "PX_LAST"
+  }),
+  atrStudyAttributes: Object.freeze({
+    maType: "Simple",
+    period: 14,
+    priceSourceHigh: "PX_HIGH",
+    priceSourceLow: "PX_LOW",
+    priceSourceClose: "PX_LAST"
+  }),
+  tasStudyAttributes: Object.freeze({
+    periodK: 14,
+    periodD: 3,
+    periodDS: 3,
+    periodDSS: 3,
+    priceSourceHigh: "PX_HIGH",
+    priceSourceLow: "PX_LOW",
+    priceSourceClose: "PX_LAST"
+  })
+});
+function toArrowTableFromNative(batch) {
+  return tableFromNativeArrowBatch(batch);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toRequestString(value) {
+  return String(value);
+}
+function mapObjectToPairs(obj) {
+  if (obj === void 0) {
+    return void 0;
+  }
+  return Object.entries(obj).map(([key, value]) => ({
+    key: toRequestString(key),
+    value: toRequestString(value)
+  }));
+}
+var BDTICK_BOOLEAN_KWARGS = Object.freeze([
+  ["includeConditionCodes", "includeConditionCodes"],
+  ["includeExchangeCodes", "includeExchangeCodes"],
+  ["includeBrokerCodes", "includeBrokerCodes"],
+  ["includeRpsCodes", "includeRpsCodes"],
+  ["includeBicMicCodes", "includeBicMicCodes"],
+  ["includeNonPlottableEvents", "includeNonPlottableEvents"],
+  ["includeBloombergStandardConditionCodes", "includeBloombergStandardConditionCodes"]
+]);
+function upsertStringPair(pairs, key, value) {
+  const existing = pairs.find((pair) => pair.key === key);
+  if (existing === void 0) {
+    pairs.push({ key, value });
+    return;
+  }
+  existing.value = value;
+}
+function buildBdtickKwargs(options) {
+  const pairs = mapObjectToPairs(options.kwargs) ?? [];
+  for (const [optionName, requestName] of BDTICK_BOOLEAN_KWARGS) {
+    const typedValue = options[optionName];
+    if (typedValue !== void 0) {
+      upsertStringPair(pairs, requestName, typedValue ? "true" : "false");
+    }
+  }
+  return pairs.length > 0 ? pairs : void 0;
+}
+function toStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => toRequestString(item));
+  }
+  if (value === null || value === void 0) {
+    return [];
+  }
+  return [toRequestString(value)];
+}
+function normalizeConfigureArgs(configOrHost, port) {
+  if (configOrHost === void 0) {
+    return void 0;
+  }
+  if (typeof configOrHost === "string" || port !== void 0) {
+    const config = {};
+    if (typeof configOrHost === "string") {
+      config.host = configOrHost;
+    }
+    if (port !== void 0) {
+      config.port = port;
+    }
+    return config;
+  }
+  if (isPlainObject(configOrHost)) {
+    return { ...configOrHost };
+  }
+  throw new TypeError(
+    "configure expects either a config object or host/port arguments"
+  );
+}
+function normalizeRecoveryOptions(options = {}) {
+  const normalized = { ...options };
+  const recoveryRate = normalized.recoveryRate ?? normalized.recovery_rate;
+  delete normalized.recoveryRate;
+  delete normalized.recovery_rate;
+  if (recoveryRate !== void 0) {
+    normalized.overrides = {
+      ...normalized.overrides ?? {},
+      CDS_RR: toRequestString(recoveryRate)
+    };
+  }
+  return normalized;
+}
+function fullDayRange(dt) {
+  const formatted = formatDate(dt);
+  if (formatted === void 0) {
+    throw new TypeError("dt must be a non-empty date-like value");
+  }
+  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`
+  };
+}
+function normalizeDate(value) {
+  return formatDate(value);
+}
+function getStudyAttrName(study) {
+  const normalized = study.toLowerCase().replace(/-/g, "_").replace(/ /g, "_");
+  const mapped = TA_STUDIES[normalized];
+  if (mapped !== void 0) {
+    return mapped;
+  }
+  if (normalized.endsWith("studyattributes")) {
+    return normalized;
+  }
+  return `${normalized}StudyAttributes`;
+}
+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 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 interval = kwargs.interval ?? rawStudy.interval ?? options.interval;
+  delete kwargs.startDate;
+  delete kwargs.start_date;
+  delete kwargs.endDate;
+  delete kwargs.end_date;
+  delete kwargs.periodicitySelection;
+  delete kwargs.periodicity;
+  delete rawStudy.studyType;
+  delete rawStudy.study;
+  delete rawStudy.calcInterval;
+  if (rawStudy.length !== void 0 && rawStudy.period === void 0) {
+    rawStudy.period = rawStudy.length;
+  }
+  delete rawStudy.length;
+  const params = {
+    ...TA_DEFAULTS[attrName] ?? {},
+    ...options.studyParams ?? {},
+    ...rawStudy
+  };
+  if (params.length !== void 0 && params.period === void 0) {
+    params.period = params.length;
+  }
+  delete params.length;
+  delete params.calcInterval;
+  const elements = [
+    { key: "priceSource.securityName", value: toRequestString(ticker) }
+  ];
+  if (periodicity === "INTRADAY") {
+    const prefix = "priceSource.dataRange.intraday";
+    if (startDate !== void 0) {
+      elements.push({ key: `${prefix}.startDate`, value: startDate });
+    }
+    if (endDate !== void 0) {
+      elements.push({ key: `${prefix}.endDate`, value: endDate });
+    }
+    elements.push({ key: `${prefix}.eventType`, value: "TRADE" });
+    if (interval !== void 0) {
+      elements.push({ key: `${prefix}.interval`, value: toRequestString(interval) });
+    }
+  } else {
+    const prefix = "priceSource.dataRange.historical";
+    if (startDate !== void 0) {
+      elements.push({ key: `${prefix}.startDate`, value: startDate });
+    }
+    if (endDate !== void 0) {
+      elements.push({ key: `${prefix}.endDate`, value: endDate });
+    }
+    elements.push({ key: `${prefix}.periodicitySelection`, value: periodicity });
+  }
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) {
+      continue;
+    }
+    elements.push({
+      key: `studyAttributes.${attrName}.${key}`,
+      value: toRequestString(value)
+    });
+  }
+  for (const [key, value] of Object.entries(kwargs)) {
+    elements.push({ key: toRequestString(key), value: toRequestString(value) });
+  }
+  return elements;
+}
+function stringOrUndef(value) {
+  return typeof value === "string" ? value : void 0;
+}
+var polarsModule;
+var polarsLoadError;
+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 });
+  polarsLoadError = error;
+  return error;
+}
+function loadPolars() {
+  if (polarsModule !== void 0) {
+    return polarsModule;
+  }
+  if (polarsLoadError !== void 0) {
+    throw polarsLoadError;
+  }
+  try {
+    polarsModule = nodeRequire2("nodejs-polars");
+    return polarsModule;
+  } catch (err) {
+    throw cachePolarsLoadError(err);
+  }
+}
+function normalizeBackend(backend) {
+  const selected = backend ?? Backend.ARROW;
+  if (selected === Backend.ARROW || selected === Backend.JSON || selected === Backend.POLARS) {
+    return selected;
+  }
+  throw new TypeError(
+    `Unsupported @xbbg/core backend "${toRequestString(selected)}". Expected one of: ${Object.values(
+      Backend
+    ).join(", ")}`
+  );
+}
+function ipcToBackend(buffer, backend) {
+  const selected = normalizeBackend(backend);
+  if (selected === Backend.JSON) {
+    return Array.from(apacheArrow.tableFromIPC(buffer));
+  }
+  if (selected === Backend.POLARS) {
+    return loadPolars().readIPC(buffer);
+  }
+  return apacheArrow.tableFromIPC(buffer);
+}
+var configuredEngineConfig;
+var configuredEnginePromise;
+function clearConfiguredEngine() {
+  const existing = configuredEnginePromise;
+  configuredEnginePromise = void 0;
+  if (existing !== void 0) {
+    existing.then((engine) => {
+      engine.signalShutdown();
+    }).catch(() => {
+    });
+  }
+}
+async function getConfiguredEngine() {
+  if (configuredEnginePromise === void 0) {
+    const pending = connect(configuredEngineConfig);
+    pending.catch(() => {
+      if (configuredEnginePromise === pending) {
+        configuredEnginePromise = void 0;
+      }
+    });
+    configuredEnginePromise = pending;
+  }
+  return await configuredEnginePromise;
+}
+var FieldHandle = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+};
+var Tick = class {
+  constructor(_update) {
+    this._update = _update;
+    this._positions = new Map(_update.fields.map((field, index) => [field, index]));
+  }
+  _update;
+  _positions;
+  get topic() {
+    return this._update.topic;
+  }
+  get timestampUs() {
+    return this._update.timestampUs;
+  }
+  get 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;
+    if (kind === "i64" || kind === "time64_us" || kind === "timestamp_us") {
+      try {
+        return BigInt(String(value));
+      } catch {
+        return null;
+      }
+    }
+    if (kind === "date32" && typeof value === "number") {
+      return new Date(Date.UTC(1970, 0, 1 + value));
+    }
+    return value;
+  }
+  f64(field) {
+    const value = this.get(field);
+    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;
+    try {
+      return BigInt(String(value));
+    } catch {
+      return null;
+    }
+  }
+  str(field) {
+    const value = this.get(field);
+    return value === null ? null : String(value);
+  }
+  toObject() {
+    const out = { topic: this.topic, timestampUs: this.timestampUs };
+    for (const field of this._update.fields) {
+      out[field] = this.get(field);
+    }
+    return out;
+  }
+};
+var ArrowSubscription = class {
+  constructor(_inner) {
+    this._inner = _inner;
+  }
+  _inner;
+  async next() {
+    try {
+      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);
+    }
+  }
+  async unsubscribe(drain = false) {
+    try {
+      const drained = await this._inner.unsubscribeArrow(drain);
+      return drained?.map(toArrowTableFromNative) ?? [];
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+var Subscription = class {
+  _inner;
+  constructor(inner) {
+    this._inner = inner;
+  }
+  async next() {
+    try {
+      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);
+    }
+  }
+  async add(tickers) {
+    try {
+      await this._inner.add(tickers);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async remove(tickers) {
+    try {
+      await this._inner.remove(tickers);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async unsubscribe(drain = false) {
+    try {
+      const drained = await this._inner.unsubscribe(drain);
+      if (drained === null) {
+        return [];
+      }
+      return drained.map((update) => new Tick(update));
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  field(name) {
+    return new FieldHandle(name);
+  }
+  arrow() {
+    return new ArrowSubscription(this._inner);
+  }
+  get tickers() {
+    return this._inner.tickers;
+  }
+  get fields() {
+    return this._inner.fields;
+  }
+  get isActive() {
+    return this._inner.isActive;
+  }
+  get stats() {
+    return this._inner.stats;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+var Engine = class _Engine {
+  // Set via constructor or via `withConfig` (which instantiates via Object.create).
+  _inner;
+  constructor(host = "localhost", port = 8194) {
+    try {
+      this._inner = new native.JsEngine(host, port);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  static withConfig(config = {}) {
+    const engine = Object.create(_Engine.prototype);
+    try {
+      engine._inner = native.JsEngine.withConfig(config);
+    } catch (err) {
+      throw wrapError(err);
+    }
+    return engine;
+  }
+  async request(params) {
+    const backend = normalizeBackend(params.backend);
+    const { backend: _discarded, ...nativeParams } = params;
+    try {
+      const buffer = await this._inner.request(nativeParams);
+      return ipcToBackend(buffer, backend);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async requestRaw(params) {
+    try {
+      return await this._inner.request(params);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async bdp(tickers, fields, options = {}) {
+    return await this.request({
+      service: "//blp/refdata",
+      operation: "ReferenceDataRequest",
+      securities: tickers,
+      fields,
+      overrides: mapObjectToPairs(options.overrides),
+      kwargs: mapObjectToPairs(options.kwargs),
+      format: options.format,
+      backend: options.backend,
+      includeSecurityErrors: Boolean(options.includeSecurityErrors),
+      validateFields: options.validateFields,
+      extractor: "refdata"
+    });
+  }
+  async bds(tickers, fields, options = {}) {
+    return await this.request({
+      service: "//blp/refdata",
+      operation: "ReferenceDataRequest",
+      securities: tickers,
+      fields,
+      overrides: mapObjectToPairs(options.overrides),
+      kwargs: mapObjectToPairs(options.kwargs),
+      format: options.format,
+      backend: options.backend,
+      validateFields: options.validateFields,
+      extractor: "bulk"
+    });
+  }
+  async bdh(tickers, fields, options = {}) {
+    return await this.request({
+      service: "//blp/refdata",
+      operation: "HistoricalDataRequest",
+      securities: tickers,
+      fields,
+      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"
+    });
+  }
+  async bdib(ticker, options = {}) {
+    return await this.request({
+      service: "//blp/refdata",
+      operation: "IntradayBarRequest",
+      security: ticker,
+      eventType: options.eventType ?? "TRADE",
+      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"
+    });
+  }
+  async bdtick(ticker, options = {}) {
+    return await this.request({
+      service: "//blp/refdata",
+      operation: "IntradayTickRequest",
+      security: ticker,
+      eventTypes: options.eventTypes ?? ["TRADE"],
+      startDatetime: formatDateTime(options.start),
+      endDatetime: formatDateTime(options.end),
+      requestTz: options.requestTz,
+      outputTz: options.outputTz,
+      kwargs: buildBdtickKwargs(options),
+      backend: options.backend,
+      extractor: "intraday_tick"
+    });
+  }
+  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),
+      format: options.format,
+      extractor: "bql"
+    });
+  }
+  async beqs(screen, options = {}) {
+    const elements = [
+      { key: "screenName", value: toRequestString(screen) },
+      { key: "screenType", value: toRequestString(options.screenType ?? "PRIVATE") },
+      { key: "Group", value: toRequestString(options.group ?? "General") }
+    ];
+    if (options.asof !== void 0) {
+      const asofFormatted = formatDate(options.asof);
+      if (asofFormatted !== void 0) {
+        elements.push({ key: "asOfDate", value: asofFormatted });
+      }
+    }
+    const overrides = { ...options.overrides ?? {} };
+    return await this.request({
+      service: "//blp/refdata",
+      operation: "BeqsRequest",
+      elements,
+      backend: options.backend,
+      kwargs: mapObjectToPairs(options.kwargs),
+      overrides: mapObjectToPairs(overrides),
+      format: options.format,
+      extractor: "generic"
+    });
+  }
+  async bsrch(searchSpec, options = {}) {
+    const elements = {
+      Domain: toRequestString(searchSpec),
+      ...options.overrides ?? {},
+      ...options.kwargs ?? {}
+    };
+    return await this.request({
+      service: "//blp/exrsvc",
+      operation: "ExcelGetGridRequest",
+      backend: options.backend,
+      elements: mapObjectToPairs(elements),
+      format: options.format,
+      extractor: "bsrch"
+    });
+  }
+  async bta(ticker, study, options = {}) {
+    return await this.request({
+      service: "//blp/tasvc",
+      operation: "studyRequest",
+      elements: buildTaRequest(ticker, study, options),
+      backend: options.backend,
+      format: options.format,
+      extractor: "generic"
+    });
+  }
+  async bflds(options = {}) {
+    if (options.searchSpec !== void 0) {
+      return await this.request({
+        service: "//blp/apiflds",
+        operation: "FieldSearchRequest",
+        searchSpec: toRequestString(options.searchSpec),
+        backend: options.backend,
+        kwargs: mapObjectToPairs(options.kwargs),
+        format: options.format
+      });
+    }
+    const fields = Array.isArray(options.fields) ? options.fields : typeof options.fields === "string" ? [options.fields] : [];
+    return await this.request({
+      service: "//blp/apiflds",
+      operation: "FieldInfoRequest",
+      fieldIds: fields,
+      backend: options.backend,
+      kwargs: mapObjectToPairs(options.kwargs),
+      format: options.format
+    });
+  }
+  async blkp(query, options = {}) {
+    return await this.request({
+      service: "//blp/instruments",
+      operation: "instrumentListRequest",
+      elements: [{ key: "query", value: toRequestString(query) }],
+      backend: options.backend,
+      kwargs: mapObjectToPairs(options.kwargs),
+      format: options.format
+    });
+  }
+  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),
+      kwargs: mapObjectToPairs(options.kwargs),
+      format: options.format
+    });
+  }
+  async bcurves(ticker, options = {}) {
+    return await this.request({
+      service: "//blp/instruments",
+      operation: "curveListRequest",
+      elements: [{ key: "query", value: toRequestString(ticker) }],
+      backend: options.backend,
+      kwargs: mapObjectToPairs(options.kwargs),
+      format: options.format
+    });
+  }
+  async bgovts(ticker, options = {}) {
+    return await this.request({
+      service: "//blp/instruments",
+      operation: "govtListRequest",
+      elements: [{ key: "query", value: toRequestString(ticker) }],
+      backend: options.backend,
+      kwargs: mapObjectToPairs(options.kwargs),
+      format: options.format
+    });
+  }
+  async resolveFieldTypes(fields, overrides, defaultType = "string") {
+    const items = await this._inner.resolveFieldTypes(
+      fields,
+      mapObjectToPairs(overrides),
+      defaultType
+    );
+    return Object.fromEntries(items.map((item) => [item.key, item.value]));
+  }
+  getFieldInfo(field) {
+    return this._inner.getFieldInfo(field);
+  }
+  clearFieldCache() {
+    this._inner.clearFieldCache();
+  }
+  saveFieldCache() {
+    this._inner.saveFieldCache();
+  }
+  async validateFields(fields) {
+    return await this._inner.validateFields(fields);
+  }
+  isFieldValidationEnabled() {
+    return this._inner.isFieldValidationEnabled();
+  }
+  async 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);
+    return JSON.parse(json);
+  }
+  async listOperations(service) {
+    return await this._inner.listOperations(service);
+  }
+  getCachedSchema(service) {
+    const json = this._inner.getCachedSchema(service);
+    return json === null ? null : JSON.parse(json);
+  }
+  invalidateSchema(service) {
+    this._inner.invalidateSchema(service);
+  }
+  clearSchemaCache() {
+    this._inner.clearSchemaCache();
+  }
+  listCachedSchemas() {
+    return this._inner.listCachedSchemas();
+  }
+  async getEnumValues(service, operation, element) {
+    return await this._inner.getEnumValues(service, operation, element);
+  }
+  async listValidElements(service, operation) {
+    return await this._inner.listValidElements(service, operation);
+  }
+  async subscribe(tickers, fields, options = {}) {
+    try {
+      const useOptions = options.options !== void 0 || options.flushThreshold !== void 0 || options.overflowPolicy !== void 0 || options.streamCapacity !== void 0;
+      const stream = useOptions ? await this._inner.subscribeWithOptions(
+        "//blp/mktdata",
+        tickers,
+        fields,
+        options.options,
+        options.flushThreshold,
+        options.overflowPolicy,
+        options.streamCapacity,
+        options.allFields
+      ) : await this._inner.subscribe(tickers, fields, options.allFields);
+      return new Subscription(stream);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async subscribeWithOptions(service, tickers, fields, options, flushThreshold, overflowPolicy, streamCapacity, allFields) {
+    try {
+      const stream = await this._inner.subscribeWithOptions(
+        service,
+        tickers,
+        fields,
+        options,
+        flushThreshold,
+        overflowPolicy,
+        streamCapacity,
+        allFields
+      );
+      return new Subscription(stream);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  signalShutdown() {
+    this._inner.signalShutdown();
+  }
+  isAvailable() {
+    return this._inner.isAvailable();
+  }
+  async stream(tickers, fields, options = {}) {
+    return await this.subscribeWithOptions(
+      "//blp/mktdata",
+      tickers,
+      fields,
+      options.options,
+      options.flushThreshold,
+      options.overflowPolicy,
+      options.streamCapacity,
+      options.allFields
+    );
+  }
+  async vwap(tickers, fields, options = {}) {
+    return await this.subscribeWithOptions(
+      "//blp/mktvwap",
+      tickers,
+      fields,
+      options.options,
+      options.flushThreshold,
+      options.overflowPolicy,
+      options.streamCapacity,
+      options.allFields
+    );
+  }
+  async mktbar(ticker, options = {}) {
+    return await this.subscribeWithOptions(
+      "//blp/mktbar",
+      [ticker],
+      options.fields ?? [],
+      options.options,
+      options.flushThreshold,
+      options.overflowPolicy,
+      options.streamCapacity,
+      options.allFields
+    );
+  }
+  async depth(ticker, options = {}) {
+    return await this.subscribeWithOptions(
+      "//blp/mktdepthdata",
+      [ticker],
+      options.fields ?? [],
+      options.options,
+      options.flushThreshold,
+      options.overflowPolicy,
+      options.streamCapacity,
+      options.allFields
+    );
+  }
+  async chains(ticker, options = {}) {
+    return await this.subscribeWithOptions(
+      "//blp/mktlist",
+      [ticker],
+      options.fields ?? [],
+      options.options,
+      options.flushThreshold,
+      options.overflowPolicy,
+      options.streamCapacity,
+      options.allFields
+    );
+  }
+  async bops(service) {
+    return await this._inner.listOperations(service);
+  }
+  async bschema(service, operation) {
+    if (operation !== void 0) {
+      const json2 = await this._inner.getOperation(service, operation);
+      return JSON.parse(json2);
+    }
+    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)],
+      ...options
+    });
+  }
+  async fieldSearch(searchSpec, options = {}) {
+    return await this.bflds({ searchSpec: toRequestString(searchSpec), ...options });
+  }
+  // ── Recipes ─────────────────────────────────────────────────────────
+  async bqr(ticker, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this._inner.recipeBqr(
+        toRequestString(ticker),
+        formatDateTime(options.startDatetime),
+        formatDateTime(options.endDatetime),
+        options.eventTypes ?? null,
+        options.includeBrokerCodes !== false
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async yas(tickers, fields, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this._inner.recipeYas(
+        toStringArray(tickers),
+        toStringArray(fields),
+        formatDate(options.settleDt),
+        options.yieldType ?? void 0,
+        options.spread ?? void 0,
+        options.yieldVal ?? void 0,
+        options.price ?? void 0,
+        options.benchmark ?? void 0
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async preferreds(equityTicker, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      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);
+    }
+  }
+  async corporateBonds(ticker, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      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);
+    }
+  }
+  async futTicker(genTicker, dt, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this._inner.recipeFutTicker(
+        toRequestString(genTicker),
+        formatDate(dt) ?? "",
+        options.freq ?? void 0
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async activeFutures(genTicker, dt, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this._inner.recipeActiveFutures(
+        toRequestString(genTicker),
+        formatDate(dt) ?? "",
+        options.freq ?? void 0
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async cdxTicker(genTicker, dt, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this._inner.recipeCdxTicker(
+        toRequestString(genTicker),
+        formatDate(dt) ?? ""
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async activeCdx(genTicker, dt, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this._inner.recipeActiveCdx(
+        toRequestString(genTicker),
+        formatDate(dt) ?? "",
+        options.lookbackDays ?? void 0
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async dividend(tickers, startDate, endDate, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      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);
+    }
+  }
+  async turnover(tickers, startDate, endDate, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this._inner.recipeTurnover(
+        toStringArray(tickers),
+        formatDate(startDate) ?? "",
+        formatDate(endDate) ?? "",
+        options.ccy ?? void 0,
+        options.factor ?? void 0
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+  async etfHoldings(etfTicker, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      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);
+    }
+  }
+  async currencyConversion(ticker, targetCcy, startDate, endDate, options = {}) {
+    const backend = normalizeBackend(options.backend);
+    try {
+      const buffer = await this._inner.recipeCurrencyConversion(
+        toRequestString(ticker),
+        toRequestString(targetCcy),
+        formatDate(startDate) ?? "",
+        formatDate(endDate) ?? ""
+      );
+      return ipcToBackend(buffer, backend);
+    } catch (err) {
+      throw wrapError(err);
+    }
+  }
+};
+async function connect(config) {
+  return await Promise.resolve(
+    config === void 0 ? new Engine() : Engine.withConfig(config)
+  );
+}
+function configure(configOrHost, port) {
+  configuredEngineConfig = normalizeConfigureArgs(configOrHost, port);
+  clearConfiguredEngine();
+  return configuredEngineConfig;
+}
+async function abdp(tickers, fields, options = {}) {
+  const engine = await getConfiguredEngine();
+  return await engine.bdp(toStringArray(tickers), toStringArray(fields), options);
+}
+async function bdp(tickers, fields, options = {}) {
+  return await abdp(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
+    );
+  }
+  return await engine.bdh(toStringArray(tickers), toStringArray(fields), {
+    ...options,
+    start,
+    end
+  });
+}
+async function bdh(tickers, fields, options = {}) {
+  return await abdh(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
+  );
+}
+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) {
+    return await engine.bdib(toRequestString(ticker), dt);
+  }
+  const normalizedOptions = isPlainObject(interval) ? { ...interval } : { ...options, interval: typeof interval === "number" ? interval : 1 };
+  if (normalizedOptions.start === void 0 && normalizedOptions.end === void 0) {
+    if (dt === void 0) {
+      throw new TypeError("abdib requires dt or explicit start/end options");
+    }
+    const range = fullDayRange(dt);
+    normalizedOptions.start = range.start;
+    normalizedOptions.end = range.end;
+  }
+  return await engine.bdib(toRequestString(ticker), normalizedOptions);
+}
+async function bdib(ticker, options = {}) {
+  return await abdib(ticker, options);
+}
+async function abdtick(ticker, start, end, options = {}) {
+  if (start === void 0 || start === null || end === void 0 || end === null) {
+    throw new TypeError("abdtick requires both start and end datetimes");
+  }
+  const engine = await getConfiguredEngine();
+  return await engine.bdtick(toRequestString(ticker), { ...options, start, end });
+}
+async function bdtick(ticker, options = {}) {
+  const engine = await getConfiguredEngine();
+  return await engine.bdtick(toRequestString(ticker), options);
+}
+async function asubscribe(tickers, fields, options = {}) {
+  const engine = await getConfiguredEngine();
+  return await engine.subscribe(toStringArray(tickers), toStringArray(fields), options);
+}
+async function subscribe(tickers, fields, options = {}) {
+  return await asubscribe(tickers, fields, options);
+}
+async function acdxInfo(ticker, options = {}) {
+  const engine = await getConfiguredEngine();
+  return await engine.bdp([toRequestString(ticker)], [...CDX_INFO_FIELDS], options);
+}
+async function acdxPricing(ticker, options = {}) {
+  const engine = await getConfiguredEngine();
+  return await engine.bdp(
+    [toRequestString(ticker)],
+    [...CDX_PRICING_FIELDS],
+    normalizeRecoveryOptions(options)
+  );
+}
+async function acdxRisk(ticker, options = {}) {
+  const engine = await getConfiguredEngine();
+  return await engine.bdp(
+    [toRequestString(ticker)],
+    [...CDX_RISK_FIELDS],
+    normalizeRecoveryOptions(options)
+  );
+}
+var blp = Object.freeze({
+  bdp,
+  bdh,
+  bds,
+  bdib,
+  bdtick,
+  subscribe,
+  abdp,
+  abdh,
+  abds,
+  abdib,
+  abdtick,
+  asubscribe
+});
+var ext = Object.freeze({
+  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,
+  contractIndex: native.extContractIndex,
+  filterCandidatesByCycle: native.extFilterCandidatesByCycle,
+  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,
+  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,
+  getMarketRule: native.extGetMarketRule,
+  inferTimezone: native.extInferTimezone,
+  setExchangeOverride: native.extSetExchangeOverride,
+  getExchangeOverride: native.extGetExchangeOverride,
+  clearExchangeOverride: native.extClearExchangeOverride,
+  listExchangeOverrides: native.extListExchangeOverrides,
+  sessionTimesToUtc: native.extSessionTimesToUtc
+});
+function version() {
+  return packageJson.version;
+}
+var setLogLevel = native.setLogLevel;
+var getLogLevel = native.getLogLevel;
+
+exports.ArrowSubscription = ArrowSubscription;
+exports.Backend = Backend;
+exports.BlpError = BlpError;
+exports.BlpInternalError = BlpInternalError;
+exports.BlpRequestError = BlpRequestError;
+exports.BlpSessionError = BlpSessionError;
+exports.BlpTimeoutError = BlpTimeoutError;
+exports.BlpValidationError = BlpValidationError;
+exports.Engine = Engine;
+exports.FieldHandle = FieldHandle;
+exports.Format = Format;
+exports.Subscription = Subscription;
+exports.Tick = Tick;
+exports.abdh = abdh;
+exports.abdib = abdib;
+exports.abdp = abdp;
+exports.abds = abds;
+exports.abdtick = abdtick;
+exports.asubscribe = asubscribe;
+exports.bdh = bdh;
+exports.bdib = bdib;
+exports.bdp = bdp;
+exports.bds = bds;
+exports.bdtick = bdtick;
+exports.blp = blp;
+exports.configure = configure;
+exports.connect = connect;
+exports.ext = ext;
+exports.formatDate = formatDate;
+exports.formatDateTime = formatDateTime;
+exports.getLogLevel = getLogLevel;
+exports.setLogLevel = setLogLevel;
+exports.subscribe = subscribe;
+exports.version = version;
+exports.wrapError = wrapError;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map