@compforge/harness-toolbox 0.1.0 → 0.1.1

package/README.md

@@ -1,7 +1,7 @@
 # Harness Toolbox
 
 Shared infrastructure for diagnostic tools, test runners and business adapters. Use the same
-clients to access Kubernetes, MySQL, Redis and OpenSearch without depending on a particular
+clients to access Kubernetes, MySQL, Redis, OpenSearch and S3-compatible object storage without depending on a particular
 command, plugin protocol, test model or verdict.
 
 The package supports Node.js 22+ and Bun. Install with `npm install @compforge/harness-toolbox`.
@@ -45,3 +45,39 @@ capture policy, shared concurrency pool and byte budget; the package does not ch
 limits. Temporary capture files live until client disposal.
 
 See [toolbox contracts](../../../docs/toolbox.md) for ownership and cross-language semantics.
+
+## Read S3 objects
+
+S3 uses the official AWS SDK behind the same managed lifecycle. Supply resolved connection
+settings and explicit limits; the package does not discover business configuration or credentials.
+
+```ts
+import { ClientManager } from "@compforge/harness-toolbox";
+import { S3DataSource } from "@compforge/harness-toolbox/s3";
+
+const clients = new ClientManager();
+try {
+  const s3 = await clients.get(new S3DataSource({
+    endpoint: "https://s3.example.com", region: "us-east-1",
+    credentials: { accessKeyId: "...", secretAccessKey: "..." },
+  }, { concurrency: 4, connectTimeoutMs: 5_000, requestTimeoutMs: 15_000 }));
+  const object = await s3.headObject("artifacts", "runs/example.json");
+  const prefix = await s3.readObject("artifacts", "runs/example.json", { maxBytes: 65_536 });
+  // prefix.truncated distinguishes a bounded prefix from the complete object.
+} finally {
+  await clients.dispose();
+}
+```
+
+`listObjects` and `listBuckets` return one explicitly bounded page with continuation tokens;
+callers own traversal and total scan budgets. Bucket HEAD and versioning are also available.
+Errors preserve SDK status/code: a failed HEAD is not converted to `exists=false`. Reads stop at
+the byte cap and close the body; request deadlines include queueing and body consumption.
+No write operations, automatic retries or implicit region redirects are exposed.
+
+For a mapped TCP transport, pass `{ key: "cluster/context identity", transport }` as the third
+DataSource argument. The caller owns that transport's lifetime. Path-style addressing is required
+for mapped routes; direct endpoints also support virtual-hosted buckets. Signed Host and TLS
+identity remain the logical endpoint, not the forwarded address. Private CAs may be supplied
+explicitly with `ca`; certificate verification stays enabled. Initialization prepares the client
+and route without listing buckets or claiming that credentials have been validated.

package/dist/chunk-9j36zvn4.js

@@ -0,0 +1,35 @@
+import {
+  dataSourceKey
+} from "./chunk-hqx7j9xe.js";
+import {
+  S3Client
+} from "./chunk-zp1s833x.js";
+import {
+  DirectTransport
+} from "./chunk-xy4g56g4.js";
+
+// src/s3/datasource.ts
+class S3DataSource {
+  key;
+  #target;
+  #limits;
+  #transport;
+  constructor(target, limits, route) {
+    this.#target = structuredClone(target);
+    this.#limits = { ...limits };
+    this.#transport = route?.transport ?? new DirectTransport;
+    this.key = dataSourceKey("s3", {
+      target: this.#target,
+      limits: this.#limits,
+      route: route ? { key: route.key, transport: route.transport.name } : "direct"
+    });
+  }
+  createClient(signal) {
+    return new S3Client({
+      resolve: async () => this.#target,
+      transports: [this.#transport]
+    }, this.#limits, { signal });
+  }
+}
+
+export { S3DataSource };

package/dist/chunk-x4ntb898.js

@@ -0,0 +1,46 @@
+// src/s3/handler.ts
+import { Agent as HttpAgent } from "node:http";
+import { Agent as HttpsAgent } from "node:https";
+import { NodeHttpHandler } from "@smithy/node-http-handler";
+function s3Handler(target, route, limits) {
+  const endpoint = new URL(target.endpoint);
+  const mapped = route.host !== endpoint.hostname || route.port !== Number(endpoint.port || (endpoint.protocol === "https:" ? 443 : 80));
+  if (mapped && target.forcePathStyle === false) {
+    throw new Error("S3 mapped transports require path-style addressing to preserve bucket and TLS identity");
+  }
+  const pool = { keepAlive: true, maxSockets: limits.concurrency, maxTotalSockets: limits.concurrency };
+  const httpAgent = new HttpAgent(pool);
+  const httpsAgent = new HttpsAgent({
+    ...pool,
+    ca: target.ca,
+    rejectUnauthorized: true,
+    ...mapped ? { servername: endpoint.hostname } : {}
+  });
+  const transport = new NodeHttpHandler({
+    httpAgent,
+    httpsAgent,
+    connectionTimeout: limits.connectTimeoutMs,
+    requestTimeout: limits.requestTimeoutMs,
+    throwOnRequestTimeout: true
+  });
+  const handler = {
+    handle(request, options) {
+      if (!mapped)
+        return transport.handle(request, options);
+      const routed = request.clone();
+      routed.hostname = route.host;
+      routed.port = route.port;
+      return transport.handle(routed, options);
+    },
+    destroy() {
+      transport.destroy();
+    }
+  };
+  return { handler, destroy: () => {
+    handler.destroy();
+    httpAgent.destroy();
+    httpsAgent.destroy();
+  } };
+}
+
+export { s3Handler };

package/dist/chunk-zp1s833x.js

@@ -0,0 +1,200 @@
+import {
+  ConcurrencyPool
+} from "./chunk-v3hxvnrc.js";
+import {
+  s3Handler
+} from "./chunk-x4ntb898.js";
+
+// src/s3/client.ts
+import {
+  S3Client as AwsS3Client,
+  HeadBucketCommand,
+  HeadObjectCommand,
+  ListBucketsCommand,
+  ListObjectsV2Command,
+  GetBucketVersioningCommand,
+  GetObjectCommand
+} from "@aws-sdk/client-s3";
+import { Readable } from "node:stream";
+function positive(value, name, maximum = Number.MAX_SAFE_INTEGER) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
+    throw new Error(`${name} must be an integer between 1 and ${maximum}`);
+  }
+}
+function metadata(value) {
+  return {
+    size: value.ContentLength,
+    etag: value.ETag,
+    lastModified: value.LastModified,
+    contentType: value.ContentType,
+    versionId: value.VersionId,
+    metadata: value.Metadata ?? {}
+  };
+}
+
+class S3Client {
+  source;
+  limits;
+  lifecycle;
+  #controller = new AbortController;
+  signal;
+  #pool;
+  #operations = new Set;
+  #initialization;
+  #disposal;
+  #sdk;
+  #http;
+  constructor(source, limits, lifecycle = {}) {
+    this.source = source;
+    this.limits = limits;
+    this.lifecycle = lifecycle;
+    positive(limits.concurrency, "concurrency");
+    positive(limits.connectTimeoutMs, "connectTimeoutMs", 2147483647);
+    positive(limits.requestTimeoutMs, "requestTimeoutMs", 2147483647);
+    this.#pool = new ConcurrencyPool(limits.concurrency);
+    this.signal = lifecycle.signal ? AbortSignal.any([lifecycle.signal, this.#controller.signal]) : this.#controller.signal;
+  }
+  initialize() {
+    this.signal.throwIfAborted();
+    return this.#initialization ??= this.#initialize();
+  }
+  async#initialize() {
+    const target = await this.source.resolve();
+    this.signal.throwIfAborted();
+    const url = new URL(target.endpoint);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+      throw new Error("S3 endpoint must be an HTTP(S) URL without embedded credentials, query or fragment");
+    }
+    const transport = this.source.transports[0];
+    if (!transport || transport.kind !== "tcp")
+      throw new Error("S3 requires a TCP transport");
+    const route = await transport.connect({
+      host: url.hostname,
+      port: Number(url.port || (url.protocol === "https:" ? 443 : 80)),
+      servername: url.hostname
+    });
+    this.signal.throwIfAborted();
+    this.#http = s3Handler(target, route, this.limits);
+    this.#sdk = new AwsS3Client({
+      endpoint: target.endpoint,
+      region: target.region,
+      credentials: target.credentials,
+      forcePathStyle: target.forcePathStyle ?? true,
+      requestHandler: this.#http.handler,
+      maxAttempts: 1,
+      followRegionRedirects: false,
+      responseChecksumValidation: "WHEN_REQUIRED"
+    });
+    this.lifecycle.onRoute?.({ transport: transport.name });
+  }
+  #run(options, operation) {
+    this.signal.throwIfAborted();
+    const sdk = this.#sdk;
+    if (!sdk)
+      throw new Error("S3 client is not initialized");
+    const timeout = new AbortController;
+    const timer = setTimeout(() => timeout.abort(new Error("S3 request deadline exceeded")), this.limits.requestTimeoutMs);
+    timer.unref();
+    const signal = AbortSignal.any([this.signal, timeout.signal, ...options.signal ? [options.signal] : []]);
+    const pending = this.#pool.run(() => operation(sdk, signal), signal).finally(() => clearTimeout(timer));
+    this.#operations.add(pending);
+    pending.then(() => this.#operations.delete(pending), () => this.#operations.delete(pending));
+    return pending;
+  }
+  headBucket(bucket, options = {}) {
+    return this.#run(options, async (sdk, signal) => {
+      await sdk.send(new HeadBucketCommand({ Bucket: bucket }), { abortSignal: signal });
+    });
+  }
+  headObject(bucket, key, options = {}) {
+    return this.#run(options, async (sdk, signal) => metadata(await sdk.send(new HeadObjectCommand({ Bucket: bucket, Key: key, VersionId: options.versionId }), { abortSignal: signal })));
+  }
+  listObjects(bucket, options) {
+    positive(options.maxKeys, "maxKeys", 1000);
+    return this.#run(options, async (sdk, signal) => {
+      const page = await sdk.send(new ListObjectsV2Command({
+        Bucket: bucket,
+        MaxKeys: options.maxKeys,
+        Prefix: options.prefix,
+        Delimiter: options.delimiter,
+        ContinuationToken: options.continuationToken
+      }), { abortSignal: signal });
+      return {
+        objects: (page.Contents ?? []).filter((item) => item.Key !== undefined).map((item) => ({
+          key: item.Key,
+          size: item.Size,
+          etag: item.ETag,
+          lastModified: item.LastModified
+        })),
+        prefixes: (page.CommonPrefixes ?? []).flatMap((item) => item.Prefix === undefined ? [] : [item.Prefix]),
+        truncated: page.IsTruncated ?? false,
+        continuationToken: page.NextContinuationToken
+      };
+    });
+  }
+  listBuckets(options) {
+    positive(options.maxBuckets, "maxBuckets", 1e4);
+    return this.#run(options, async (sdk, signal) => {
+      const page = await sdk.send(new ListBucketsCommand({
+        MaxBuckets: options.maxBuckets,
+        ContinuationToken: options.continuationToken
+      }), { abortSignal: signal });
+      return { buckets: (page.Buckets ?? []).filter((item) => item.Name !== undefined).map((item) => ({ name: item.Name, creationDate: item.CreationDate })), continuationToken: page.ContinuationToken };
+    });
+  }
+  getBucketVersioning(bucket, options = {}) {
+    return this.#run(options, async (sdk, signal) => {
+      const result = await sdk.send(new GetBucketVersioningCommand({ Bucket: bucket }), { abortSignal: signal });
+      if (result.Status === "Enabled")
+        return "enabled";
+      return result.Status === "Suspended" ? "suspended" : "disabled";
+    });
+  }
+  readObject(bucket, key, options) {
+    positive(options.maxBytes, "maxBytes");
+    return this.#run(options, async (sdk, signal) => {
+      const result = await sdk.send(new GetObjectCommand({
+        Bucket: bucket,
+        Key: key,
+        VersionId: options.versionId
+      }), { abortSignal: signal });
+      const body = result.Body;
+      if (!(body instanceof Readable))
+        throw new Error("S3 response is missing a Node readable body");
+      const abort = () => body.destroy(new Error("S3 object read aborted", { cause: signal.reason }));
+      signal.addEventListener("abort", abort, { once: true });
+      const chunks = [];
+      let size = 0;
+      let truncated = false;
+      try {
+        signal.throwIfAborted();
+        for await (const chunk of body) {
+          signal.throwIfAborted();
+          const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          const remaining = options.maxBytes - size;
+          chunks.push(Buffer.from(bytes.subarray(0, remaining)));
+          size += Math.min(remaining, bytes.length);
+          if (bytes.length > remaining || size === options.maxBytes && result.ContentLength !== undefined && result.ContentLength > size) {
+            truncated = true;
+            break;
+          }
+        }
+        return { ...metadata(result), bytes: Buffer.concat(chunks, size), truncated };
+      } finally {
+        signal.removeEventListener("abort", abort);
+        body.destroy();
+      }
+    });
+  }
+  dispose() {
+    return this.#disposal ??= (async () => {
+      this.#controller.abort(new Error("S3 client disposed"));
+      await this.#initialization?.catch(() => {});
+      await Promise.allSettled(this.#operations);
+      this.#sdk?.destroy();
+      this.#http?.destroy();
+    })();
+  }
+}
+
+export { S3Client };

package/dist/kubernetes/client.js

@@ -1,9 +1,9 @@
 import {
   ServicePortForwarder
-} from "../chunk-205a4vma.js";
-import"../chunk-hv2kx47y.js";
+} from "../chunk-p097seg7.js";
 import"../chunk-j46x7j7c.js";
 import"../chunk-6fnhzhdb.js";
+import"../chunk-hv2kx47y.js";
 import {
   KubectlExecutor
 } from "../chunk-0rs1aacd.js";

package/dist/kubernetes/service-port-forward.js

@@ -1,9 +1,9 @@
 import {
   ServicePortForwarder
-} from "../chunk-205a4vma.js";
-import"../chunk-hv2kx47y.js";
+} from "../chunk-p097seg7.js";
 import"../chunk-j46x7j7c.js";
 import"../chunk-6fnhzhdb.js";
+import"../chunk-hv2kx47y.js";
 import"../chunk-0rs1aacd.js";
 import"../chunk-ztenxgjv.js";
 export {

package/dist/mysql/client.js

@@ -2,9 +2,9 @@ import {
   MysqlClient,
   MysqlDatabase,
   openMysql
-} from "../chunk-mkhyty75.js";
-import"../chunk-v3hxvnrc.js";
+} from "../chunk-sry9e02n.js";
 import"../chunk-s06hs7a8.js";
+import"../chunk-v3hxvnrc.js";
 import"../chunk-xy4g56g4.js";
 export {
   openMysql,

package/dist/mysql/index.js

@@ -1,14 +1,14 @@
-import {
-  MysqlClient,
-  MysqlDatabase,
-  openMysql
-} from "../chunk-mkhyty75.js";
-import"../chunk-v3hxvnrc.js";
 import {
   parseMysqlEnvTarget
 } from "../chunk-qq77x9ek.js";
 import"../chunk-pfar9cm3.js";
+import {
+  MysqlClient,
+  MysqlDatabase,
+  openMysql
+} from "../chunk-sry9e02n.js";
 import"../chunk-s06hs7a8.js";
+import"../chunk-v3hxvnrc.js";
 import"../chunk-xy4g56g4.js";
 export {
   parseMysqlEnvTarget,

package/dist/redis/index.js

@@ -1,10 +1,3 @@
-import {
-  collectRedisKeyStats,
-  redisGroupedSampleSizes
-} from "../chunk-jr9y0ghr.js";
-import {
-  discoverRedisTopology
-} from "../chunk-c6z919qb.js";
 import {
   RedisAccess,
   RedisClient,
@@ -12,6 +5,13 @@ import {
   openRedis,
   parseRedisInfo
 } from "../chunk-ajhdd4hp.js";
+import {
+  collectRedisKeyStats,
+  redisGroupedSampleSizes
+} from "../chunk-jr9y0ghr.js";
+import {
+  discoverRedisTopology
+} from "../chunk-c6z919qb.js";
 export {
   redisGroupedSampleSizes,
   parseRedisInfo,

package/dist/s3/client.d.ts

@@ -0,0 +1,40 @@
+import type { Client } from "../client";
+import type { ClientLifecycle, ConnectionSource } from "../datasource";
+import type { S3Target, S3Limits, S3RequestOptions, S3ObjectMetadata, S3ObjectPage, S3BucketPage, S3ObjectRead } from "./types";
+/**
+ * @spec Read-only S3 operations share a bounded pool; no failed protocol operation is replayed.
+ * @spec HTTP errors retain SDK status/code, including ambiguous HEAD 403/404 responses.
+ * @why Initialization prepares a route without requiring account-wide bucket-list permission.
+ */
+export declare class S3Client implements Client {
+    #private;
+    private readonly source;
+    private readonly limits;
+    private readonly lifecycle;
+    readonly signal: AbortSignal;
+    constructor(source: ConnectionSource<S3Target>, limits: S3Limits, lifecycle?: ClientLifecycle);
+    initialize(): Promise<void>;
+    /** A failed HEAD remains an error, not a misleading exists=false. */
+    headBucket(bucket: string, options?: S3RequestOptions): Promise<void>;
+    headObject(bucket: string, key: string, options?: S3RequestOptions & {
+        versionId?: string;
+    }): Promise<S3ObjectMetadata>;
+    /** One bounded page; callers own traversal and total scan budgets. */
+    listObjects(bucket: string, options: S3RequestOptions & {
+        maxKeys: number;
+        prefix?: string;
+        delimiter?: string;
+        continuationToken?: string;
+    }): Promise<S3ObjectPage>;
+    listBuckets(options: S3RequestOptions & {
+        maxBuckets: number;
+        continuationToken?: string;
+    }): Promise<S3BucketPage>;
+    getBucketVersioning(bucket: string, options?: S3RequestOptions): Promise<"enabled" | "suspended" | "disabled">;
+    /** Read a bounded prefix. Own and close the response stream before returning the pool slot. */
+    readObject(bucket: string, key: string, options: S3RequestOptions & {
+        maxBytes: number;
+        versionId?: string;
+    }): Promise<S3ObjectRead>;
+    dispose(): Promise<void>;
+}

package/dist/s3/client.js

@@ -0,0 +1,8 @@
+import {
+  S3Client
+} from "../chunk-zp1s833x.js";
+import"../chunk-v3hxvnrc.js";
+import"../chunk-x4ntb898.js";
+export {
+  S3Client
+};

package/dist/s3/datasource.d.ts

@@ -0,0 +1,14 @@
+import { type DataSource } from "../datasource";
+import { type TcpTransport } from "../transport";
+import { S3Client } from "./client";
+import type { S3Limits, S3Target } from "./types";
+/** Connection details are resolved by the caller; route identity includes the cluster/context, not just a transport name. */
+export declare class S3DataSource implements DataSource<S3Client> {
+    #private;
+    readonly key: string;
+    constructor(target: S3Target, limits: S3Limits, route?: {
+        key: string;
+        transport: TcpTransport;
+    });
+    createClient(signal: AbortSignal): S3Client;
+}

package/dist/s3/datasource.js

@@ -0,0 +1,12 @@
+import {
+  S3DataSource
+} from "../chunk-9j36zvn4.js";
+import"../chunk-hqx7j9xe.js";
+import"../chunk-3dt25p98.js";
+import"../chunk-zp1s833x.js";
+import"../chunk-v3hxvnrc.js";
+import"../chunk-x4ntb898.js";
+import"../chunk-xy4g56g4.js";
+export {
+  S3DataSource
+};

package/dist/s3/handler.d.ts

@@ -0,0 +1,13 @@
+import { NodeHttpHandler } from "@smithy/node-http-handler";
+import type { Endpoint } from "../transport";
+import type { S3Limits, S3Target } from "./types";
+/** Routing changes only the socket destination, never the signed HTTP Host or TLS identity. */
+export declare function s3Handler(target: S3Target, route: Endpoint, limits: S3Limits): {
+    handler: {
+        handle(request: Parameters<NodeHttpHandler["handle"]>[0], options: Parameters<NodeHttpHandler["handle"]>[1]): Promise<{
+            response: import("@smithy/core/transport").HttpResponse;
+        }>;
+        destroy(): void;
+    };
+    destroy: () => void;
+};

package/dist/s3/handler.js

@@ -0,0 +1,6 @@
+import {
+  s3Handler
+} from "../chunk-x4ntb898.js";
+export {
+  s3Handler
+};

package/dist/s3/index.d.ts

@@ -0,0 +1,3 @@
+export { S3Client } from "./client";
+export { S3DataSource } from "./datasource";
+export type * from "./types";

package/dist/s3/index.js

@@ -0,0 +1,15 @@
+import {
+  S3DataSource
+} from "../chunk-9j36zvn4.js";
+import"../chunk-hqx7j9xe.js";
+import"../chunk-3dt25p98.js";
+import {
+  S3Client
+} from "../chunk-zp1s833x.js";
+import"../chunk-v3hxvnrc.js";
+import"../chunk-x4ntb898.js";
+import"../chunk-xy4g56g4.js";
+export {
+  S3DataSource,
+  S3Client
+};

package/dist/s3/types.d.ts

@@ -0,0 +1,51 @@
+export interface S3Target {
+    endpoint: string;
+    region: string;
+    credentials: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    forcePathStyle?: boolean;
+    /** Additional trust is explicit; TLS verification is never disabled for a tunnel. */
+    ca?: string;
+}
+/** Root-owned policy, not product defaults. Request time includes queueing and body consumption. */
+export interface S3Limits {
+    concurrency: number;
+    connectTimeoutMs: number;
+    requestTimeoutMs: number;
+}
+export interface S3RequestOptions {
+    signal?: AbortSignal;
+}
+export interface S3ObjectMetadata {
+    size?: number;
+    etag?: string;
+    lastModified?: Date;
+    contentType?: string;
+    versionId?: string;
+    metadata: Record<string, string>;
+}
+export interface S3ObjectPage {
+    objects: Array<{
+        key: string;
+        size?: number;
+        etag?: string;
+        lastModified?: Date;
+    }>;
+    prefixes: string[];
+    truncated: boolean;
+    continuationToken?: string;
+}
+export interface S3BucketPage {
+    buckets: Array<{
+        name: string;
+        creationDate?: Date;
+    }>;
+    continuationToken?: string;
+}
+export interface S3ObjectRead extends S3ObjectMetadata {
+    bytes: Uint8Array;
+    truncated: boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compforge/harness-toolbox",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Shared infrastructure clients, transports and bounded data capture",
   "type": "module",
   "scripts": {
@@ -57,6 +57,14 @@
       "types": "./dist/opensearch/*.d.ts",
       "import": "./dist/opensearch/*.js"
     },
+    "./s3": {
+      "types": "./dist/s3/index.d.ts",
+      "import": "./dist/s3/index.js"
+    },
+    "./s3/*": {
+      "types": "./dist/s3/*.d.ts",
+      "import": "./dist/s3/*.js"
+    },
     "./client": {
       "types": "./dist/client.d.ts",
       "import": "./dist/client.js"
@@ -75,10 +83,12 @@
     "README.md"
   ],
   "dependencies": {
-    "mysql2": "3.23.1",
-    "@redis/client": "6.1.0",
-    "@opensearch-project/opensearch": "3.6.0",
+    "@aws-sdk/client-s3": "3.1133.0",
     "@kubernetes/client-node": "1.4.0",
+    "@opensearch-project/opensearch": "3.6.0",
+    "@redis/client": "6.1.0",
+    "@smithy/node-http-handler": "4.12.1",
+    "mysql2": "3.23.1",
     "node-fetch": "2.7.0"
   },
   "devDependencies": {

package/dist/{chunk-205a4vma.js → chunk-p097seg7.js}

@@ -1,6 +1,3 @@
-import {
-  PortForwardScope
-} from "./chunk-hv2kx47y.js";
 import {
   findPodsForService,
   findService,
@@ -9,6 +6,9 @@ import {
 import {
   findPod
 } from "./chunk-6fnhzhdb.js";
+import {
+  PortForwardScope
+} from "./chunk-hv2kx47y.js";
 
 // src/kubernetes/service-port-forward.ts
 class ServicePortForwarder {

package/dist/{chunk-mkhyty75.js → chunk-sry9e02n.js}

@@ -1,9 +1,9 @@
-import {
-  ConcurrencyPool
-} from "./chunk-v3hxvnrc.js";
 import {
   queryMysqlViaPod
 } from "./chunk-s06hs7a8.js";
+import {
+  ConcurrencyPool
+} from "./chunk-v3hxvnrc.js";
 import {
   isConnectionNetworkError
 } from "./chunk-xy4g56g4.js";