@compforge/harness-toolbox 0.4.2 → 0.4.4

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/dist/redis/client.d.ts

@@ -1,6 +1,7 @@
 import type { Client } from "../client";
 import type { ConnectionSource, ClientLifecycle } from "../datasource";
-import type { TcpTransport } from "../transport";
+import { type TcpTransport } from "../transport";
+import { type RedisTopologyConfig, type RedisTopology } from "./topology";
 import { createClient, type RedisClientType } from "@redis/client";
 export interface RedisEndpoint {
     host: string;
@@ -17,6 +18,10 @@ export interface RedisConnectionConfig extends RedisCredentials {
     database: number;
     useSsl: boolean;
     timeoutMs: number;
+    /** Per-route mapping and handshake budget; defaults to timeoutMs. */
+    connectTimeoutMs?: number;
+    /** Total acquisition budget; defaults to connectTimeoutMs times the number of routes. */
+    acquireTimeoutMs?: number;
 }
 export type RedisEndpointMapper = (endpoint: RedisEndpoint) => Promise<RedisMappedEndpoint>;
 type NodeRedisClient = RedisClientType;
@@ -25,7 +30,10 @@ export interface RedisManagedConnection extends RedisConnectionApi {
     readonly isReady: boolean;
     close(): void;
 }
-export type RedisConnectionFactory = (endpoint: RedisEndpoint, mapped: RedisMappedEndpoint, config: RedisConnectionConfig) => Promise<RedisManagedConnection>;
+export type RedisConnectionFactory = (endpoint: RedisEndpoint, mapped: RedisMappedEndpoint, config: RedisConnectionConfig & {
+    signal?: AbortSignal;
+    connectSignal?: AbortSignal;
+}) => Promise<RedisManagedConnection>;
 /** Redis INFO wire 文本解析；协议适配留在 infra，领域层只接收结构化字段。 */
 export declare function parseRedisInfo(raw: string): Record<string, unknown>;
 export interface RedisConnectionApi {
@@ -44,14 +52,19 @@ export interface RedisAccessApi {
     connection(endpoint: RedisEndpoint, database: number, credentials?: RedisCredentials): Promise<RedisConnectionApi>;
     close(): Promise<void>;
 }
+/** @spec A command is sent once; a later operation may acquire a new connection after failure. */
 export declare class RedisConnection implements RedisManagedConnection {
     #private;
     readonly endpoint: RedisEndpoint;
     private readonly client;
     private readonly timeoutMs;
     private readonly lastError;
+    private readonly signal?;
     private constructor();
-    static connect(endpoint: RedisEndpoint, mapped: RedisMappedEndpoint, config: RedisConnectionConfig, clientFactory?: NodeRedisClientFactory): Promise<RedisConnection>;
+    static connect(endpoint: RedisEndpoint, mapped: RedisMappedEndpoint, config: RedisConnectionConfig & {
+        signal?: AbortSignal;
+        connectSignal?: AbortSignal;
+    }, clientFactory?: NodeRedisClientFactory): Promise<RedisConnection>;
     get isReady(): boolean;
     ping(): Promise<string>;
     info(section?: string): Promise<Record<string, unknown>>;
@@ -64,25 +77,31 @@ export declare class RedisConnection implements RedisManagedConnection {
     }>;
     close(): void;
 }
+/**
+ * @spec Only connection establishment can advance to another transport; protocol operations are never replayed.
+ * @why Every topology node needs the same route policy, credentials, deadline and root cancellation.
+ */
 export declare class RedisAccess implements RedisAccessApi {
     #private;
-    private readonly transport;
     private readonly baseConfig;
     private readonly connectionFactory;
-    constructor(transport: TcpTransport, baseConfig: Omit<RedisConnectionConfig, "database">, connectionFactory?: RedisConnectionFactory);
+    private readonly lifecycle;
+    constructor(transports: TcpTransport | readonly TcpTransport[], baseConfig: Omit<RedisConnectionConfig, "database">, connectionFactory?: RedisConnectionFactory, lifecycle?: ClientLifecycle);
     connection(endpoint: RedisEndpoint, database: number, credentials?: RedisCredentials): Promise<RedisManagedConnection>;
     close(): Promise<void>;
 }
-export interface RedisDataSourceTarget extends RedisConnectionConfig {
-    endpoints: RedisEndpoint[];
-}
+/** Connection configuration includes topology; diagnostics do not need a second target model. */
+export type RedisDataSourceTarget = RedisConnectionConfig & RedisTopologyConfig;
 export declare class RedisClient implements Client {
     #private;
     private readonly source;
+    private readonly lifecycle;
     readonly signal: AbortSignal;
     constructor(source: ConnectionSource<RedisDataSourceTarget>, lifecycle?: ClientLifecycle);
     initialize(): Promise<void>;
     get access(): RedisAccess;
+    /** Refresh topology for this observation, while retaining reusable node connections. */
+    topology(): Promise<RedisTopology>;
     get target(): RedisDataSourceTarget;
     dispose(): Promise<void>;
 }

package/dist/redis/client.js

@@ -4,7 +4,15 @@ import {
   RedisConnection,
   openRedis,
   parseRedisInfo
-} from "../chunk-ajhdd4hp.js";
+} from "../chunk-yp6tcw22.js";
+import"../chunk-5tbzf9wd.js";
+import"../chunk-20kv4wc3.js";
+import"../chunk-h8fwx0k7.js";
+import"../chunk-wv4jwhvj.js";
+import"../chunk-631vce5z.js";
+import"../chunk-hmah9t8e.js";
+import"../chunk-mn6dwsvh.js";
+import"../chunk-ssj93brx.js";
 export {
   parseRedisInfo,
   openRedis,

package/dist/redis/index.js

@@ -2,16 +2,23 @@ import {
   collectRedisKeyStats,
   redisGroupedSampleSizes
 } from "../chunk-jr9y0ghr.js";
-import {
-  discoverRedisTopology
-} from "../chunk-c6z919qb.js";
 import {
   RedisAccess,
   RedisClient,
   RedisConnection,
   openRedis,
   parseRedisInfo
-} from "../chunk-ajhdd4hp.js";
+} from "../chunk-yp6tcw22.js";
+import {
+  discoverRedisTopology
+} from "../chunk-5tbzf9wd.js";
+import"../chunk-20kv4wc3.js";
+import"../chunk-h8fwx0k7.js";
+import"../chunk-wv4jwhvj.js";
+import"../chunk-631vce5z.js";
+import"../chunk-hmah9t8e.js";
+import"../chunk-mn6dwsvh.js";
+import"../chunk-ssj93brx.js";
 export {
   redisGroupedSampleSizes,
   parseRedisInfo,

package/dist/redis/topology.d.ts

@@ -1,13 +1,16 @@
 import type { RedisAccessApi, RedisCredentials, RedisEndpoint } from "./client";
-export interface RedisTopologyConfig extends RedisCredentials {
+/** Endpoints are standalone/cluster seeds or Sentinel seeds according to clusterType. */
+export type RedisTopologyConfig = RedisCredentials & {
     endpoints: RedisEndpoint[];
     database: number;
-    clusterType: "single" | "sentinel" | "cluster";
-    sentinelHosts: RedisEndpoint[];
+} & ({
+    clusterType: "single" | "cluster";
+} | {
+    clusterType: "sentinel";
     sentinelMasterName: string;
     sentinelUsername?: string;
     sentinelPassword?: string;
-}
+});
 export interface RedisSlotRange {
     start: number;
     end: number;

package/dist/redis/topology.js

@@ -1,6 +1,6 @@
 import {
   discoverRedisTopology
-} from "../chunk-c6z919qb.js";
+} from "../chunk-5tbzf9wd.js";
 export {
   discoverRedisTopology
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compforge/harness-toolbox",
-  "version": "0.4.2",
+  "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"
   },