@compforge/harness-toolbox 0.4.3 → 0.4.4

package/README.md

@@ -376,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-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/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";

package/dist/kubernetes/compute-model.d.ts

@@ -0,0 +1,115 @@
+import type { ErrorKind } from "../errors";
+/** CPU cores and bytes; never percentages or unitless Kubernetes quantity strings. */
+export interface ComputeQuantity {
+    cpu: number;
+    memory: number;
+}
+export interface ComputeIssue {
+    source: string;
+    kind: ErrorKind;
+    message: string;
+    code?: string | number;
+}
+export interface ComputeRead<T> {
+    status: "complete" | "partial" | "unavailable";
+    items: T[];
+    issues: ComputeIssue[];
+}
+export interface ComputeUsage extends ComputeQuantity {
+    timestamp: string;
+    window: string;
+}
+export interface NodeCompute {
+    name: string;
+    uid: string;
+    ready: boolean;
+    unschedulable: boolean;
+    capacity: ComputeQuantity;
+    allocatable: ComputeQuantity;
+}
+export interface PodCompute {
+    namespace: string;
+    name: string;
+    uid: string;
+    createdAt?: string;
+    node?: string;
+    phase: string;
+    ready: boolean;
+    restarts: number;
+    /** Steady-state application and native sidecar container names, for metrics coverage. */
+    containers: string[];
+    /** Spec-based effective requests, including init/sidecar peak, Pod-level overrides and overhead. */
+    requests: ComputeQuantity;
+    /** Sum/peak of declared limits, NOT an upper bound when containers have no limit. */
+    configuredLimits: ComputeQuantity;
+    /** Container counts, not cores/bytes; a Pod-level budget can still apply. */
+    containersWithoutLimits: {
+        cpu: number;
+        memory: number;
+    };
+}
+export interface NodeComputeUsage extends ComputeUsage {
+    name: string;
+}
+export interface PodComputeUsage extends ComputeUsage {
+    namespace: string;
+    name: string;
+    uid: string;
+}
+export interface PodComputeSummary {
+    pods: number;
+    activePods: number;
+    scheduledPods: number;
+    readyPods: number;
+    /** Active Pods only; unscheduled requests are demand, not allocated node capacity. */
+    requests: ComputeQuantity;
+    scheduledRequests: ComputeQuantity;
+    configuredLimits: ComputeQuantity;
+    /** Container counts, not cores/bytes; a Pod-level budget can still apply. */
+    containersWithoutLimits: {
+        cpu: number;
+        memory: number;
+    };
+}
+export interface ClusterCompute {
+    environment: string;
+    observedAt: string;
+    scope: "cluster";
+    nodes: ComputeRead<NodeCompute>;
+    pods: ComputeRead<PodCompute>;
+    usage: ComputeRead<NodeComputeUsage>;
+    /** Totals describe acquired evidence only; consult each read's coverage before claiming cluster totals. */
+    summary: {
+        capacity?: ComputeQuantity;
+        allocatable?: ComputeQuantity;
+        pods?: PodComputeSummary;
+        usage?: ComputeQuantity;
+    };
+}
+export interface WorkloadCompute {
+    environment: string;
+    observedAt: string;
+    /** Scope is exactly the supplied instance set, not a claim of complete Service discovery. */
+    scope: "instances";
+    workloads: readonly {
+        namespace: string;
+        workload: string;
+        pod: string;
+        uid: string;
+    }[];
+    pods: ComputeRead<PodCompute>;
+    usage: ComputeRead<PodComputeUsage>;
+    summary: {
+        pods?: PodComputeSummary;
+        usage?: ComputeQuantity;
+    };
+}
+export interface ComputeOptions {
+    environment: string;
+    signal?: AbortSignal;
+    /** Whole collection budget, including all pages and metrics reads. */
+    timeoutMs: number;
+    maxPods: number;
+    maxNodes: number;
+    pageSize: number;
+}

package/dist/kubernetes/compute-quantity.d.ts

@@ -0,0 +1,18 @@
+import type { ComputeQuantity, PodCompute, PodComputeSummary } from "./compute-model";
+import type { Resource } from "./resources";
+type ObjectValue = Record<string, unknown>;
+export declare function object(value: unknown): ObjectValue;
+export declare function requiredString(value: unknown, field: string): string;
+/**
+ * @why client-node 1.4 quantityToScalar uses BigInt for binary suffixes and rejects valid fractional Gi values.
+ * @spec Quantities normalize to cores/bytes; invalid or unrepresentable values never become zero usage.
+ */
+export declare function parseComputeQuantity(value: unknown): number;
+export declare const zero: () => ComputeQuantity;
+export declare function add(left: ComputeQuantity, right: ComputeQuantity): ComputeQuantity;
+export declare function quantities(value: unknown, required?: boolean): ComputeQuantity;
+export declare function sum(values: readonly ComputeQuantity[]): ComputeQuantity;
+/** Spec projection only: do not claim current cgroup allocation or scheduler admission headroom. */
+export declare function podCompute(value: Resource): PodCompute;
+export declare function summarizePods(pods: readonly PodCompute[]): PodComputeSummary;
+export {};

package/dist/kubernetes/compute-quantity.js

@@ -0,0 +1,23 @@
+import {
+  add,
+  object,
+  parseComputeQuantity,
+  podCompute,
+  quantities,
+  requiredString,
+  sum,
+  summarizePods,
+  zero
+} from "../chunk-5zgz1z41.js";
+import"../chunk-20kv4wc3.js";
+export {
+  zero,
+  summarizePods,
+  sum,
+  requiredString,
+  quantities,
+  podCompute,
+  parseComputeQuantity,
+  object,
+  add
+};

package/dist/kubernetes/compute.d.ts

@@ -0,0 +1,17 @@
+import type { WorkloadInstance } from "@compforge/harness-common";
+import type { ResourceAccess } from "./resources";
+import type { ClusterCompute, ComputeOptions, WorkloadCompute } from "./compute-model";
+export type * from "./compute-model";
+export { parseComputeQuantity } from "./compute-quantity";
+/**
+ * @spec Cluster reads are independent: forbidden Nodes/metrics are coverage gaps, not cluster-health failures.
+ * @rule access must be an explicit cluster-scoped view, e.g. KubernetesClient.clusterResources().
+ * No namespace fallback, client creation or cleanup occurs here.
+ */
+export declare function collectClusterCompute(access: ResourceAccess, options: ComputeOptions): Promise<ClusterCompute>;
+/**
+ * @spec Whole-Pod accounting deduplicates physical UID across Workload aliases and container defaults.
+ * @spec Only caller-supplied instances are read; cluster permissions are not needed.
+ * @rule The caller retains discovery coverage. This result never asserts that input covers all Service instances.
+ */
+export declare function collectWorkloadCompute(access: ResourceAccess, instances: readonly WorkloadInstance[], options: ComputeOptions): Promise<WorkloadCompute>;

package/dist/kubernetes/compute.js

@@ -0,0 +1,211 @@
+import {
+  object,
+  parseComputeQuantity,
+  podCompute,
+  quantities,
+  requiredString,
+  sum,
+  summarizePods
+} from "../chunk-5zgz1z41.js";
+import {
+  KubernetesError
+} from "../chunk-20kv4wc3.js";
+
+// src/kubernetes/compute.ts
+function requestBudget(options) {
+  if (!options.environment.trim() || [options.timeoutMs, options.maxPods, options.maxNodes, options.pageSize].some((value) => !Number.isSafeInteger(value) || value <= 0)) {
+    throw new KubernetesError("Compute requires environment and positive timeout/item/page budgets", { kind: "invalid_argument" });
+  }
+  const deadline = performance.now() + options.timeoutMs;
+  return () => {
+    options.signal?.throwIfAborted();
+    const remaining = Math.ceil(deadline - performance.now());
+    if (remaining <= 0)
+      throw new KubernetesError("Compute collection budget exhausted", { kind: "timeout" });
+    return { signal: options.signal, timeoutMs: remaining };
+  };
+}
+function issue(source, error) {
+  const kind = error instanceof KubernetesError ? error.kind : "operation_failed";
+  return {
+    source,
+    kind,
+    code: error instanceof KubernetesError ? error.code : undefined,
+    message: kind === "permission_denied" ? "Permission denied" : `Kubernetes compute read failed: ${kind}`
+  };
+}
+function finish(items, issues, observed) {
+  return { items, issues, status: !issues.length ? "complete" : observed ? "partial" : "unavailable" };
+}
+function gap(source, kind, message) {
+  return { source, kind, message };
+}
+async function readPages(access, query, maxItems, options, request, parse, identity) {
+  const source = `${query.apiVersion}/${query.resource}`;
+  const items = [], issues = [];
+  const tokens = new Set, identities = new Set;
+  let continuation, observed = false, read = 0;
+  try {
+    do {
+      const page = await access.list({ ...query, limit: Math.min(options.pageSize, maxItems - read), continue: continuation }, request());
+      if (!Array.isArray(page.items))
+        throw new KubernetesError("List lacks items", { kind: "invalid_response" });
+      observed = true;
+      for (const item of page.items.slice(0, maxItems - read)) {
+        try {
+          const parsed = parse(item), key = identity(parsed);
+          if (!identities.has(key)) {
+            items.push(parsed);
+            identities.add(key);
+          }
+        } catch (error) {
+          issues.push(issue(source, error));
+        }
+      }
+      read += page.items.length;
+      continuation = page.metadata?.continue || undefined;
+      if (read > maxItems || read >= maxItems && continuation) {
+        issues.push(gap(source, "limit_exceeded", `Collection limited to ${maxItems} items`));
+        break;
+      }
+      if (continuation && tokens.has(continuation)) {
+        issues.push(gap(source, "invalid_response", "Pagination did not advance"));
+        break;
+      }
+      if (continuation)
+        tokens.add(continuation);
+    } while (continuation);
+  } catch (error) {
+    options.signal?.throwIfAborted();
+    issues.push(issue(source, error));
+  }
+  return finish(items, issues, observed);
+}
+function nodeCompute(value) {
+  const meta = object(value.metadata), status = object(value.status), spec = object(value.spec);
+  const conditions = Array.isArray(status.conditions) ? status.conditions.map(object) : [];
+  return {
+    name: requiredString(meta.name, "node name"),
+    uid: requiredString(meta.uid, "node uid"),
+    ready: conditions.some((c) => c.type === "Ready" && c.status === "True"),
+    unschedulable: spec.unschedulable === true,
+    capacity: quantities(status.capacity, true),
+    allocatable: quantities(status.allocatable, true)
+  };
+}
+function usage(value) {
+  const timestamp = requiredString(value.timestamp, "metrics timestamp"), window = requiredString(value.window, "metrics window");
+  if (!Number.isFinite(Date.parse(timestamp)))
+    throw new KubernetesError("Invalid metrics timestamp", { kind: "invalid_response" });
+  return { ...quantities(value.usage, true), timestamp, window };
+}
+async function collectClusterCompute(access, options) {
+  const request = requestBudget(options);
+  const nodes = await readPages(access, { apiVersion: "v1", resource: "nodes" }, options.maxNodes, options, request, nodeCompute, (n) => n.uid);
+  const pods = await readPages(access, { apiVersion: "v1", resource: "pods" }, options.maxPods, options, request, podCompute, (p) => `${p.namespace}/${p.uid}`);
+  const metrics = await readPages(access, { apiVersion: "metrics.k8s.io/v1beta1", resource: "nodes" }, options.maxNodes, options, request, (item) => ({ ...usage(item), name: requiredString(item.metadata?.name, "metrics node name") }), (n) => n.name);
+  if (nodes.status !== "unavailable" && metrics.status !== "unavailable") {
+    const measured = new Set(metrics.items.map((item) => item.name));
+    for (const node of nodes.items)
+      if (!measured.has(node.name)) {
+        metrics.issues.push(gap(`nodes/${node.name}`, "resource_not_found", "Node has no metrics sample"));
+      }
+    if (metrics.issues.length)
+      metrics.status = "partial";
+  }
+  options.signal?.throwIfAborted();
+  return {
+    environment: options.environment,
+    observedAt: new Date().toISOString(),
+    scope: "cluster",
+    nodes,
+    pods,
+    usage: metrics,
+    summary: {
+      capacity: nodes.status !== "complete" && !nodes.items.length ? undefined : sum(nodes.items.map((n) => n.capacity)),
+      allocatable: nodes.status !== "complete" && !nodes.items.length ? undefined : sum(nodes.items.map((n) => n.allocatable)),
+      pods: pods.status !== "complete" && !pods.items.length ? undefined : summarizePods(pods.items),
+      usage: metrics.status === "unavailable" || !metrics.items.length && (metrics.status !== "complete" || nodes.status !== "complete" || nodes.items.length > 0) ? undefined : sum(metrics.items)
+    }
+  };
+}
+async function collectWorkloadCompute(access, instances, options) {
+  const request = requestBudget(options);
+  const selected = new Map;
+  for (const instance of instances) {
+    if (instance.environment !== options.environment) {
+      throw new KubernetesError("Compute instance belongs to a different environment", { kind: "invalid_argument" });
+    }
+    selected.set(JSON.stringify([instance.namespace, instance.pod, instance.uid]), instance);
+  }
+  const pods = [], metrics = [];
+  const podIssues = [], metricIssues = [];
+  if (selected.size > options.maxPods)
+    podIssues.push(gap("pods", "limit_exceeded", `Collection limited to ${options.maxPods} Pods`));
+  for (const instance of [...selected.values()].slice(0, options.maxPods)) {
+    const source = `pods/${instance.namespace}/${instance.pod}`;
+    let pod;
+    try {
+      pod = podCompute(await access.get({ apiVersion: "v1", resource: "pods", namespace: instance.namespace, name: instance.pod }, request()));
+      if (pod.uid !== instance.uid || pod.name !== instance.pod || pod.namespace !== instance.namespace) {
+        throw new KubernetesError("Pod identity changed after discovery", { kind: "invalid_response" });
+      }
+      pods.push(pod);
+    } catch (error) {
+      options.signal?.throwIfAborted();
+      podIssues.push(issue(source, error));
+      metricIssues.push(gap(source, "operation_failed", "Metrics not collected because Pod identity could not be verified"));
+      continue;
+    }
+    if (pod.phase === "Succeeded" || pod.phase === "Failed")
+      continue;
+    try {
+      const raw = await access.get({ apiVersion: "metrics.k8s.io/v1beta1", resource: "pods", namespace: pod.namespace, name: pod.name }, request());
+      if (raw.metadata?.name !== pod.name || raw.metadata?.namespace !== pod.namespace || !Array.isArray(raw.containers)) {
+        throw new KubernetesError("Pod metrics lacks identity or containers", { kind: "invalid_response" });
+      }
+      const names = raw.containers.map((c) => requiredString(object(c).name, "metrics container name"));
+      if (new Set(names).size !== names.length || pod.containers.some((name) => !names.includes(name))) {
+        throw new KubernetesError("Pod metrics does not cover its containers", { kind: "invalid_response" });
+      }
+      const values = raw.containers.map((c) => quantities(object(c).usage, true));
+      if (!values.length)
+        throw new KubernetesError("Empty Pod metrics", { kind: "invalid_response" });
+      const measured = {
+        ...usage({ ...raw, usage: { cpu: String(sum(values).cpu), memory: String(sum(values).memory) } }),
+        namespace: pod.namespace,
+        name: pod.name,
+        uid: pod.uid
+      };
+      if (raw.metadata.uid && raw.metadata.uid !== pod.uid || pod.createdAt && Date.parse(measured.timestamp) < Date.parse(pod.createdAt)) {
+        throw new KubernetesError("Pod metrics precedes current Pod incarnation", { kind: "invalid_response" });
+      }
+      metrics.push(measured);
+    } catch (error) {
+      options.signal?.throwIfAborted();
+      metricIssues.push(issue(`metrics/${source}`, error));
+    }
+  }
+  if (selected.size > options.maxPods)
+    metricIssues.push(gap("metrics/pods", "limit_exceeded", "Metrics limited to collected Pods"));
+  options.signal?.throwIfAborted();
+  const podRead = finish(pods, podIssues, pods.length > 0 || !selected.size);
+  const metricRead = finish(metrics, metricIssues, metrics.length > 0 || !podIssues.length && pods.every((p) => p.phase === "Succeeded" || p.phase === "Failed"));
+  return {
+    environment: options.environment,
+    observedAt: new Date().toISOString(),
+    scope: "instances",
+    workloads: instances.map(({ namespace, workload, pod, uid }) => ({ namespace, workload, pod, uid })),
+    pods: podRead,
+    usage: metricRead,
+    summary: {
+      pods: podRead.status === "unavailable" ? undefined : summarizePods(pods),
+      usage: metricRead.status === "unavailable" ? undefined : sum(metrics)
+    }
+  };
+}
+export {
+  parseComputeQuantity,
+  collectWorkloadCompute,
+  collectClusterCompute
+};

package/dist/kubernetes/environment.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 {
   clientKey
 } from "../chunk-a9htb6cr.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compforge/harness-toolbox",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Shared infrastructure clients, transports and bounded data capture",
   "type": "module",
   "scripts": {
@@ -116,6 +116,9 @@
     "@types/node": "^22",
     "@types/ws": "^8.18.1"
   },
+  "overrides": {
+    "@compforge/harness-common": "file:../common"
+  },
   "publishConfig": {
     "access": "public"
   },