@compforge/harness-toolbox 0.1.0

package/dist/chunk-jr9y0ghr.js

@@ -0,0 +1,157 @@
+// src/redis/key-stats.ts
+var LENGTH_COMMANDS = {
+  string: "STRLEN",
+  list: "LLEN",
+  set: "SCARD",
+  hash: "HLEN",
+  zset: "ZCARD",
+  stream: "XLEN"
+};
+var RANDOM_SAMPLE_MAX_FRACTION = 0.1;
+var RANDOM_SAMPLE_DRAW_MULTIPLIER = 1.25;
+function text(value) {
+  return Buffer.isBuffer(value) ? value.toString("utf8") : String(value ?? "");
+}
+function integer(value, fallback) {
+  if (value instanceof Error || value === null || value === undefined)
+    return fallback;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function throttle(startedAt, processed, maxPerSecond) {
+  const delay = processed / maxPerSecond * 1000 - (performance.now() - startedAt);
+  if (delay > 0)
+    await sleep(delay);
+}
+function redisGroupedSampleSizes(totalKeys, targetSamples) {
+  const samples = Math.min(Math.max(0, totalKeys), Math.max(0, targetSamples));
+  if (samples === 0)
+    return [];
+  const baseSize = Math.floor(totalKeys / samples);
+  const largerGroups = totalKeys % samples;
+  return Array.from({ length: samples }, (_, index) => baseSize + (index < largerGroups ? 1 : 0));
+}
+async function selectKeysByScan(client, totalKeys, limit, scanCount, maxKeysPerSecond, onProgress) {
+  const startedAt = performance.now();
+  if (limit >= totalKeys) {
+    const uniqueKeys = new Set;
+    let cursor2 = "0";
+    let visited2 = 0;
+    do {
+      const page = await client.scan(cursor2, scanCount);
+      cursor2 = page.cursor;
+      visited2 += page.keys.length;
+      for (const key of page.keys)
+        uniqueKeys.add(key);
+      onProgress?.(uniqueKeys.size, limit);
+      await throttle(startedAt, visited2, maxKeysPerSecond);
+    } while (cursor2 !== "0");
+    return { keys: [...uniqueKeys], visited: visited2 };
+  }
+  const groupSizes = redisGroupedSampleSizes(totalKeys, limit);
+  const keys = [];
+  let groupIndex = 0;
+  let groupPosition = 0;
+  let selectedPosition = groupSizes.length ? Math.floor(Math.random() * groupSizes[0]) : -1;
+  let cursor = "0";
+  let visited = 0;
+  do {
+    const page = await client.scan(cursor, scanCount);
+    cursor = page.cursor;
+    for (const key of page.keys) {
+      visited += 1;
+      if (groupIndex >= groupSizes.length)
+        continue;
+      if (groupPosition === selectedPosition)
+        keys.push(key);
+      groupPosition += 1;
+      if (groupPosition >= groupSizes[groupIndex]) {
+        groupIndex += 1;
+        groupPosition = 0;
+        selectedPosition = groupIndex < groupSizes.length ? Math.floor(Math.random() * groupSizes[groupIndex]) : -1;
+      }
+    }
+    onProgress?.(keys.length, limit);
+    await throttle(startedAt, visited, maxKeysPerSecond);
+  } while (cursor !== "0");
+  return { keys, visited };
+}
+async function selectKeysByRandomDraw(client, limit, pipelineKeys, maxKeysPerSecond, onProgress) {
+  const keys = new Set;
+  const maxDraws = Math.ceil(limit * RANDOM_SAMPLE_DRAW_MULTIPLIER);
+  const startedAt = performance.now();
+  let visited = 0;
+  while (keys.size < limit && visited < maxDraws) {
+    const batchSize = Math.min(pipelineKeys, maxDraws - visited);
+    const replies = await client.pipeline(Array.from({ length: batchSize }, () => ["RANDOMKEY"]));
+    visited += batchSize;
+    for (const reply of replies) {
+      if (!(reply instanceof Error) && reply !== null && reply !== undefined)
+        keys.add(text(reply));
+      if (keys.size >= limit)
+        break;
+    }
+    onProgress?.(keys.size, limit);
+    await throttle(startedAt, visited, maxKeysPerSecond);
+  }
+  return { keys: [...keys].slice(0, limit), visited };
+}
+async function selectKeys(client, totalKeys, limit, options) {
+  if (limit === 0)
+    return { keys: [], visited: 0 };
+  if (limit / totalKeys < RANDOM_SAMPLE_MAX_FRACTION) {
+    return selectKeysByRandomDraw(client, limit, options.pipelineKeys, options.maxKeysPerSecond, options.onSelectionProgress);
+  }
+  return selectKeysByScan(client, totalKeys, limit, options.scanCount, options.maxKeysPerSecond, options.onSelectionProgress);
+}
+async function inspectKeys(client, keys, memorySamples) {
+  const typeReplies = await client.pipeline(keys.map((key) => ["TYPE", key]));
+  const types = typeReplies.map((value) => value instanceof Error ? "unknown" : text(value));
+  const commands = [];
+  const replyOffsets = [];
+  for (let index = 0;index < keys.length; index += 1) {
+    const key = keys[index];
+    const type = types[index];
+    const ttl = commands.push(["PTTL", key]) - 1;
+    const memory = commands.push(["MEMORY", "USAGE", key, "SAMPLES", String(memorySamples)]) - 1;
+    const lengthCommand = LENGTH_COMMANDS[type];
+    const length = lengthCommand ? commands.push([lengthCommand, key]) - 1 : undefined;
+    replyOffsets.push({ ttl, memory, length });
+  }
+  const replies = commands.length ? await client.pipeline(commands) : [];
+  return keys.map((key, index) => {
+    const offsets = replyOffsets[index];
+    return {
+      key,
+      type: types[index],
+      ttlMs: integer(replies[offsets.ttl], -3),
+      memoryBytes: integer(replies[offsets.memory], 0),
+      length: offsets.length === undefined ? null : integer(replies[offsets.length], 0)
+    };
+  });
+}
+async function collectRedisKeyStats(client, options) {
+  const totalKeys = Math.max(0, Number(await client.dbSize()));
+  const limit = Math.min(totalKeys, Math.max(0, options.maxKeys));
+  const selected = await selectKeys(client, totalKeys, limit, options);
+  const result = [];
+  const startedAt = performance.now();
+  for (let offset = 0;offset < selected.keys.length; offset += options.pipelineKeys) {
+    const rows = await inspectKeys(client, selected.keys.slice(offset, offset + options.pipelineKeys), options.memorySamples);
+    result.push(...rows);
+    await throttle(startedAt, result.length, options.maxKeysPerSecond);
+    options.onProgress?.(result.length, limit);
+  }
+  return {
+    totalKeys,
+    visitedKeys: selected.visited,
+    inspectedKeys: result.length,
+    scanComplete: limit >= totalKeys,
+    keys: result
+  };
+}
+
+export { redisGroupedSampleSizes, collectRedisKeyStats };

package/dist/chunk-mkhyty75.js

@@ -0,0 +1,166 @@
+import {
+  ConcurrencyPool
+} from "./chunk-v3hxvnrc.js";
+import {
+  queryMysqlViaPod
+} from "./chunk-s06hs7a8.js";
+import {
+  isConnectionNetworkError
+} from "./chunk-xy4g56g4.js";
+
+// src/mysql/client.ts
+import { createConnection } from "mysql2/promise";
+class MysqlDatabase {
+  transports;
+  options;
+  connect;
+  #queries = new ConcurrencyPool(1);
+  #connections = new Map;
+  constructor(transports, options, connect = createConnection) {
+    this.transports = transports;
+    this.options = options;
+    this.connect = connect;
+  }
+  query(target, sql, values) {
+    return this.#queries.run(() => this.#query(target, sql, values), this.options.signal);
+  }
+  initialize(target) {
+    return this.#queries.run(async () => {
+      await this.#session(target);
+    }, this.options.signal);
+  }
+  #session(target) {
+    this.options.signal?.throwIfAborted();
+    const key = [target.host, target.port, target.database, target.user, target.password].join("\x00");
+    let pending = this.#connections.get(key);
+    if (!pending) {
+      pending = this.#open(target);
+      this.#connections.set(key, pending);
+      pending.catch(() => {
+        if (this.#connections.get(key) === pending)
+          this.#connections.delete(key);
+      });
+    }
+    return pending;
+  }
+  async#query(target, sql, values) {
+    this.options.signal?.throwIfAborted();
+    const key = [target.host, target.port, target.database, target.user, target.password].join("\x00");
+    const pending = this.#session(target);
+    let session;
+    try {
+      session = await pending;
+      this.options.signal?.throwIfAborted();
+      if (session.kind === "python")
+        return await queryMysqlViaPod(session.transport, target, sql, values, this.options);
+      const [rows] = await session.connection.execute({ sql, values: [...values], timeout: this.options.queryTimeoutMs });
+      return rows;
+    } catch (error) {
+      if (this.#connections.get(key) === pending)
+        this.#connections.delete(key);
+      if (session?.kind === "tcp")
+        session.connection.destroy();
+      throw error;
+    }
+  }
+  async#open(target) {
+    let reason;
+    for (let i = 0;i < this.transports.length; i++) {
+      const transport = this.transports[i];
+      this.options.signal?.throwIfAborted();
+      if (transport.kind === "python") {
+        this.options.onRoute?.({ transport: transport.name, reason });
+        return { kind: "python", transport };
+      }
+      try {
+        const endpoint = await transport.connect(target);
+        const connection = await this.connect({
+          host: endpoint.host,
+          port: endpoint.port,
+          user: target.user,
+          password: target.password,
+          database: target.database,
+          connectTimeout: this.options.connectTimeoutMs,
+          dateStrings: true,
+          supportBigNumbers: true,
+          bigNumberStrings: true
+        });
+        this.options.onRoute?.({ transport: endpoint.host === target.host && endpoint.port === target.port ? "direct" : transport.name, reason });
+        return { kind: "tcp", connection };
+      } catch (error) {
+        if (!isConnectionNetworkError(error) || i === this.transports.length - 1)
+          throw error;
+        reason = String(error.code);
+      }
+    }
+    throw new Error("MySQL DataSource has no transport");
+  }
+  async queryOne(target, sql, values) {
+    return (await this.query(target, sql, values))[0];
+  }
+  close() {
+    return this.#queries.run(async () => {
+      const pending = [...this.#connections.values()];
+      this.#connections.clear();
+      for (const result of await Promise.allSettled(pending)) {
+        if (result.status === "fulfilled" && result.value.kind === "tcp")
+          result.value.connection.destroy();
+      }
+    });
+  }
+}
+
+class MysqlClient {
+  source;
+  options;
+  #controller = new AbortController;
+  signal;
+  #initialization;
+  #disposal;
+  #database;
+  #target;
+  constructor(source, options) {
+    this.source = source;
+    this.options = options;
+    this.signal = options.signal ? AbortSignal.any([options.signal, this.#controller.signal]) : this.#controller.signal;
+  }
+  initialize() {
+    this.signal.throwIfAborted();
+    return this.#initialization ??= (async () => {
+      this.#target = await this.source.resolve();
+      this.signal.throwIfAborted();
+      this.#database = new MysqlDatabase(this.source.transports, { ...this.options, signal: this.signal });
+      await this.#database.initialize(this.#target);
+    })();
+  }
+  get database() {
+    if (!this.#database)
+      throw new Error("MySQL client is not initialized");
+    return this.#database;
+  }
+  get target() {
+    if (!this.#target)
+      throw new Error("MySQL client is not initialized");
+    return this.#target;
+  }
+  dispose() {
+    return this.#disposal ??= (async () => {
+      this.#controller.abort(new Error("MySQL client disposed"));
+      await this.#initialization?.catch(() => {});
+      await this.#database?.close();
+    })();
+  }
+}
+async function openMysql(source, options) {
+  const client = new MysqlClient(source, options);
+  try {
+    await client.initialize();
+  } catch (error) {
+    await client.dispose();
+    throw error;
+  }
+  options.onDispose?.(() => client.dispose());
+  return client;
+}
+
+export { MysqlDatabase, MysqlClient, openMysql };

package/dist/chunk-mp88s7r7.js

@@ -0,0 +1,12 @@
+// src/kubernetes/log-timestamp.ts
+function logTimestampNanos(value) {
+  const parts = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?(Z|[+-]\d{2}:\d{2})$/.exec(value);
+  if (!parts)
+    return;
+  const seconds = Date.parse(`${parts[1]}${parts[3]}`);
+  if (!Number.isFinite(seconds))
+    return;
+  return BigInt(seconds) * 1000000n + BigInt((parts[2] ?? "").padEnd(9, "0"));
+}
+
+export { logTimestampNanos };

package/dist/chunk-qq77x9ek.js

@@ -0,0 +1,34 @@
+// src/mysql/target.ts
+function parseMysqlEnvTarget(raw, options) {
+  const env = new Map;
+  for (const line of raw.split(/\r?\n/)) {
+    const index = line.indexOf("=");
+    if (index > 0)
+      env.set(line.slice(0, index), line.slice(index + 1));
+  }
+  const { label, prefix, fallback, defaultPort = 3306 } = options;
+  const host = env.get(`${prefix}_HOST`);
+  const database = env.get(`${prefix}_DATABASE`) || env.get(`${prefix}_NAME`);
+  const port = Number(env.get(`${prefix}_PORT`) || String(defaultPort));
+  if (!host || !database || !Number.isInteger(port) || port <= 0) {
+    throw new Error(`${label} 未暴露有效的 ${prefix}_HOST/PORT/DATABASE`);
+  }
+  const envUser = env.get(`${prefix}_USERNAME`) || env.get(`${prefix}_USER`);
+  const envPassword = env.get(`${prefix}_PASSWORD`);
+  if (envUser && envPassword) {
+    return {
+      host,
+      port,
+      database,
+      user: envUser,
+      password: envPassword,
+      credentialSource: "service-env"
+    };
+  }
+  if (!fallback?.user || !fallback.password) {
+    throw new Error(`${label} 未暴露完整的 ${prefix}_USERNAME/PASSWORD，且未配置 profile 数据库身份兜底`);
+  }
+  return { host, port, database, ...fallback, credentialSource: "profile" };
+}
+
+export { parseMysqlEnvTarget };

package/dist/chunk-s06hs7a8.js

@@ -0,0 +1,79 @@
+// src/mysql/pod.ts
+function preparePodSql(sql, values) {
+  let index = 0;
+  const rendered = sql.replace(/%/g, "%%").replace(/'(?:\\.|''|[^'\\])*'|"(?:\\.|""|[^"\\])*"|`(?:``|[^`])*`|--\s[^\n]*|#[^\n]*|\/\*[\s\S]*?\*\/|\?/g, (token) => {
+    if (token !== "?")
+      return token;
+    if (index >= values.length)
+      throw new Error("SQL placeholder count exceeds bound values");
+    index++;
+    return "%s";
+  });
+  if (index !== values.length)
+    throw new Error("SQL bound values exceed placeholder count");
+  return rendered;
+}
+var POD_QUERY = String.raw`
+import json, math, signal, sys
+
+
+def timeout(signum, frame):
+    raise TimeoutError()
+
+
+def encode(value):
+    if isinstance(value, bytes):
+        return {"type": "Buffer", "data": list(value)}
+    raise TypeError(type(value).__name__)
+
+
+try:
+    request = json.load(sys.stdin)
+    signal.signal(signal.SIGALRM, timeout)
+    signal.alarm(math.ceil(request["queryTimeoutMs"] / 1000))
+    import pymysql
+    from pymysql.constants import FIELD_TYPE
+    target = request["target"]
+    converters = pymysql.converters.conversions.copy()
+    # Match mysql2 dateStrings/supportBigNumbers/bigNumberStrings and native JSON decoding.
+    for field in (FIELD_TYPE.DATE, FIELD_TYPE.DATETIME, FIELD_TYPE.TIMESTAMP, FIELD_TYPE.TIME,
+                  FIELD_TYPE.LONGLONG, FIELD_TYPE.DECIMAL, FIELD_TYPE.NEWDECIMAL):
+        converters[field] = str
+    converters[FIELD_TYPE.JSON] = json.loads
+    connection = pymysql.connect(
+        host=target["host"], port=target["port"], database=target["database"], user=target["user"],
+        password=target["password"], charset="utf8mb4",
+        connect_timeout=math.ceil(request["connectTimeoutMs"] / 1000),
+        read_timeout=math.ceil(request["queryTimeoutMs"] / 1000),
+        write_timeout=math.ceil(request["queryTimeoutMs"] / 1000),
+        conv=converters,
+    )
+    try:
+        with connection.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute(request["sql"], request["values"])
+            rows = cursor.fetchall()
+        print(json.dumps({"rows": rows}, default=encode, ensure_ascii=False))
+    finally:
+        connection.close()
+except Exception as error:
+    # DB errors may include SQL values; expose only the exception class and numeric server code.
+    code = error.args[0] if error.args and isinstance(error.args[0], int) else None
+    print(json.dumps({"error": type(error).__name__, "code": code}))
+finally:
+    signal.alarm(0)
+`;
+async function queryMysqlViaPod(transport, target, sql, values, options) {
+  const raw = await transport.run(POD_QUERY, {
+    target,
+    sql: preparePodSql(sql, values),
+    values,
+    ...options
+  }, options.queryTimeoutMs + 3000);
+  const response = JSON.parse(raw, (_key, value) => value?.type === "Buffer" && Array.isArray(value.data) ? Buffer.from(value.data) : value);
+  if (response.error || !Array.isArray(response.rows)) {
+    throw new Error(`MySQL via Pod failed: ${response.error ?? "invalid response"}${response.code ? ` (${response.code})` : ""}`);
+  }
+  return response.rows;
+}
+
+export { preparePodSql, queryMysqlViaPod };

package/dist/chunk-s1sjyem7.js

@@ -0,0 +1,41 @@
+// src/opensearch/endpoint.ts
+function parseOpenSearchEndpoint(value) {
+  const first = value.split(",").map((item) => item.trim()).find(Boolean);
+  if (!first)
+    throw new Error("OpenSearch endpoint 为空");
+  const schemeExplicit = first.includes("://");
+  let parsed;
+  try {
+    parsed = new URL(schemeExplicit ? first : `http://${first}`);
+  } catch {
+    throw new Error(`OpenSearch endpoint 格式无效：${first}`);
+  }
+  if (!parsed.hostname)
+    throw new Error(`OpenSearch endpoint 缺少 host：${first}`);
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new Error(`OpenSearch endpoint scheme 仅支持 http/https：${parsed.protocol}`);
+  }
+  const scheme = parsed.protocol.slice(0, -1);
+  const username = parsed.username ? decodeURIComponent(parsed.username) : undefined;
+  const password = parsed.password ? decodeURIComponent(parsed.password) : undefined;
+  const port = parsed.port ? Number(parsed.port) : schemeExplicit ? scheme === "https" ? 443 : 80 : 9200;
+  parsed.username = "";
+  parsed.password = "";
+  parsed.port = String(port);
+  parsed.pathname = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
+  const safeUrl = parsed.toString().replace(/\/$/, "");
+  const safeEndpoint = schemeExplicit ? safeUrl : `${parsed.hostname}:${port}`;
+  return {
+    url: safeUrl,
+    safeUrl,
+    safeEndpoint,
+    host: parsed.hostname,
+    port,
+    scheme,
+    schemeExplicit,
+    username,
+    password
+  };
+}
+
+export { parseOpenSearchEndpoint };

package/dist/chunk-v3hxvnrc.js

@@ -0,0 +1,47 @@
+// src/concurrency.ts
+class ConcurrencyPool {
+  concurrency;
+  #active = 0;
+  #waiting = [];
+  constructor(concurrency) {
+    this.concurrency = concurrency;
+    if (!Number.isSafeInteger(concurrency) || concurrency < 1)
+      throw new Error("concurrency must be a positive integer");
+  }
+  async run(work, signal) {
+    await this.#acquire(signal);
+    try {
+      signal?.throwIfAborted();
+      return await work();
+    } finally {
+      const next = this.#waiting.shift();
+      if (next)
+        next();
+      else
+        this.#active--;
+    }
+  }
+  #acquire(signal) {
+    signal?.throwIfAborted();
+    if (this.#active < this.concurrency) {
+      this.#active++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const start = () => {
+        signal?.removeEventListener("abort", abort);
+        resolve();
+      };
+      const abort = () => {
+        const index = this.#waiting.indexOf(start);
+        if (index >= 0)
+          this.#waiting.splice(index, 1);
+        reject(signal.reason);
+      };
+      this.#waiting.push(start);
+      signal?.addEventListener("abort", abort, { once: true });
+    });
+  }
+}
+
+export { ConcurrencyPool };

package/dist/chunk-w3a4p6jm.js

@@ -0,0 +1,124 @@
+// src/opensearch/client.ts
+import { Client } from "@opensearch-project/opensearch";
+function isOpenSearchReadApi(search) {
+  return typeof search.request === "function";
+}
+function createClient(options) {
+  return new Client({
+    node: options.node,
+    auth: options.auth.username && options.auth.password ? { username: options.auth.username, password: options.auth.password } : undefined,
+    ssl: { rejectUnauthorized: false },
+    requestTimeout: options.requestTimeoutMs ?? 60000,
+    maxRetries: 0
+  });
+}
+
+class OpenSearchEngine {
+  client;
+  constructor(options, client) {
+    this.client = client ?? createClient(options);
+  }
+  async count(index, query) {
+    const response = await this.client.count({ index, body: { query } });
+    return Number(response.body.count ?? 0);
+  }
+  async search(index, body) {
+    const response = await this.client.search({ index, body });
+    return response.body;
+  }
+  async request(path, query) {
+    if (!this.client.transport)
+      throw new Error("OpenSearch client 不支持通用只读请求");
+    const response = await this.client.transport.request({
+      method: "GET",
+      path,
+      querystring: query
+    });
+    return response.body;
+  }
+  ping() {
+    return this.client.ping();
+  }
+  close() {
+    return this.client.close();
+  }
+}
+
+class OpenSearchClient {
+  source;
+  #controller = new AbortController;
+  signal;
+  #initialization;
+  #disposal;
+  #engine;
+  #operations = new Set;
+  constructor(source, lifecycle = {}) {
+    this.source = source;
+    this.signal = lifecycle.signal ? AbortSignal.any([lifecycle.signal, this.#controller.signal]) : this.#controller.signal;
+  }
+  initialize() {
+    this.signal.throwIfAborted();
+    return this.#initialization ??= (async () => {
+      const target = await this.source.resolve();
+      this.signal.throwIfAborted();
+      const transport = this.source.transports[0];
+      if (!transport || transport.kind !== "tcp")
+        throw new Error("OpenSearch requires a TCP transport");
+      const url = new URL(target.node);
+      const endpoint = await transport.connect({ host: url.hostname, port: Number(url.port || (url.protocol === "https:" ? 443 : 80)) });
+      this.signal.throwIfAborted();
+      url.hostname = endpoint.host;
+      url.port = String(endpoint.port);
+      this.#engine = new OpenSearchEngine({ ...target, node: url.toString() });
+    })();
+  }
+  #ready() {
+    this.signal.throwIfAborted();
+    if (!this.#engine)
+      throw new Error("OpenSearch client is not initialized");
+    return this.#engine;
+  }
+  #run(operation) {
+    const engine = this.#ready();
+    const pending = operation(engine);
+    this.#operations.add(pending);
+    pending.then(() => this.#operations.delete(pending), () => this.#operations.delete(pending));
+    return pending;
+  }
+  count(index, query) {
+    return this.#run((engine) => engine.count(index, query));
+  }
+  search(index, body) {
+    return this.#run((engine) => engine.search(index, body));
+  }
+  request(path, query) {
+    return this.#run((engine) => engine.request(path, query));
+  }
+  ping() {
+    return this.#run((engine) => engine.ping());
+  }
+  close() {
+    return this.dispose();
+  }
+  dispose() {
+    return this.#disposal ??= (async () => {
+      this.#controller.abort(new Error("OpenSearch client disposed"));
+      await this.#initialization?.catch(() => {});
+      await Promise.allSettled(this.#operations);
+      await this.#engine?.close();
+    })();
+  }
+}
+async function openOpenSearch(source, lifecycle = {}) {
+  const client = new OpenSearchClient(source, lifecycle);
+  try {
+    await client.initialize();
+  } catch (error) {
+    await client.dispose();
+    throw error;
+  }
+  lifecycle.onDispose?.(() => client.dispose());
+  return client;
+}
+
+export { isOpenSearchReadApi, OpenSearchEngine, OpenSearchClient, openOpenSearch };