@compforge/harness-toolbox 0.4.4 → 0.4.7

package/dist/chunk-m4d29vfd.js

@@ -0,0 +1,236 @@
+import {
+  acquireConnection,
+  awaitWithSignal
+} from "./chunk-gm4swndx.js";
+import {
+  TimeoutError,
+  ToolboxError
+} from "./chunk-rkt41za2.js";
+import {
+  isConnectionNetworkError
+} from "./chunk-h8fwx0k7.js";
+
+// src/opensearch/client.ts
+import { Client, Connection, errors } from "@opensearch-project/opensearch";
+function describeOpenSearchError(error) {
+  const parts = [];
+  const seen = new Set;
+  while (error && typeof error === "object" && !seen.has(error) && parts.length < 4) {
+    seen.add(error);
+    const value = error;
+    const safe = (value2) => typeof value2 === "number" ? String(value2) : typeof value2 === "string" && /^[a-zA-Z0-9_.-]{1,80}$/.test(value2) ? value2 : undefined;
+    parts.push([
+      `error=${safe(value.name) ?? "Error"}`,
+      safe(value.code) && `code=${safe(value.code)}`,
+      safe(value.kind) && `kind=${safe(value.kind)}`,
+      safe(value.statusCode ?? value.meta?.statusCode) && `status=${safe(value.statusCode ?? value.meta?.statusCode)}`
+    ].filter(Boolean).join(" "));
+    error = value.cause;
+  }
+  return parts.join(" cause=") || "error=UnknownError";
+}
+function isOpenSearchReadApi(search) {
+  return typeof search.request === "function";
+}
+
+class OpenSearchConnection extends Connection {
+  buildRequestObject(params) {
+    return { ...super.buildRequestObject(params), servername: this.ssl?.servername };
+  }
+}
+function createClient(options) {
+  return new Client({
+    node: options.node,
+    Connection: OpenSearchConnection,
+    auth: options.auth.username && options.auth.password ? { username: options.auth.username, password: options.auth.password } : undefined,
+    ssl: { rejectUnauthorized: false, servername: options.servername },
+    requestTimeout: options.requestTimeoutMs ?? 60000,
+    maxRetries: 0,
+    agent: { keepAlive: !process.versions.bun }
+  });
+}
+
+class OpenSearchEngine {
+  options;
+  client;
+  constructor(options, client) {
+    this.options = options;
+    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;
+  }
+  async ping(signal, timeoutMs = this.options.requestTimeoutMs ?? 60000) {
+    signal?.throwIfAborted();
+    const started = Date.now();
+    const url = new URL(this.options.node);
+    const target = `${url.protocol}//${url.host}`;
+    const log = this.options.onDiagnostic ?? (() => {});
+    log(`OpenSearch probe start target=${target} timeout_ms=${timeoutMs}`);
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(new TimeoutError(`OpenSearch probe timed out after ${timeoutMs}ms`)), timeoutMs);
+    const active = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+    try {
+      const request = this.client.ping({}, { requestTimeout: timeoutMs });
+      const result = await awaitWithSignal(request, active, () => request.abort?.());
+      log(`OpenSearch probe ok target=${target} elapsed_ms=${Date.now() - started}`);
+      return result;
+    } catch (error) {
+      log(`OpenSearch probe failed target=${target} elapsed_ms=${Date.now() - started} ${describeOpenSearchError(error)}`);
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async close() {
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(new TimeoutError("OpenSearch close timed out after 2000ms")), 2000);
+    try {
+      await awaitWithSignal(this.client.close(), controller.signal);
+    } catch (error) {
+      this.options.onDiagnostic?.(`OpenSearch close failed ${describeOpenSearchError(error)}`);
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+function openSearchRetryReason(error) {
+  if (isConnectionNetworkError(error))
+    return String(error.code);
+  if (error instanceof errors.TimeoutError)
+    return "ETIMEDOUT";
+  if (error instanceof errors.ConnectionError)
+    return error.name;
+  return;
+}
+
+class OpenSearchClient {
+  source;
+  lifecycle;
+  #controller = new AbortController;
+  signal;
+  #initialization;
+  #disposal;
+  #engine;
+  #operations = new Set;
+  constructor(source, lifecycle = {}) {
+    this.source = source;
+    this.lifecycle = lifecycle;
+    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 awaitWithSignal(this.source.resolve(), this.signal);
+      this.signal.throwIfAborted();
+      const original = new URL(target.node);
+      try {
+        this.#engine = await acquireConnection(this.source.transports, {
+          name: "OpenSearch connection",
+          signal: this.signal,
+          connectTimeoutMs: target.connectTimeoutMs ?? target.requestTimeoutMs ?? 1e4,
+          acquireTimeoutMs: target.acquireTimeoutMs,
+          onRoute: this.lifecycle.onRoute,
+          open: async (transport, attempt) => {
+            if (transport.kind !== "tcp")
+              throw new Error("OpenSearch requires a TCP transport");
+            this.lifecycle.onDiagnostic?.(`OpenSearch route start transport=${transport.name} target=${original.protocol}//${original.host} timeout_ms=${attempt.remainingMs()}`);
+            const endpoint = await transport.connect({
+              host: original.hostname,
+              port: Number(original.port || (original.protocol === "https:" ? 443 : 80)),
+              servername: target.servername ?? original.hostname
+            });
+            attempt.signal.throwIfAborted();
+            const url = new URL(original);
+            url.hostname = endpoint.host;
+            url.port = String(endpoint.port);
+            const engine = new OpenSearchEngine({ ...target, onDiagnostic: this.lifecycle.onDiagnostic, node: url.toString(), servername: endpoint.servername ?? target.servername ?? original.hostname });
+            try {
+              await engine.ping(attempt.signal, attempt.remainingMs());
+              return { connection: engine, transport: transport.name };
+            } catch (error) {
+              await engine.close();
+              throw error;
+            }
+          },
+          close: (engine) => engine.close(),
+          retryReason: openSearchRetryReason
+        });
+      } catch (error) {
+        this.lifecycle.onDiagnostic?.(`OpenSearch connect failed ${describeOpenSearchError(error)}`);
+        this.signal.throwIfAborted();
+        if (error instanceof ToolboxError && error.kind === "timeout")
+          throw error;
+        const reason = openSearchRetryReason(error);
+        if (reason === undefined)
+          throw error;
+        throw new ToolboxError(`OpenSearch connect failed (${reason})`, { kind: "connection_failed", code: reason, cause: error });
+      }
+    })();
+  }
+  #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 { describeOpenSearchError, isOpenSearchReadApi, OpenSearchEngine, OpenSearchClient, openOpenSearch };

package/dist/{chunk-631vce5z.js → chunk-nftzckdy.js}

@@ -1,12 +1,13 @@
 import {
   buildKubectlArgs
-} from "./chunk-hmah9t8e.js";
+} from "./chunk-rq5fc007.js";
 import {
   spawnProcess
-} from "./chunk-mn6dwsvh.js";
+} from "./chunk-9shz0bw1.js";
 
 // src/kubernetes/port-forward.ts
 async function startPortForward(opts) {
+  opts.signal?.throwIfAborted();
   const target = opts.target ?? (opts.service ? { kind: "service", name: opts.service } : undefined);
   if (!target)
     return { ok: false, reason: "port-forward 缺少 Service/Pod 目标" };
@@ -24,8 +25,51 @@ async function startPortForward(opts) {
     return { ok: false, reason: err instanceof Error ? err.message : String(err) };
   }
   const timeoutMs = opts.timeoutMs ?? 15000;
-  const stderrPromise = new Response(proc.stderr).text();
+  const log = opts.onDiagnostic ?? (() => {});
+  const started = Date.now();
+  log(`port-forward start target=${target.kind}/${target.name} namespace=${opts.namespace ?? "default"} remote_port=${opts.remotePort} timeout_ms=${timeoutMs}`);
+  let stderr = "";
+  let loggedBytes = 0;
+  const stderrReader = proc.stderr.getReader();
+  const stderrDone = (async () => {
+    const decoder2 = new TextDecoder;
+    for (;; ) {
+      const chunk = await stderrReader.read();
+      if (chunk.done)
+        break;
+      const text = decoder2.decode(chunk.value, { stream: true }).replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/g, "$1[redacted]@").replace(/([?&](?:token|password|secret|key)=)[^&\s]+/gi, "$1[redacted]").replace(/((?:authorization|password|token)[:=]\s*)[^\r\n]+/gi, "$1[redacted]");
+      stderr = (stderr + text).slice(-8192);
+      if (loggedBytes < 8192) {
+        const diagnostic = text.slice(0, 8192 - loggedBytes);
+        loggedBytes += diagnostic.length;
+        log(`port-forward stderr: ${diagnostic.trim()}`);
+      }
+    }
+  })().catch(() => {});
+  let stopped = false;
+  let cancelWait;
+  const cancelled = new Promise((resolve) => {
+    cancelWait = () => resolve("cancelled");
+  });
+  const abort = () => {
+    log(`port-forward cancelled elapsed_ms=${Date.now() - started}`);
+    stop();
+    cancelWait();
+  };
+  const stop = () => {
+    if (stopped)
+      return;
+    stopped = true;
+    opts.signal?.removeEventListener("abort", abort);
+    proc.kill("SIGKILL");
+    stderrReader.cancel().catch(() => {});
+    reader.cancel().catch(() => {});
+  };
   const reader = proc.stdout.getReader();
+  opts.signal?.addEventListener("abort", abort, { once: true });
+  if (opts.signal?.aborted)
+    abort();
+  proc.exited.then(() => opts.signal?.removeEventListener("abort", abort), () => opts.signal?.removeEventListener("abort", abort));
   const decoder = new TextDecoder;
   const deadline = Date.now() + timeoutMs;
   let out = "";
@@ -36,6 +80,7 @@ async function startPortForward(opts) {
     let timer;
     const chunk = await Promise.race([
       reader.read(),
+      cancelled,
       new Promise((resolve) => {
         timer = setTimeout(() => resolve("timeout"), remain);
       }),
@@ -43,10 +88,13 @@ async function startPortForward(opts) {
     ]).finally(() => {
       clearTimeout(timer);
     });
+    opts.signal?.throwIfAborted();
+    if (chunk === "cancelled")
+      throw opts.signal?.reason;
     if (chunk === "timeout")
       break;
     if (typeof chunk === "object" && "error" in chunk) {
-      proc.kill();
+      stop();
       return { ok: false, reason: chunk.error instanceof Error ? chunk.error.message : String(chunk.error) };
     }
     if (chunk === "exited" || chunk.done)
@@ -54,16 +102,18 @@ async function startPortForward(opts) {
     out += decoder.decode(chunk.value);
     const m = out.match(/Forwarding from 127\.0\.0\.1:(\d+)/);
     if (m) {
+      log(`port-forward listening local=127.0.0.1:${m[1]} elapsed_ms=${Date.now() - started}`);
       return {
         ok: true,
-        value: { target, localPort: Number(m[1]), command: argv, stop: () => proc.kill() }
+        value: { target, localPort: Number(m[1]), command: argv, stop }
       };
     }
   }
-  proc.kill();
-  const stderr = await stderrPromise.catch(() => "");
+  await Promise.resolve();
+  stop();
   const reason = stderr.trim().split(`
 `)[0] || `port-forward 未就绪（${timeoutMs}ms 超时）`;
+  log(`port-forward failed elapsed_ms=${Date.now() - started} reason=${reason}`);
   return { ok: false, reason };
 }
 

package/dist/{chunk-shsabpc1.js → chunk-r3rnsvwv.js}

@@ -1,7 +1,7 @@
 import {
   KubernetesError,
   kubernetesHttpError
-} from "./chunk-20kv4wc3.js";
+} from "./chunk-rkt41za2.js";
 import {
   ConcurrencyPool
 } from "./chunk-v3hxvnrc.js";

package/dist/{chunk-20kv4wc3.js → chunk-rkt41za2.js}

@@ -15,6 +15,12 @@ class KubernetesError extends ToolboxError {
 
 class FileError extends ToolboxError {
 }
+
+class TimeoutError extends ToolboxError {
+  constructor(message, options) {
+    super(message, { kind: "timeout", code: "ETIMEDOUT", cause: options?.cause });
+  }
+}
 function kubernetesHttpError(status) {
   const kind = {
     401: "authentication_failed",
@@ -41,4 +47,4 @@ function kubernetesCommandError(result) {
   return status ? kubernetesHttpError(status) : new KubernetesError("Kubernetes resource request failed", { kind: "operation_failed" });
 }
 
-export { ToolboxError, KubernetesError, FileError, kubernetesHttpError, kubernetesCommandError };
+export { ToolboxError, KubernetesError, FileError, TimeoutError, kubernetesHttpError, kubernetesCommandError };

package/dist/{chunk-hmah9t8e.js → chunk-rq5fc007.js}

@@ -1,6 +1,6 @@
 import {
   spawnProcess
-} from "./chunk-mn6dwsvh.js";
+} from "./chunk-9shz0bw1.js";
 
 // src/kubernetes/executor.ts
 function buildKubectlArgs(opts, sub) {

package/dist/{chunk-h73h2b7y.js → chunk-t4hrnaj0.js}

@@ -5,13 +5,18 @@ import {
 import {
   queryReadonlySession,
   validateQueryLimits
-} from "./chunk-age65q4n.js";
+} from "./chunk-db4an9td.js";
 import {
+  connectMysql,
   destroyMysqlConnection
-} from "./chunk-136egyff.js";
+} from "./chunk-835fssgz.js";
+import {
+  acquireConnection,
+  awaitWithSignal
+} from "./chunk-gm4swndx.js";
 import {
   ToolboxError
-} from "./chunk-20kv4wc3.js";
+} from "./chunk-rkt41za2.js";
 import {
   ConcurrencyPool
 } from "./chunk-v3hxvnrc.js";
@@ -20,7 +25,6 @@ import {
 } from "./chunk-h8fwx0k7.js";
 
 // src/mysql/client.ts
-import { createConnection } from "mysql2/promise";
 function mysqlOperationError(error, phase) {
   if (!error || typeof error !== "object" || !("code" in error) || error.code !== "PROTOCOL_CONNECTION_LOST")
     return error;
@@ -37,7 +41,7 @@ class MysqlDatabase {
   connect;
   #queries = new ConcurrencyPool(1);
   #connections = new Map;
-  constructor(transports, options, connect = createConnection) {
+  constructor(transports, options, connect = connectMysql) {
     this.transports = transports;
     this.options = options;
     this.connect = connect;
@@ -120,39 +124,40 @@ class MysqlDatabase {
       return rows;
     });
   }
-  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) {
-        const failure = mysqlOperationError(error, "connect");
-        const connectionLost = failure instanceof ToolboxError && failure.kind === "connection_lost";
-        if (!isConnectionNetworkError(failure) && !connectionLost || i === this.transports.length - 1)
-          throw failure;
-        reason = String(failure.code);
-      }
-    }
-    throw new Error("MySQL DataSource has no transport");
+  #open(target) {
+    return acquireConnection(this.transports, {
+      name: "MySQL connection",
+      ...this.options,
+      open: async (transport, attempt) => {
+        if (transport.kind === "python")
+          return { connection: { kind: "python", transport }, transport: transport.name };
+        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: attempt.remainingMs(),
+            dateStrings: true,
+            supportBigNumbers: true,
+            bigNumberStrings: true
+          }, attempt.signal);
+          return {
+            connection: { kind: "tcp", connection },
+            transport: endpoint.host === target.host && endpoint.port === target.port ? "direct" : transport.name
+          };
+        } catch (error) {
+          throw mysqlOperationError(error, "connect");
+        }
+      },
+      close: (session) => {
+        if (session.kind === "tcp")
+          destroyMysqlConnection(session.connection);
+      },
+      retryReason: (error) => isConnectionNetworkError(error) || error instanceof ToolboxError && error.kind === "connection_lost" ? String(error.code) : undefined
+    });
   }
   async queryOne(target, sql, values) {
     return (await this.query(target, sql, values))[0];
@@ -186,7 +191,7 @@ class MysqlClient {
   initialize() {
     this.signal.throwIfAborted();
     return this.#initialization ??= (async () => {
-      this.#target = await this.source.resolve();
+      this.#target = await awaitWithSignal(this.source.resolve(), this.signal);
       this.signal.throwIfAborted();
       this.#database = new MysqlDatabase(this.source.transports, { ...this.options, signal: this.signal });
       await this.#database.initialize(this.#target);

package/dist/{chunk-kkts16w9.js → chunk-ww11q58v.js}

@@ -1,7 +1,7 @@
 import {
   FileError,
   ToolboxError
-} from "./chunk-20kv4wc3.js";
+} from "./chunk-rkt41za2.js";
 import {
   ConcurrencyPool
 } from "./chunk-v3hxvnrc.js";

package/dist/{chunk-4ms037k2.js → chunk-x0yhfg29.js}

@@ -1,6 +1,6 @@
 import {
   resourcePath
-} from "./chunk-ftkrjqkc.js";
+} from "./chunk-dpcge1xt.js";
 import {
   clientKey
 } from "./chunk-a9htb6cr.js";
@@ -8,7 +8,7 @@ import {
   KubernetesError,
   ToolboxError,
   kubernetesHttpError
-} from "./chunk-20kv4wc3.js";
+} from "./chunk-rkt41za2.js";
 import {
   ConcurrencyPool
 } from "./chunk-v3hxvnrc.js";

package/dist/{chunk-j46x7j7c.js → chunk-xgnz10sr.js}

@@ -53,11 +53,13 @@ function findPodsForService(services, pods, serviceName, namespace) {
     return [];
   return pods.filter((pod) => pod.namespace === namespace && pod.phase === "Running" && selector.every(([name, value]) => pod.labels[name] === value)).sort((left, right) => left.name.localeCompare(right.name));
 }
-async function listServiceNetwork(executor, namespace) {
+async function listServiceNetwork(executor, namespace, signal) {
+  signal?.throwIfAborted();
   const [serviceResult, podResult] = await Promise.all([
-    executor.run(["get", "services", "-o", "json"], { timeoutMs: 20000 }),
-    executor.run(["get", "pods", "-o", "json"], { timeoutMs: 20000 })
+    executor.run(["get", "services", "-o", "json"], { timeoutMs: 20000, signal }),
+    executor.run(["get", "pods", "-o", "json"], { timeoutMs: 20000, signal })
   ]);
+  signal?.throwIfAborted();
   if (!serviceResult.ok) {
     throw new Error(`读取 Service 失败：${serviceResult.stderr.trim() || `exit=${serviceResult.exitCode}`}`);
   }

package/dist/{chunk-5zgz1z41.js → chunk-z15gwjvg.js}

@@ -1,6 +1,6 @@
 import {
   KubernetesError
-} from "./chunk-20kv4wc3.js";
+} from "./chunk-rkt41za2.js";
 
 // src/kubernetes/compute-quantity.ts
 function object(value) {

package/dist/connection/acquire.d.ts

@@ -0,0 +1,34 @@
+import type { ClientLifecycle } from "../datasource";
+/** Stop waiting without leaving rejected preparation promises unobserved. */
+export declare function awaitWithSignal<T>(pending: Promise<T>, signal: AbortSignal, cancel?: () => void): Promise<T>;
+export interface ConnectionAttempt {
+    readonly signal: AbortSignal;
+    /** Remaining mapping + handshake budget, not a fresh timeout for each phase. */
+    remainingMs(): number;
+}
+interface Acquisition<R, C> {
+    name: string;
+    connectTimeoutMs: number;
+    acquireTimeoutMs?: number;
+    signal?: AbortSignal;
+    open(route: R, attempt: ConnectionAttempt): Promise<{
+        connection: C;
+        transport: string;
+    }>;
+    close(connection: C): void | Promise<void>;
+    /** Undefined means terminal; authentication and protocol errors must not change route. */
+    retryReason(error: unknown): string | undefined;
+    onRoute?: ClientLifecycle["onRoute"];
+}
+/**
+ * @spec One acquisition owns ordered attempts and a deadline covering mapping and handshake.
+ * @spec Cancellation keeps its original reason; a late successful connection is closed, never published.
+ * @rule Only connection preparation enters this function. Commands and queries must never be replayed.
+ * @why Protocol adapters own partial handles and error classification; all protocols share the same lifecycle.
+ * @see {@link component://docs/toolbox.md}
+ * @case id=connection_mapping_cancel,desc=`Cancel while mapping a route`,expect=`Acquisition exits without a late handshake`
+ */
+export declare function acquireConnection<R extends {
+    readonly name: string;
+}, C>(routes: readonly R[], options: Acquisition<R, C>): Promise<C>;
+export {};

package/dist/connection/acquire.js

@@ -0,0 +1,9 @@
+import {
+  acquireConnection,
+  awaitWithSignal
+} from "../chunk-gm4swndx.js";
+import"../chunk-rkt41za2.js";
+export {
+  awaitWithSignal,
+  acquireConnection
+};

package/dist/datasource.js

@@ -6,7 +6,7 @@ import {
 import {
   KubernetesError,
   ToolboxError
-} from "./chunk-20kv4wc3.js";
+} from "./chunk-rkt41za2.js";
 export {
   clientKey,
   ToolboxError,

package/dist/errors.d.ts

@@ -13,6 +13,10 @@ export declare class KubernetesError extends ToolboxError {
 }
 export declare class FileError extends ToolboxError {
 }
+/** A local deadline expiry, distinct from a connection failure reported by a driver. */
+export declare class TimeoutError extends ToolboxError {
+    constructor(message: string, options?: ErrorOptions);
+}
 export declare function kubernetesHttpError(status: number): KubernetesError;
 /**
  * Normalize a failed kubectl resource request at the transport boundary.

package/dist/errors.js

@@ -1,14 +1,16 @@
 import {
   FileError,
   KubernetesError,
+  TimeoutError,
   ToolboxError,
   kubernetesCommandError,
   kubernetesHttpError
-} from "./chunk-20kv4wc3.js";
+} from "./chunk-rkt41za2.js";
 export {
   kubernetesHttpError,
   kubernetesCommandError,
   ToolboxError,
+  TimeoutError,
   KubernetesError,
   FileError
 };

package/dist/file/client.js

@@ -2,8 +2,8 @@ import {
   BoundedFileClient,
   fileClientOptions,
   filePaths
-} from "../chunk-kkts16w9.js";
-import"../chunk-20kv4wc3.js";
+} from "../chunk-ww11q58v.js";
+import"../chunk-rkt41za2.js";
 import"../chunk-v3hxvnrc.js";
 export {
   filePaths,