@camstack/addon-pipeline 1.2.107 → 1.2.115

package/dist/{event-loop-stall-monitor-DwAho7HD.js → event-loop-stall-monitor-ylMGpz48.js}

@@ -1,4 +1,5 @@
-const require_dist = require("./dist-L-1LMGQs.js");
+const require_dist = require("./dist-BqIbYW1A.js");
+let node_crypto = require("node:crypto");
 let node_perf_hooks = require("node:perf_hooks");
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";
@@ -1890,6 +1891,226 @@ function resolveModelForFormat(stepId, chosenModelId, format) {
 	return getDefaultModelForFormat(stepId, format);
 }
 //#endregion
+//#region src/session-decode/frame-view-geometry.ts
+function positiveInteger(value, label) {
+	if (!Number.isFinite(value) || value <= 0) throw new Error(`${label} must be positive`);
+	return Math.max(1, Math.round(value));
+}
+function clampCrop(sourceWidth, sourceHeight, crop) {
+	if (!crop) return {
+		left: 0,
+		top: 0,
+		width: sourceWidth,
+		height: sourceHeight
+	};
+	const left = Math.max(0, Math.min(sourceWidth - 1, Math.floor(crop.left)));
+	const top = Math.max(0, Math.min(sourceHeight - 1, Math.floor(crop.top)));
+	const right = Math.max(left + 1, Math.min(sourceWidth, Math.ceil(crop.left + crop.width)));
+	const bottom = Math.max(top + 1, Math.min(sourceHeight, Math.ceil(crop.top + crop.height)));
+	return {
+		left,
+		top,
+		width: right - left,
+		height: bottom - top
+	};
+}
+/** Pure geometry for worker-side crop/resize without model padding. */
+function resolveFrameViewGeometry(sourceWidthInput, sourceHeightInput, spec) {
+	const sourceWidth = positiveInteger(sourceWidthInput, "source width");
+	const sourceHeight = positiveInteger(sourceHeightInput, "source height");
+	const targetWidth = positiveInteger(spec.content.width, "content width");
+	const targetHeight = positiveInteger(spec.content.height, "content height");
+	const sourceCrop = clampCrop(sourceWidth, sourceHeight, spec.crop);
+	const output = spec.fit === "stretch" ? {
+		width: targetWidth,
+		height: targetHeight
+	} : (() => {
+		const scale = Math.min(targetWidth / sourceCrop.width, targetHeight / sourceCrop.height);
+		return {
+			width: Math.max(1, Math.round(sourceCrop.width * scale)),
+			height: Math.max(1, Math.round(sourceCrop.height * scale))
+		};
+	})();
+	return {
+		source: {
+			width: sourceWidth,
+			height: sourceHeight
+		},
+		sourceCrop,
+		output,
+		scale: {
+			x: output.width / sourceCrop.width,
+			y: output.height / sourceCrop.height
+		}
+	};
+}
+//#endregion
+//#region src/session-decode/local-frame-registry.ts
+var DEFAULT_MAX_FRAMES = 24;
+var DEFAULT_MAX_BYTES = 512 * 1024 * 1024;
+function estimateFrameBytes(image) {
+	return image.width * image.height * (image.format === "gray" ? 1 : 3);
+}
+function releasesNative(reason) {
+	return reason !== "success";
+}
+/**
+* Bounded process-local registry. A serialized ref from another process misses
+* by registry id; an evicted id never aliases a newer frame. View resolution
+* is lease-only ({@link acquire} → {@link LocalFrameLease.resolve}) so an
+* in-flight `toBuffer()` is covered by `refs > 1` and cannot be LRU-evicted.
+*/
+var LocalFrameRegistry = class {
+	registryId;
+	maxFrames;
+	maxBytes;
+	entries = /* @__PURE__ */ new Map();
+	bytes = 0;
+	releaseCount = 0;
+	evictionCount = 0;
+	staleMissCount = 0;
+	constructor(options = {}) {
+		this.registryId = options.registryId ?? `${process.pid}-${(0, node_crypto.randomUUID)()}`;
+		this.maxFrames = options.maxFrames ?? DEFAULT_MAX_FRAMES;
+		this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+	}
+	get size() {
+		return this.entries.size;
+	}
+	get estimatedBytes() {
+		return this.bytes;
+	}
+	getStats() {
+		let residentRefs = 0;
+		for (const entry of this.entries.values()) residentRefs += entry.refs;
+		return {
+			residentFrames: this.entries.size,
+			residentRefs,
+			residentBytes: this.bytes,
+			releases: this.releaseCount,
+			evictions: this.evictionCount,
+			staleMisses: this.staleMissCount
+		};
+	}
+	register(image, metadata) {
+		const estimatedBytes = estimateFrameBytes(image);
+		if (this.maxFrames < 1 || estimatedBytes > this.maxBytes) {
+			image.close();
+			image.releaseNativeLease?.();
+			return null;
+		}
+		const ref = {
+			registryId: this.registryId,
+			id: (0, node_crypto.randomUUID)(),
+			width: image.width,
+			height: image.height,
+			format: image.format,
+			timestamp: metadata.timestamp,
+			...metadata.capturedAt !== void 0 ? { capturedAt: metadata.capturedAt } : {}
+		};
+		this.entries.set(ref.id, {
+			ref,
+			image,
+			estimatedBytes,
+			refs: 1,
+			releaseNativeOnClose: false
+		});
+		this.bytes += estimatedBytes;
+		this.evictToBounds();
+		return this.entries.has(ref.id) ? ref : null;
+	}
+	acquire(ref) {
+		if (ref.registryId === this.registryId && !this.entries.has(ref.id)) this.staleMissCount += 1;
+		const entry = this.getEntry(ref);
+		if (!entry) return null;
+		entry.refs += 1;
+		this.touch(entry);
+		let released = false;
+		return {
+			resolve: (spec) => this.resolveFromLease(entry, spec),
+			release: (reason) => {
+				if (released) return;
+				released = true;
+				this.release(ref, reason);
+			}
+		};
+	}
+	release(ref, reason) {
+		const entry = this.getEntry(ref);
+		if (!entry) return;
+		this.releaseCount += 1;
+		if (releasesNative(reason)) entry.releaseNativeOnClose = true;
+		entry.refs = Math.max(0, entry.refs - 1);
+		if (entry.refs === 0) this.drop(entry);
+	}
+	clear(reason = "detach") {
+		for (const entry of [...this.entries.values()]) {
+			if (releasesNative(reason)) entry.releaseNativeOnClose = true;
+			this.drop(entry);
+		}
+	}
+	getEntry(ref) {
+		if (ref.registryId !== this.registryId) return null;
+		return this.entries.get(ref.id) ?? null;
+	}
+	touch(entry) {
+		this.entries.delete(entry.ref.id);
+		this.entries.set(entry.ref.id, entry);
+	}
+	/**
+	* Materialize a view for a live lease only. Public callers must go through
+	* {@link acquire} so `refs > 1` covers the whole `toBuffer()` window.
+	*/
+	async resolveFromLease(entry, spec) {
+		if (!this.entries.has(entry.ref.id)) return {
+			kind: "miss",
+			reason: "stale-ref"
+		};
+		this.touch(entry);
+		const geometry = resolveFrameViewGeometry(entry.image.width, entry.image.height, spec);
+		return {
+			kind: "view",
+			data: await entry.image.toBuffer({
+				crop: geometry.sourceCrop,
+				resize: geometry.output,
+				format: spec.format
+			}),
+			width: geometry.output.width,
+			height: geometry.output.height,
+			format: spec.format,
+			geometry
+		};
+	}
+	/** Oldest owner-only / queued entry (`refs === 1`). Consumer leases (`refs > 1`) stay. */
+	findOwnerOnlyVictim() {
+		for (const entry of this.entries.values()) if (entry.refs <= 1) return entry;
+	}
+	evictToBounds() {
+		while (this.entries.size > this.maxFrames || this.bytes > this.maxBytes) {
+			const victim = this.findOwnerOnlyVictim();
+			if (!victim) break;
+			victim.releaseNativeOnClose = true;
+			this.evictionCount += 1;
+			this.drop(victim);
+		}
+	}
+	drop(entry) {
+		if (!this.entries.delete(entry.ref.id)) return;
+		this.bytes = Math.max(0, this.bytes - entry.estimatedBytes);
+		entry.image.close();
+		if (entry.releaseNativeOnClose) entry.image.releaseNativeLease?.();
+	}
+};
+function envPositiveInt(name, fallback) {
+	const parsed = Number(process.env[name]);
+	return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+/** Shared only by addons in the same grouped runner process. */
+var localFrameRegistry = new LocalFrameRegistry({
+	maxFrames: envPositiveInt("CAMSTACK_LOCAL_FRAME_MAX_FRAMES", DEFAULT_MAX_FRAMES),
+	maxBytes: envPositiveInt("CAMSTACK_LOCAL_FRAME_BUDGET_MB", DEFAULT_MAX_BYTES / 1048576) * 1048576
+});
+//#endregion
 //#region src/detection-pipeline/diagnostics/event-loop-stall-monitor.ts
 /**
 * event-loop-stall-monitor — names the thing that freezes the detection process.
@@ -2074,6 +2295,18 @@ Object.defineProperty(exports, "landmarkPrecisionVerdict", {
 		return landmarkPrecisionVerdict;
 	}
 });
+Object.defineProperty(exports, "localFrameRegistry", {
+	enumerable: true,
+	get: function() {
+		return localFrameRegistry;
+	}
+});
+Object.defineProperty(exports, "resolveFrameViewGeometry", {
+	enumerable: true,
+	get: function() {
+		return resolveFrameViewGeometry;
+	}
+});
 Object.defineProperty(exports, "resolveModelForFormat", {
 	enumerable: true,
 	get: function() {

package/dist/{lazy-sharp-DfbyQxET.js → lazy-sharp-cOsy7l_P.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-L-1LMGQs.js");
+const require_dist = require("./dist-BqIbYW1A.js");
 let node_url = require("node:url");
 let node_module = require("node:module");
 let node_path = require("node:path");

package/dist/motion-wasm/index.js

@@ -2,8 +2,8 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-L-1LMGQs.js");
-const require_lazy_sharp = require("../lazy-sharp-DfbyQxET.js");
+const require_dist = require("../dist-BqIbYW1A.js");
+const require_lazy_sharp = require("../lazy-sharp-cOsy7l_P.js");
 let node_path = require("node:path");
 let node_fs = require("node:fs");
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { Et as hydrateSchema, G as evaluateZoneRules, Y as motionDetectionCapability, wt as DeviceType, xt as BaseAddon } from "../dist-CkXAzTZ2.mjs";
+import { Et as hydrateSchema, G as evaluateZoneRules, Y as motionDetectionCapability, wt as DeviceType, xt as BaseAddon } from "../dist-DGQkkWc6.mjs";
 import { t as getSharp } from "../lazy-sharp-6oymT_yf.mjs";
 import { join } from "node:path";
 import { readFileSync } from "node:fs";