@compforge/harness-toolbox 0.4.2 → 0.4.4

package/README.md

@@ -62,6 +62,26 @@ never close it themselves.
 Version 0.4.2 requires Common 0.5.4. Replace single path arguments with arrays, supply `maxTotalBytes`,
 and handle per-file results. Publish Common before Toolbox; this change has no single-file legacy adapter.
 
+## Redis sources
+
+`RedisClient` owns resolved configuration and reusable node connections. Use `clusterType` to
+select `single`, `cluster` or `sentinel`; `endpoints` contains that mode's seed addresses. Sentinel
+configuration additionally provides `sentinelMasterName` and optional Sentinel credentials,
+separate from data-node credentials. Cluster connections require database zero.
+
+Supply ordered TCP transports through `ConnectionSource`. Only mapping or handshake network
+failures advance to the next transport; authentication and TLS verification failures stop immediately.
+`connectTimeoutMs` bounds each route (mapping and handshake); it defaults to the command
+`timeoutMs`. `acquireTimeoutMs` bounds all candidates together and defaults to the per-route budget
+times the number of routes. A spent total budget does not start another route.
+`onRoute` reports the selected route and the preceding failure code without credentials.
+
+`client.topology()` refreshes topology using the same connections and route policy as
+`client.access.connection(endpoint, database)`. A root signal cancels connection preparation and
+active commands. Commands and pipelines are sent once, with no offline queue or automatic replay;
+a subsequent acquisition replaces an unhealthy connection. The caller owns `dispose()` and transport
+cleanup, and diagnostics own sampling policy and collected observations.
+
 ## Kubernetes resources
 
 Borrow a root `KubernetesClient` through `KubernetesEnvironment` and `ClientManager`. Use
@@ -356,3 +376,11 @@ reason. The caller owns shared transports such as `PodRelayTransport` and their
 
 Routed HTTPS preserves the original TLS server name. Bun disables HTTP keep-alive because its reused
 socket recovery can replay a failed request below the driver; Node retains connection pooling.
+
+## Kubernetes compute evidence
+
+`kubernetes/compute` exports `collectClusterCompute` and `collectWorkloadCompute`. They borrow
+ResourceAccess, use explicit deadlines/item/page budgets, and retain read coverage independently.
+Use `client.clusterResources()` for Nodes and all-namespace Pods; normal client methods retain their
+configured namespace. A forbidden cluster read records `permission_denied`; it does not block a
+separate namespace-scoped Workload read. See [compute collection](../../../docs/toolbox.md#kubernetes-compute-evidence).

package/dist/{chunk-c6z919qb.js → chunk-5tbzf9wd.js}

@@ -26,7 +26,7 @@ function sentinelRows(value) {
   });
 }
 async function discoverSentinel(access, config) {
-  const sentinels = config.sentinelHosts.length ? config.sentinelHosts : config.endpoints;
+  const sentinels = config.endpoints;
   let lastError;
   for (const sentinel of sentinels) {
     try {

package/dist/chunk-5zgz1z41.js

@@ -0,0 +1,145 @@
+import {
+  KubernetesError
+} from "./chunk-20kv4wc3.js";
+
+// src/kubernetes/compute-quantity.ts
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function invalid(message) {
+  throw new KubernetesError(message, { kind: "invalid_response" });
+}
+function requiredString(value, field) {
+  if (typeof value !== "string" || !value)
+    return invalid(`Kubernetes response lacks ${field}`);
+  return value;
+}
+function parseComputeQuantity(value) {
+  if (typeof value !== "string")
+    return invalid("Kubernetes quantity must be a string");
+  const match = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+))([eE][+-]?\d+|[numkMGTPE]|[KMGTPE]i)?$/.exec(value);
+  if (!match)
+    return invalid("Invalid Kubernetes quantity");
+  const suffix = match[2] ?? "";
+  const factors = {
+    "": 1,
+    n: 0.000000001,
+    u: 0.000001,
+    m: 0.001,
+    k: 1000,
+    M: 1e6,
+    G: 1e9,
+    T: 1000000000000,
+    P: 1000000000000000,
+    E: 1000000000000000000,
+    Ki: 2 ** 10,
+    Mi: 2 ** 20,
+    Gi: 2 ** 30,
+    Ti: 2 ** 40,
+    Pi: 2 ** 50,
+    Ei: 2 ** 60
+  };
+  const result = Number(match[1]) * (/^[eE][+-]?\d+$/.test(suffix) ? 10 ** Number(suffix.slice(1)) : factors[suffix]);
+  if (!Number.isFinite(result) || result < 0 || result > Number.MAX_SAFE_INTEGER) {
+    return invalid("Kubernetes quantity is outside the supported numeric range");
+  }
+  return result;
+}
+var zero = () => ({ cpu: 0, memory: 0 });
+function add(left, right) {
+  return { cpu: left.cpu + right.cpu, memory: left.memory + right.memory };
+}
+function max(left, right) {
+  return { cpu: Math.max(left.cpu, right.cpu), memory: Math.max(left.memory, right.memory) };
+}
+function quantities(value, required = false) {
+  const input = object(value);
+  return {
+    cpu: input.cpu === undefined && !required ? 0 : parseComputeQuantity(input.cpu),
+    memory: input.memory === undefined && !required ? 0 : parseComputeQuantity(input.memory)
+  };
+}
+function sum(values) {
+  return values.reduce(add, zero());
+}
+function containers(value) {
+  if (!Array.isArray(value))
+    return invalid("Pod response lacks containers");
+  return value.map((item) => {
+    const container = object(item);
+    requiredString(container.name, "container.name");
+    return container;
+  });
+}
+function podCompute(value) {
+  const meta = object(value.metadata), spec = object(value.spec), status = object(value.status);
+  const app = containers(spec.containers);
+  if (!app.length)
+    return invalid("Pod must contain an application container");
+  const init = containers(spec.initContainers ?? []);
+  const effective = (field) => {
+    let steady = sum(app.map((c) => quantities(object(c.resources)[field])));
+    let sidecars = zero(), peak = zero();
+    for (const container of init) {
+      const current = quantities(object(container.resources)[field]);
+      if (container.restartPolicy === "Always") {
+        sidecars = add(sidecars, current);
+        steady = add(steady, current);
+        peak = max(peak, sidecars);
+      } else
+        peak = max(peak, add(sidecars, current));
+    }
+    const result = max(steady, peak);
+    const podLevel = object(object(spec.resources)[field]);
+    const overhead = quantities(spec.overhead);
+    for (const key of ["cpu", "memory"]) {
+      if (podLevel[key] !== undefined)
+        result[key] = parseComputeQuantity(podLevel[key]);
+      if (field === "requests" || result[key] > 0)
+        result[key] += overhead[key];
+    }
+    return result;
+  };
+  const without = zero();
+  for (const container of [...app, ...init]) {
+    const limits = object(object(container.resources).limits);
+    for (const key of ["cpu", "memory"])
+      if (limits[key] === undefined)
+        without[key]++;
+  }
+  const conditions = Array.isArray(status.conditions) ? status.conditions.map(object) : [];
+  const states = [
+    ...Array.isArray(status.containerStatuses) ? status.containerStatuses : [],
+    ...Array.isArray(status.initContainerStatuses) ? status.initContainerStatuses : []
+  ].map(object);
+  return {
+    namespace: requiredString(meta.namespace, "metadata.namespace"),
+    name: requiredString(meta.name, "metadata.name"),
+    uid: requiredString(meta.uid, "metadata.uid"),
+    createdAt: typeof meta.creationTimestamp === "string" ? meta.creationTimestamp : undefined,
+    node: typeof spec.nodeName === "string" && spec.nodeName ? spec.nodeName : undefined,
+    phase: requiredString(status.phase, "status.phase"),
+    ready: conditions.some((c) => c.type === "Ready" && c.status === "True"),
+    restarts: states.reduce((n, c) => n + (typeof c.restartCount === "number" ? c.restartCount : 0), 0),
+    containers: [...app, ...init.filter((c) => c.restartPolicy === "Always")].map((c) => String(c.name)),
+    requests: effective("requests"),
+    configuredLimits: effective("limits"),
+    containersWithoutLimits: without
+  };
+}
+function summarizePods(pods) {
+  const active = pods.filter((p) => p.phase !== "Succeeded" && p.phase !== "Failed");
+  const scheduled = active.filter((p) => p.node);
+  return {
+    pods: pods.length,
+    activePods: active.length,
+    scheduledPods: scheduled.length,
+    readyPods: active.filter((p) => p.ready).length,
+    requests: sum(active.map((p) => p.requests)),
+    scheduledRequests: sum(scheduled.map((p) => p.requests)),
+    configuredLimits: sum(active.map((p) => p.configuredLimits)),
+    containersWithoutLimits: sum(active.map((p) => p.containersWithoutLimits))
+  };
+}
+
+export { object, requiredString, parseComputeQuantity, zero, add, quantities, sum, podCompute, summarizePods };

package/dist/{chunk-8kts470p.js → chunk-c2n8zvyn.js}

@@ -1,15 +1,15 @@
-import {
-  KubernetesResourceTransport
-} from "./chunk-4ms037k2.js";
-import {
-  resolveWorkload
-} from "./chunk-0s27bgga.js";
 import {
   ServicePortForwarder
 } from "./chunk-2171tajs.js";
+import {
+  KubernetesResourceTransport
+} from "./chunk-4ms037k2.js";
 import {
   KubernetesExecTransport
 } from "./chunk-shsabpc1.js";
+import {
+  resolveWorkload
+} from "./chunk-0s27bgga.js";
 import {
   KubernetesError
 } from "./chunk-20kv4wc3.js";
@@ -83,6 +83,12 @@ class KubernetesClient {
   list(query, options) {
     return this.#track(() => this.#resourceAccess().list({ ...query, namespace: query.namespace ?? this.kube.namespace }, this.#options(options)));
   }
+  clusterResources() {
+    return {
+      get: (ref, options) => this.#track(() => this.#resourceAccess().get(ref, this.#options(options))),
+      list: (query, options) => this.#track(() => this.#resourceAccess().list(query, this.#options(options)))
+    };
+  }
   inNamespace(namespace) {
     if (!namespace.trim())
       throw new KubernetesError("Namespace is required", { kind: "invalid_argument" });

package/dist/chunk-yp6tcw22.js

@@ -0,0 +1,366 @@
+import {
+  discoverRedisTopology
+} from "./chunk-5tbzf9wd.js";
+import {
+  ToolboxError
+} from "./chunk-20kv4wc3.js";
+import {
+  isConnectionNetworkError
+} from "./chunk-h8fwx0k7.js";
+
+// src/redis/client.ts
+import { createClient, SocketClosedUnexpectedlyError, ConnectionTimeoutError } from "@redis/client";
+function stringValue(value) {
+  if (Buffer.isBuffer(value))
+    return value.toString("utf8");
+  return String(value ?? "");
+}
+function scalar(value) {
+  if (/^-?(?:\d+|\d+\.\d+)$/.test(value))
+    return Number(value);
+  return value;
+}
+function parseRedisInfo(raw) {
+  const result = {};
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line || line.startsWith("#"))
+      continue;
+    const separator = line.indexOf(":");
+    if (separator < 1)
+      continue;
+    const name = line.slice(0, separator);
+    const value = line.slice(separator + 1);
+    if (/^db\d+$/.test(name)) {
+      result[name] = Object.fromEntries(value.split(",").map((item) => {
+        const index = item.indexOf("=");
+        return [item.slice(0, index), scalar(item.slice(index + 1))];
+      }));
+    } else {
+      result[name] = scalar(value);
+    }
+  }
+  return result;
+}
+async function abortable(pending, signal, cancel) {
+  if (signal.aborted) {
+    cancel?.();
+    pending.catch(() => {});
+    signal.throwIfAborted();
+  }
+  let abort;
+  const cancelled = new Promise((_, reject) => {
+    abort = () => {
+      cancel?.();
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  try {
+    return await Promise.race([pending, cancelled]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+
+class RedisConnection {
+  endpoint;
+  client;
+  timeoutMs;
+  lastError;
+  signal;
+  #abort;
+  constructor(endpoint, client, timeoutMs, lastError, signal) {
+    this.endpoint = endpoint;
+    this.client = client;
+    this.timeoutMs = timeoutMs;
+    this.lastError = lastError;
+    this.signal = signal;
+    this.#abort = () => this.close();
+    signal?.addEventListener("abort", this.#abort, { once: true });
+  }
+  static async connect(endpoint, mapped, config, clientFactory = createClient) {
+    config.signal?.throwIfAborted();
+    config.connectSignal?.throwIfAborted();
+    const baseSocket = {
+      host: mapped.host,
+      port: mapped.port,
+      connectTimeout: config.connectTimeoutMs ?? config.timeoutMs,
+      reconnectStrategy: false
+    };
+    const socket = config.useSsl ? { ...baseSocket, tls: true, servername: mapped.servername ?? endpoint.host } : { ...baseSocket, tls: false };
+    const client = clientFactory({
+      socket,
+      database: config.database,
+      username: config.username,
+      password: config.password,
+      disableOfflineQueue: true,
+      commandOptions: { timeout: config.timeoutMs }
+    });
+    let lastError;
+    client.on("error", (err) => {
+      lastError = err instanceof Error ? err : new Error(String(err));
+    });
+    const timeout = new AbortController;
+    const timer = setTimeout(() => timeout.abort(new ToolboxError("Redis handshake timed out", { kind: "timeout", code: "ETIMEDOUT" })), config.connectTimeoutMs ?? config.timeoutMs);
+    const signal = AbortSignal.any([
+      timeout.signal,
+      ...config.signal ? [config.signal] : [],
+      ...config.connectSignal ? [config.connectSignal] : []
+    ]);
+    const close = () => {
+      if (client.isOpen)
+        client.destroy();
+    };
+    try {
+      await abortable(client.connect(), signal, close);
+      signal.throwIfAborted();
+      return new RedisConnection(endpoint, client, config.timeoutMs, () => lastError, config.signal);
+    } catch (error) {
+      close();
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  get isReady() {
+    return !this.signal?.aborted && this.client.isReady;
+  }
+  async#execute(operationName, operation) {
+    this.signal?.throwIfAborted();
+    if (!this.client.isOpen) {
+      const reason = this.lastError()?.message;
+      throw new Error(`Redis connection is closed${reason ? `: ${reason}` : ""}`);
+    }
+    const timeout = new AbortController;
+    const timer = setTimeout(() => timeout.abort(new ToolboxError(`Redis ${operationName} timed out after ${this.timeoutMs}ms (${this.endpoint.host}:${this.endpoint.port})`, { kind: "timeout", code: "ETIMEDOUT" })), this.timeoutMs);
+    const signal = this.signal ? AbortSignal.any([this.signal, timeout.signal]) : timeout.signal;
+    try {
+      return await abortable(Promise.resolve().then(() => {
+        signal.throwIfAborted();
+        return operation();
+      }), signal, () => this.close());
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  ping() {
+    return this.#execute("PING", () => this.client.ping());
+  }
+  async info(section) {
+    const raw = await this.#execute(section ? `INFO ${section}` : "INFO", () => section ? this.client.sendCommand(["INFO", section]) : this.client.sendCommand(["INFO"]));
+    return parseRedisInfo(stringValue(raw));
+  }
+  async dbSize() {
+    return Number(await this.#execute("DBSIZE", () => this.client.sendCommand(["DBSIZE"])));
+  }
+  command(args) {
+    return this.#execute(args[0]?.toUpperCase() ?? "command", () => this.client.sendCommand(args));
+  }
+  async pipeline(commands) {
+    const commandNames = new Set(commands.map((command) => command[0]?.toUpperCase()).filter(Boolean));
+    const operationName = commandNames.size === 1 ? `${[...commandNames][0]} pipeline` : "pipeline";
+    return await this.#execute(operationName, () => {
+      const pipeline = this.client.multi();
+      for (const command of commands)
+        pipeline.addCommand(command);
+      return pipeline.execAsPipeline();
+    });
+  }
+  async scan(cursor, count) {
+    const reply = await this.command(["SCAN", cursor, "COUNT", String(count)]);
+    if (!Array.isArray(reply) || !Array.isArray(reply[1]))
+      throw new Error("Redis SCAN 返回格式无效");
+    return { cursor: stringValue(reply[0]), keys: reply[1].map(stringValue) };
+  }
+  close() {
+    if (this.#abort)
+      this.signal?.removeEventListener("abort", this.#abort);
+    if (this.client.isOpen)
+      this.client.destroy();
+  }
+}
+
+class RedisAccess {
+  baseConfig;
+  connectionFactory;
+  lifecycle;
+  #connections = new Map;
+  #controller = new AbortController;
+  #signal;
+  #transports;
+  #closing;
+  constructor(transports, baseConfig, connectionFactory = RedisConnection.connect, lifecycle = {}) {
+    this.baseConfig = baseConfig;
+    this.connectionFactory = connectionFactory;
+    this.lifecycle = lifecycle;
+    this.#transports = Array.isArray(transports) ? transports : [transports];
+    if (!this.#transports.length)
+      throw new Error("Redis requires a TCP transport");
+    for (const value of [
+      baseConfig.timeoutMs,
+      baseConfig.connectTimeoutMs ?? baseConfig.timeoutMs,
+      baseConfig.acquireTimeoutMs ?? (baseConfig.connectTimeoutMs ?? baseConfig.timeoutMs) * this.#transports.length
+    ]) {
+      if (!Number.isFinite(value) || value <= 0)
+        throw new Error("Redis timeouts must be positive milliseconds");
+    }
+    this.#signal = lifecycle.signal ? AbortSignal.any([lifecycle.signal, this.#controller.signal]) : this.#controller.signal;
+  }
+  async connection(endpoint, database, credentials = this.baseConfig) {
+    this.#signal.throwIfAborted();
+    const key = [endpoint.host, endpoint.port, database, credentials.username ?? "", credentials.password ?? ""].join("\x00");
+    const existing = this.#connections.get(key);
+    if (existing) {
+      const connection = await existing;
+      this.#signal.throwIfAborted();
+      if (connection.isReady)
+        return connection;
+      if (this.#connections.get(key) === existing) {
+        this.#connections.delete(key);
+        connection.close();
+      }
+      return this.connection(endpoint, database, credentials);
+    }
+    const pending = this.#open(endpoint, database, credentials);
+    this.#connections.set(key, pending);
+    pending.catch(() => {
+      if (this.#connections.get(key) === pending)
+        this.#connections.delete(key);
+    });
+    return pending;
+  }
+  async#open(endpoint, database, credentials) {
+    const timeout = new AbortController;
+    const attemptBudget = this.baseConfig.connectTimeoutMs ?? this.baseConfig.timeoutMs;
+    const budget = this.baseConfig.acquireTimeoutMs ?? attemptBudget * this.#transports.length;
+    const deadline = performance.now() + budget;
+    const timer = setTimeout(() => timeout.abort(new ToolboxError(`Redis connection timed out after ${budget}ms (${endpoint.host}:${endpoint.port})`, { kind: "timeout", code: "ETIMEDOUT" })), budget);
+    const signal = AbortSignal.any([this.#signal, timeout.signal]);
+    let reason;
+    try {
+      for (let index = 0;index < this.#transports.length; index++) {
+        signal.throwIfAborted();
+        const transport = this.#transports[index];
+        const attempt = new AbortController;
+        const remaining = Math.min(attemptBudget, Math.max(1, Math.ceil(deadline - performance.now())));
+        const attemptTimer = setTimeout(() => attempt.abort(new ToolboxError(`Redis connection attempt timed out (${transport.name})`, { kind: "timeout", code: "ETIMEDOUT" })), remaining);
+        const attemptSignal = AbortSignal.any([signal, attempt.signal]);
+        try {
+          const mapped = await abortable(transport.connect(endpoint), attemptSignal);
+          attemptSignal.throwIfAborted();
+          const pending = this.connectionFactory(endpoint, mapped, {
+            ...this.baseConfig,
+            ...credentials,
+            database,
+            connectTimeoutMs: remaining,
+            signal: this.#signal,
+            connectSignal: attemptSignal
+          });
+          const prepared = pending.then((connection2) => {
+            if (attemptSignal.aborted) {
+              connection2.close();
+              attemptSignal.throwIfAborted();
+            }
+            return connection2;
+          });
+          const connection = await abortable(prepared, attemptSignal);
+          this.lifecycle.onRoute?.({ transport: mapped.host === endpoint.host && mapped.port === endpoint.port ? "direct" : transport.name, reason });
+          return connection;
+        } catch (failure) {
+          signal.throwIfAborted();
+          const error = attemptSignal.aborted ? attemptSignal.reason : failure;
+          const network = isConnectionNetworkError(error) || error instanceof SocketClosedUnexpectedlyError || error instanceof ConnectionTimeoutError;
+          if (!network || index === this.#transports.length - 1)
+            throw error;
+          reason = error instanceof SocketClosedUnexpectedlyError ? "connection_lost" : error instanceof ConnectionTimeoutError ? "ETIMEDOUT" : String(error.code);
+        } finally {
+          clearTimeout(attemptTimer);
+        }
+      }
+      throw new Error("Redis requires a TCP transport");
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  close() {
+    return this.#closing ??= (async () => {
+      this.#controller.abort(new Error("Redis access is closed"));
+      const settled = await Promise.allSettled(this.#connections.values());
+      this.#connections.clear();
+      const errors = [];
+      for (const result of settled)
+        if (result.status === "fulfilled") {
+          try {
+            result.value.close();
+          } catch (error) {
+            errors.push(error);
+          }
+        }
+      if (errors.length)
+        throw new AggregateError(errors, "Redis connection cleanup failed");
+    })();
+  }
+}
+
+class RedisClient {
+  source;
+  lifecycle;
+  #controller = new AbortController;
+  signal;
+  #initialization;
+  #disposal;
+  #access;
+  #target;
+  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 () => {
+      this.#target = await this.source.resolve();
+      this.signal.throwIfAborted();
+      if (!this.source.transports.length || this.source.transports.some((transport) => transport.kind !== "tcp")) {
+        throw new Error("Redis requires TCP transports");
+      }
+      if (this.#target.clusterType === "cluster" && this.#target.database !== 0)
+        throw new Error("Redis Cluster requires database 0");
+      this.#access = new RedisAccess(this.source.transports, this.#target, undefined, { ...this.lifecycle, signal: this.signal });
+    })();
+  }
+  get access() {
+    this.signal.throwIfAborted();
+    if (!this.#access)
+      throw new Error("Redis client is not initialized");
+    return this.#access;
+  }
+  topology() {
+    return discoverRedisTopology(this.access, this.target);
+  }
+  get target() {
+    if (!this.#target)
+      throw new Error("Redis client is not initialized");
+    return this.#target;
+  }
+  dispose() {
+    return this.#disposal ??= (async () => {
+      this.#controller.abort(new Error("Redis client disposed"));
+      await this.#initialization?.catch(() => {});
+      await this.#access?.close();
+    })();
+  }
+}
+async function openRedis(source, lifecycle = {}) {
+  const client = new RedisClient(source, lifecycle);
+  try {
+    await client.initialize();
+  } catch (error) {
+    await client.dispose();
+    throw error;
+  }
+  lifecycle.onDispose?.(() => client.dispose());
+  return client;
+}
+
+export { parseRedisInfo, RedisConnection, RedisAccess, RedisClient, openRedis };

package/dist/kubernetes/client.d.ts

@@ -23,6 +23,10 @@ export declare class KubernetesClient implements Client {
      */
     get(ref: ResourceRef, options?: ResourceRequestOptions): Promise<import("./resources").Resource>;
     list(query: ResourceListQuery, options?: ResourceRequestOptions): Promise<import("./resources").ResourceList>;
+    /** Explicit root scope for Nodes and all-namespace lists; no default namespace is inserted.
+     * @spec This view borrows root transport, cancellation and cleanup just like namespace views.
+     */
+    clusterResources(): ResourceAccess;
     inNamespace(namespace: string): NamespaceResources;
     exec(namespace: string, target: ExecTarget, command: string[], options?: RunOptions): Promise<import("./executor").ExecResult>;
     forward(namespace: string, target: KubernetesEndpoint): Promise<import("./service-port-forward").ForwardedEndpoint>;

package/dist/kubernetes/client.js

@@ -1,13 +1,13 @@
 import {
   KubernetesClient
-} from "../chunk-8kts470p.js";
-import"../chunk-4ms037k2.js";
-import"../chunk-0s27bgga.js";
+} from "../chunk-c2n8zvyn.js";
 import"../chunk-2171tajs.js";
 import"../chunk-j46x7j7c.js";
 import"../chunk-6fnhzhdb.js";
+import"../chunk-4ms037k2.js";
 import"../chunk-ftkrjqkc.js";
 import"../chunk-shsabpc1.js";
+import"../chunk-0s27bgga.js";
 import"../chunk-a9htb6cr.js";
 import"../chunk-20kv4wc3.js";
 import"../chunk-v3hxvnrc.js";