@camstack/addon-pipeline 1.2.191 → 1.2.193

package/dist/pipeline-runner/index.mjs

@@ -1,62 +1,17 @@
-import { B as defineCustomActions, Bt as nodePin, Ft as createEvent, Gt as _enum, H as deriveDetailCropRect, Kt as array, L as customAction, Qt as object, X as failureContributionCapability, Xt as literal, Yt as lazy, Zt as number, _ as FailureCounters, en as string, et as loadContributionCapability, ft as pipelineRunnerCapability, jt as BaseAddon, lt as pickDetailCropConvention, m as DEVICE_BACKEND_TO_FORMAT, nn as EventCategory, p as DEFAULT_NATIVE_LEASE_SETTINGS, qt as boolean, u as DEFAULT_DETAIL_CROP_CONVENTION, ut as pickNativeLeaseOverride, wt as errMsg } from "../dist-Cjazw3T-.mjs";
-import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-KFUZT2L-.mjs";
-import { c as getStepDefinition, n as resolveFrameViewGeometry, t as localFrameRegistry } from "../local-frame-registry-CrLITJ5O.mjs";
-import { a as nativeLeaseSettingEnv, t as isWorkerReply } from "../worker-protocol-n4hf2NsC.mjs";
+import { $t as number, Et as errMsg, Ht as nodePin, Jt as array, Lt as createEvent, Nt as BaseAddon, Qt as literal, R as customAction, U as deriveDetailCropRect, V as defineCustomActions, Yt as boolean, Z as failureContributionCapability, Zt as lazy, _ as FailureCounters, dt as pickNativeLeaseOverride, en as object, in as EventCategory, m as DEVICE_BACKEND_TO_FORMAT, nn as string, p as DEFAULT_NATIVE_LEASE_SETTINGS, pt as pipelineRunnerCapability, qt as _enum, tt as loadContributionCapability, u as DEFAULT_DETAIL_CROP_CONVENTION, ut as pickDetailCropConvention } from "../dist-mYDK58Jp.mjs";
+import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-xRsaPwBa.mjs";
+import { c as getStepDefinition, n as resolveFrameViewGeometry, t as localFrameRegistry } from "../local-frame-registry-av9ObDG0.mjs";
+import { a as nativeLeaseSettingEnv, t as isWorkerReply } from "../worker-protocol-C0R1DDC0.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { n as withDetectionIntent } from "../restream-intent-B4BXZra7.mjs";
 import { t as attributeStall } from "../event-loop-stall-monitor-DXLNBMkY.mjs";
 import { n as profileForStreamId, t as isRemoteRestream } from "../remote-restream-BeHi78PZ.mjs";
+import * as os from "node:os";
 import { fork } from "node:child_process";
 import sharp from "sharp";
 import { fileURLToPath } from "node:url";
 import { PerformanceObserver } from "node:perf_hooks";
-import * as os from "node:os";
-//#region src/pipeline-runner/first-detection-frame.ts
-/**
-* How long a camera waits, after `attachCamera`, before a decoded frame
-* actually reaches the detection queue.
-*
-* The orchestrator already measures `session motion → attach latency` and it
-* is small — 11, 13 and 18 ms across three consecutive sessions on the same
-* camera. What nothing measured is the NEXT leg: from the attach to the first
-* frame the detector is given. An operator reporting "detection starts late"
-* is describing that leg, and answering them required reading the timestamps
-* of unrelated INFO lines and inferring — which produced a wrong first answer
-* (the absence of a `frame processed` line means the frame produced nothing
-* notable, not that no frame arrived).
-*
-* One number, once per attach, so a slow start is a value rather than an
-* inference.
-*/
-/** Pending attach marks, keyed by device. */
-var FirstDetectionFrameTimer = class {
-	attachedAt = /* @__PURE__ */ new Map();
-	/** A camera attached. Replaces any pending mark: the newest attach is the
-	*  one the next frame belongs to. */
-	markAttached(deviceId, nowMs) {
-		this.attachedAt.set(deviceId, nowMs);
-	}
-	/**
-	* A decoded frame was admitted to the detection queue. Returns the elapsed
-	* ms since the attach the FIRST time it is called after one, and `null`
-	* every time after — so the caller logs once per attach, not once per frame.
-	*/
-	takeLatency(deviceId, nowMs) {
-		const at = this.attachedAt.get(deviceId);
-		if (at === void 0) return null;
-		this.attachedAt.delete(deviceId);
-		return Math.max(0, nowMs - at);
-	}
-	/** A camera detached with no frame ever admitted — drop the mark so the
-	*  NEXT attach is not measured from this one. Returns whether one was
-	*  pending, which is itself the interesting fact: a session that ran and
-	*  fed the detector nothing. */
-	forget(deviceId) {
-		return this.attachedAt.delete(deviceId);
-	}
-};
-//#endregion
 //#region src/session-decode/fork-decode-worker.ts
 /** Absolute path to the built decode-worker child entry (a vite build entry). */
 var CHILD_ENTRY_PATH = fileURLToPath(new URL("../session-decode/decode-worker-child.js", import.meta.url));
@@ -521,6 +476,57 @@ var NativeCropRegistry = class {
 	}
 };
 //#endregion
+//#region src/session-decode/node-decode-budget.ts
+/**
+* The decode RAM budget and worker cap THIS node runs under.
+*
+* `nodeDecodeBudgetMb` and `maxLiveDecodeWorkers` are cluster settings — one
+* number for a 64 GB hub and a 16 GB Mac alike. Until 2026-09-05 the shipped
+* 8192 MB was the hub's number applied everywhere; with the footprint fixed
+* (D361) that admits 8 workers on the Mac, whose workers measure RSS p90
+* 952 MB on a machine already at 80% — 7.6 GB of decode on 16 GB is a swap
+* away from a stall — while the hub leaves 56 GB idle.
+*
+* Three sources, in order, and the winner is NAMED so a log line can say why:
+*  1. the node's own agent setting (`decodeBudgetMb` / `maxLiveDecodeWorkers`
+*     in `AgentPipelineSettings`) — the operator sized this node;
+*  2. the cluster setting when the operator MOVED it off the shipped default
+*     (a value equal to the default reads as "nobody chose", the same rule the
+*     native-lease knobs use, `readKnob`);
+*  3. otherwise a share of the node's RAM, clamped — the shipped default
+*     becomes a per-node derivation instead of the hub's number.
+*/
+var DECODE_BUDGET_RAM_SHARE = .5;
+var DECODE_BUDGET_MIN_MB = 2048;
+var DECODE_BUDGET_MAX_MB = 16384;
+function derivedDecodeBudgetMb(totalMemMb) {
+	const share = Math.round(totalMemMb * DECODE_BUDGET_RAM_SHARE);
+	return Math.max(DECODE_BUDGET_MIN_MB, Math.min(DECODE_BUDGET_MAX_MB, share));
+}
+function resolveNodeDecodeLimits(input) {
+	const budget = input.node.decodeBudgetMb !== void 0 ? {
+		budgetMb: input.node.decodeBudgetMb,
+		budgetSource: "node"
+	} : input.clusterBudgetMb !== input.defaultBudgetMb ? {
+		budgetMb: input.clusterBudgetMb,
+		budgetSource: "cluster"
+	} : {
+		budgetMb: derivedDecodeBudgetMb(input.totalMemMb),
+		budgetSource: "derived"
+	};
+	const workers = input.node.maxLiveDecodeWorkers !== void 0 ? {
+		maxWorkers: input.node.maxLiveDecodeWorkers,
+		maxWorkersSource: "node"
+	} : {
+		maxWorkers: input.clusterMaxWorkers,
+		maxWorkersSource: "cluster"
+	};
+	return {
+		...budget,
+		...workers
+	};
+}
+//#endregion
 //#region src/session-decode/retained-content-fallback.ts
 /**
 * Honest ≤640 RAM fallback for `getNativeCrop` full-frame misses.
@@ -922,55 +928,6 @@ function cropRgb(frame, bbox, maxWidth) {
 	};
 }
 //#endregion
-//#region src/pipeline-runner/frame-cutter-binding.ts
-/** The per-frame binding key — the same identity the retention handle carries. */
-function frameCutterKey(handle) {
-	return `${handle.shmId}#${handle.slot}#${handle.seq}`;
-}
-var FrameCutterBinding = class {
-	max;
-	map = /* @__PURE__ */ new Map();
-	constructor(max) {
-		this.max = max;
-	}
-	/** Bind at delivery. Re-binding the same handle replaces without stranding the first. */
-	bind(handle, cutter) {
-		const key = frameCutterKey(handle);
-		this.map.delete(key);
-		this.map.set(key, cutter);
-		while (this.map.size > this.max) {
-			const oldest = this.map.keys().next().value;
-			if (oldest === void 0) break;
-			const stale = this.map.get(oldest);
-			this.map.delete(oldest);
-			release(stale);
-		}
-	}
-	/** Consume the binding for a frame whose result arrived. `undefined` when already ended. */
-	take(handle) {
-		const key = frameCutterKey(handle);
-		const cutter = this.map.get(key);
-		this.map.delete(key);
-		return cutter;
-	}
-	/**
-	* End the hold of a frame the runner let go without a result. A no-op for a
-	* frame whose result already consumed the binding, so the two paths cannot
-	* double-release.
-	*/
-	drop(handle) {
-		release(this.take(handle));
-	}
-	get size() {
-		return this.map.size;
-	}
-};
-function release(cutter) {
-	try {
-		cutter?.release();
-	} catch {}
-}
-//#endregion
 //#region src/session-decode/session-decode-coordinator.ts
 /** How long to wait after `kill()` before escalating to `kill('SIGKILL')`. */
 var SIGKILL_FALLBACK_MS = 1e3;
@@ -2920,6 +2877,168 @@ function summarizeDeviceLoad(attachedDeviceKeys) {
 	})).toSorted((a, b) => a.deviceKey.localeCompare(b.deviceKey));
 }
 //#endregion
+//#region src/pipeline-runner/failure-report.ts
+/**
+* What `pipeline-runner` reports through `failure-contribution` — the inference
+* deadline, per camera, with the frames that made it as the denominator.
+*
+* ## The number that was never divided
+*
+* ~120 `inference timed out — permit released, result discarded` lines in six
+* hours across seven cameras, on 2026-08-28, never investigated. The line has
+* carried `tags: { deviceId }` for a while, so the count per camera was always
+* available; what was not available was the number to divide it by. 120
+* timeouts out of 120 000 admitted frames and 120 out of 1 200 are opposite
+* findings and produce identical log volume.
+*
+* So the counter takes BOTH outcomes of the same await, from the same place in
+* `awaitInferenceBounded`. A success counted anywhere else would eventually
+* drift from the failure and turn the ratio into fiction.
+*
+* ## Why there is no `variant` yet
+*
+* `failure-contribution` has a `variant` slot exactly so "which camera AND
+* which model" is one read, and the operator asked for it. The runner cannot
+* fill it honestly: `awaitInferenceBounded` wraps
+* `config.processFrame(deviceId, frameInput, executorHandle)`, which runs the
+* camera's WHOLE pipeline graph behind one deadline. Nothing at this seam knows
+* which step was still running when the 20 s expired — `CameraRegistration`
+* carries fps and mode, not models.
+*
+* Naming the step means the executor attributing the deadline to the step that
+* held it, and reporting THAT. Emitting a `variant` the runner guessed (the
+* camera's configured graph id, say) would be worse than leaving it absent: it
+* would look like an attribution and be a label. Absent, never invented — the
+* same rule `load-contribution` states for a measurement nobody made.
+*/
+/** One bounded inference deadline per admitted detection frame. */
+var FAMILY_INFERENCE = "inference";
+/** The call did not return inside `inferenceTimeoutMs`. */
+var REASON_INFERENCE_TIMEOUT = "timeout";
+/**
+* The runner's `failure-contribution` counters.
+*
+* One instance per runner process, read (never drained) by the provider.
+*/
+var RunnerFailureReport = class {
+	now;
+	counters;
+	constructor(now = Date.now, counters = new FailureCounters()) {
+		this.now = now;
+		this.counters = counters;
+	}
+	/** One bounded inference call. `reason` absent = it returned in time. */
+	noteInference(deviceId, reason) {
+		this.counters.note({
+			deviceId,
+			family: FAMILY_INFERENCE,
+			...reason !== void 0 ? { reason } : {}
+		}, this.now());
+	}
+	/** The `failure-contribution` provider's payload. Reads, never resets. */
+	list() {
+		return this.counters.snapshot(this.now());
+	}
+	/** Addon disposal. */
+	clear() {
+		this.counters.clear();
+	}
+};
+//#endregion
+//#region src/pipeline-runner/first-detection-frame.ts
+/**
+* How long a camera waits, after `attachCamera`, before a decoded frame
+* actually reaches the detection queue.
+*
+* The orchestrator already measures `session motion → attach latency` and it
+* is small — 11, 13 and 18 ms across three consecutive sessions on the same
+* camera. What nothing measured is the NEXT leg: from the attach to the first
+* frame the detector is given. An operator reporting "detection starts late"
+* is describing that leg, and answering them required reading the timestamps
+* of unrelated INFO lines and inferring — which produced a wrong first answer
+* (the absence of a `frame processed` line means the frame produced nothing
+* notable, not that no frame arrived).
+*
+* One number, once per attach, so a slow start is a value rather than an
+* inference.
+*/
+/** Pending attach marks, keyed by device. */
+var FirstDetectionFrameTimer = class {
+	attachedAt = /* @__PURE__ */ new Map();
+	/** A camera attached. Replaces any pending mark: the newest attach is the
+	*  one the next frame belongs to. */
+	markAttached(deviceId, nowMs) {
+		this.attachedAt.set(deviceId, nowMs);
+	}
+	/**
+	* A decoded frame was admitted to the detection queue. Returns the elapsed
+	* ms since the attach the FIRST time it is called after one, and `null`
+	* every time after — so the caller logs once per attach, not once per frame.
+	*/
+	takeLatency(deviceId, nowMs) {
+		const at = this.attachedAt.get(deviceId);
+		if (at === void 0) return null;
+		this.attachedAt.delete(deviceId);
+		return Math.max(0, nowMs - at);
+	}
+	/** A camera detached with no frame ever admitted — drop the mark so the
+	*  NEXT attach is not measured from this one. Returns whether one was
+	*  pending, which is itself the interesting fact: a session that ran and
+	*  fed the detector nothing. */
+	forget(deviceId) {
+		return this.attachedAt.delete(deviceId);
+	}
+};
+//#endregion
+//#region src/pipeline-runner/frame-cutter-binding.ts
+/** The per-frame binding key — the same identity the retention handle carries. */
+function frameCutterKey(handle) {
+	return `${handle.shmId}#${handle.slot}#${handle.seq}`;
+}
+var FrameCutterBinding = class {
+	max;
+	map = /* @__PURE__ */ new Map();
+	constructor(max) {
+		this.max = max;
+	}
+	/** Bind at delivery. Re-binding the same handle replaces without stranding the first. */
+	bind(handle, cutter) {
+		const key = frameCutterKey(handle);
+		this.map.delete(key);
+		this.map.set(key, cutter);
+		while (this.map.size > this.max) {
+			const oldest = this.map.keys().next().value;
+			if (oldest === void 0) break;
+			const stale = this.map.get(oldest);
+			this.map.delete(oldest);
+			release(stale);
+		}
+	}
+	/** Consume the binding for a frame whose result arrived. `undefined` when already ended. */
+	take(handle) {
+		const key = frameCutterKey(handle);
+		const cutter = this.map.get(key);
+		this.map.delete(key);
+		return cutter;
+	}
+	/**
+	* End the hold of a frame the runner let go without a result. A no-op for a
+	* frame whose result already consumed the binding, so the two paths cannot
+	* double-release.
+	*/
+	drop(handle) {
+		release(this.take(handle));
+	}
+	get size() {
+		return this.map.size;
+	}
+};
+function release(cutter) {
+	try {
+		cutter?.release();
+	} catch {}
+}
+//#endregion
 //#region src/pipeline-runner/frame-lazy-metrics.ts
 function emptyFrameLazyCounters() {
 	return {
@@ -3492,57 +3611,6 @@ var NodeDecodeLimitsSource = class {
 	}
 };
 //#endregion
-//#region src/session-decode/node-decode-budget.ts
-/**
-* The decode RAM budget and worker cap THIS node runs under.
-*
-* `nodeDecodeBudgetMb` and `maxLiveDecodeWorkers` are cluster settings — one
-* number for a 64 GB hub and a 16 GB Mac alike. Until 2026-09-05 the shipped
-* 8192 MB was the hub's number applied everywhere; with the footprint fixed
-* (D361) that admits 8 workers on the Mac, whose workers measure RSS p90
-* 952 MB on a machine already at 80% — 7.6 GB of decode on 16 GB is a swap
-* away from a stall — while the hub leaves 56 GB idle.
-*
-* Three sources, in order, and the winner is NAMED so a log line can say why:
-*  1. the node's own agent setting (`decodeBudgetMb` / `maxLiveDecodeWorkers`
-*     in `AgentPipelineSettings`) — the operator sized this node;
-*  2. the cluster setting when the operator MOVED it off the shipped default
-*     (a value equal to the default reads as "nobody chose", the same rule the
-*     native-lease knobs use, `readKnob`);
-*  3. otherwise a share of the node's RAM, clamped — the shipped default
-*     becomes a per-node derivation instead of the hub's number.
-*/
-var DECODE_BUDGET_RAM_SHARE = .5;
-var DECODE_BUDGET_MIN_MB = 2048;
-var DECODE_BUDGET_MAX_MB = 16384;
-function derivedDecodeBudgetMb(totalMemMb) {
-	const share = Math.round(totalMemMb * DECODE_BUDGET_RAM_SHARE);
-	return Math.max(DECODE_BUDGET_MIN_MB, Math.min(DECODE_BUDGET_MAX_MB, share));
-}
-function resolveNodeDecodeLimits(input) {
-	const budget = input.node.decodeBudgetMb !== void 0 ? {
-		budgetMb: input.node.decodeBudgetMb,
-		budgetSource: "node"
-	} : input.clusterBudgetMb !== input.defaultBudgetMb ? {
-		budgetMb: input.clusterBudgetMb,
-		budgetSource: "cluster"
-	} : {
-		budgetMb: derivedDecodeBudgetMb(input.totalMemMb),
-		budgetSource: "derived"
-	};
-	const workers = input.node.maxLiveDecodeWorkers !== void 0 ? {
-		maxWorkers: input.node.maxLiveDecodeWorkers,
-		maxWorkersSource: "node"
-	} : {
-		maxWorkers: input.clusterMaxWorkers,
-		maxWorkersSource: "cluster"
-	};
-	return {
-		...budget,
-		...workers
-	};
-}
-//#endregion
 //#region src/session-decode/on-demand-jpeg-fallback.ts
 /** Single content-sized JPEG requested after a detection, never a continuous raw. */
 var ON_DEMAND_JPEG_VIEW = {
@@ -3888,74 +3956,6 @@ function packageZoneUnion(polygons) {
 	};
 }
 //#endregion
-//#region src/pipeline-runner/failure-report.ts
-/**
-* What `pipeline-runner` reports through `failure-contribution` — the inference
-* deadline, per camera, with the frames that made it as the denominator.
-*
-* ## The number that was never divided
-*
-* ~120 `inference timed out — permit released, result discarded` lines in six
-* hours across seven cameras, on 2026-08-28, never investigated. The line has
-* carried `tags: { deviceId }` for a while, so the count per camera was always
-* available; what was not available was the number to divide it by. 120
-* timeouts out of 120 000 admitted frames and 120 out of 1 200 are opposite
-* findings and produce identical log volume.
-*
-* So the counter takes BOTH outcomes of the same await, from the same place in
-* `awaitInferenceBounded`. A success counted anywhere else would eventually
-* drift from the failure and turn the ratio into fiction.
-*
-* ## Why there is no `variant` yet
-*
-* `failure-contribution` has a `variant` slot exactly so "which camera AND
-* which model" is one read, and the operator asked for it. The runner cannot
-* fill it honestly: `awaitInferenceBounded` wraps
-* `config.processFrame(deviceId, frameInput, executorHandle)`, which runs the
-* camera's WHOLE pipeline graph behind one deadline. Nothing at this seam knows
-* which step was still running when the 20 s expired — `CameraRegistration`
-* carries fps and mode, not models.
-*
-* Naming the step means the executor attributing the deadline to the step that
-* held it, and reporting THAT. Emitting a `variant` the runner guessed (the
-* camera's configured graph id, say) would be worse than leaving it absent: it
-* would look like an attribution and be a label. Absent, never invented — the
-* same rule `load-contribution` states for a measurement nobody made.
-*/
-/** One bounded inference deadline per admitted detection frame. */
-var FAMILY_INFERENCE = "inference";
-/** The call did not return inside `inferenceTimeoutMs`. */
-var REASON_INFERENCE_TIMEOUT = "timeout";
-/**
-* The runner's `failure-contribution` counters.
-*
-* One instance per runner process, read (never drained) by the provider.
-*/
-var RunnerFailureReport = class {
-	now;
-	counters;
-	constructor(now = Date.now, counters = new FailureCounters()) {
-		this.now = now;
-		this.counters = counters;
-	}
-	/** One bounded inference call. `reason` absent = it returned in time. */
-	noteInference(deviceId, reason) {
-		this.counters.note({
-			deviceId,
-			family: FAMILY_INFERENCE,
-			...reason !== void 0 ? { reason } : {}
-		}, this.now());
-	}
-	/** The `failure-contribution` provider's payload. Reads, never resets. */
-	list() {
-		return this.counters.snapshot(this.now());
-	}
-	/** Addon disposal. */
-	clear() {
-		this.counters.clear();
-	}
-};
-//#endregion
 //#region src/pipeline-runner/frame-governor.ts
 var FrameGovernor = class {
 	config;
@@ -5265,6 +5265,40 @@ function isUsable(bbox) {
 //#endregion
 //#region src/pipeline-runner/index.ts
 /**
+* addon-pipeline-runner — per-node detection scheduler.
+*
+* Lives on every "vision node" (hub if hub is one, every agent that runs
+* decoders/cameras). Receives camera assignments from the hub-side
+* `addon-pipeline-orchestrator` via cap calls, owns the per-camera frame
+* queues + semaphore + motion → detection phase machine, calls the local
+* `motion-detection` and `pipeline-executor` capabilities for the actual
+* work, and emits typed events on the bus
+* (`detection.motion-analysis`, `pipeline.inference-result`, `pipeline.trace`).
+*
+* Design notes:
+*
+*  - All cap inputs/outputs are serializable so the runner is transparently
+*    routable across the cluster: when the runner is co-located with the
+*    broker/decoder/motion/detection (the default and recommended deploy),
+*    capability lookups return live singletons and frame data never crosses
+*    a process boundary. When a deploy splits the runner from the executor
+*    (rare), the lookup returns null and the runner falls back to
+*    `this.ctx.api` (broker proxy) at the cost of serialization.
+*
+*  - The scheduler core (`PipelineRunner`) is callback-driven and framework
+*    agnostic. The addon class injects the inference + motion callbacks at
+*    construction time, capturing references to the relevant providers
+*    lazily on each invocation.
+*
+*  - Result post-processing (analysis pipeline, class filters, notifications)
+*    is intentionally NOT done by the runner. The runner emits the raw
+*    inference output as a `pipeline.inference-result` event on the bus;
+*    a hub-side subscriber consumes the event and runs the post-processing
+*    pipeline. This keeps the runner stateless w.r.t. detection-side
+*    business logic and makes it possible to deploy the post-processor
+*    independently from the inference workers.
+*/
+/**
 * How often a device's package zone-union geometry is re-read. An operator
 * redrawing a package zone takes effect within one interval; the read is a
 * cross-addon cap call reached from the per-frame package gate, so it must be
@@ -7823,6 +7857,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 								workerToRunnerBytes: 0
 							});
 							const admitted = current.detection && runner.enqueueReservedDetectionFrame(config.deviceId, frame, handle);
+							if (admitted) nativeCrop?.markInferred();
 							if (current.motion) {
 								const motion = await resolveMotionFrameView(localFrameRegistry, frame.frameRef);
 								if (motion.kind === "view") runner.enqueueMotionFrame(config.deviceId, {
@@ -7834,7 +7869,6 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 									capturedAt: frame.capturedAt
 								}, void 0);
 							}
-							if (admitted) nativeCrop?.markInferred();
 							return admitted;
 						}
 					} : { inlineViewSpec: SPLIT_DETECTION_VIEW },

package/dist/{process-memory-BgX9_XQ5.mjs → process-memory-BDHR3lxe.mjs}

@@ -1,4 +1,4 @@
-import { ot as parseProcStatus } from "./dist-Cjazw3T-.mjs";
+import { st as parseProcStatus } from "./dist-mYDK58Jp.mjs";
 import * as fs from "node:fs";
 import { execFile } from "node:child_process";
 //#region src/shared/node-topology-platform.ts

package/dist/{process-memory-B4o15Ps9.js → process-memory-CoCSce63.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-PQArEi7A.js");
+const require_dist = require("./dist-HG5geL9t.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs);
 let node_child_process = require("node:child_process");