@camstack/addon-pipeline 1.2.5 → 1.2.7

package/dist/{dist-CtQsET1Q.js → dist-CAT3VF7A.js}

@@ -6915,7 +6915,6 @@ object({ deviceId: number() }), object({ deviceId: number() }), object({
 	patch: record(string(), unknown())
 }), object({ success: literal(true) });
 object({ deviceId: number() }), unknown().nullable();
-/** Shorthand to define a method schema */
 function method(input, output, options) {
 	return {
 		input,
@@ -6923,6 +6922,7 @@ function method(input, output, options) {
 		kind: options?.kind ?? "query",
 		auth: options?.auth ?? "protected",
 		...options?.access !== void 0 ? { access: options.access } : {},
+		...options?.caller !== void 0 ? { caller: options.caller } : {},
 		timeoutMs: options?.timeoutMs
 	};
 }
@@ -11731,6 +11731,22 @@ var CameraMetricsSchema = object({
 	])
 });
 var CameraMetricsWithDeviceIdSchema = CameraMetricsSchema.extend({ deviceId: number() });
+/**
+* Reference to the frame's retained NATIVE surface + the parent crop's placement
+* within the frame, so the executor can re-cut a leaf child ROI at native
+* resolution on the detail plane. See the `runPipeline` `nativeCropRef` field.
+*/
+var NativeCropRefSchema = object({
+	/** Handle keying the retained native surface (node-pinned to its owner). */
+	handle: FrameHandleSchema,
+	/** The parent crop's padded/clamped rectangle in FRAME-space pixels. */
+	cropFrameSpace: object({
+		x: number(),
+		y: number(),
+		w: number(),
+		h: number()
+	})
+});
 var ModelFormatSchema$1 = _enum([
 	"onnx",
 	"coreml",
@@ -12104,7 +12120,22 @@ var pipelineExecutorCapability = {
 			* Omitted ⇒ the runner's default device (current single-engine
 			* behaviour). Selects WHICH device pool of the node runs the call.
 			*/
-			deviceKey: string().optional()
+			deviceKey: string().optional(),
+			/**
+			* Two-plane NATIVE child-crop reference. Set by `runDetailSubtree` ONLY
+			* when the parent crop was resolved from the frame's retained NATIVE
+			* surface (a frameHandle HIT). Lets the executor re-cut a LEAF crop
+			* child's ROI (plate-ocr, face-embedding, leaf classifiers) at native
+			* resolution from that surface — the SAME quality path faces already
+			* had — instead of the downscaled parent tile. `handle` keys the native
+			* surface (node-pinned to its owner); `cropFrameSpace` is the parent
+			* crop's padded/clamped rectangle in FRAME-space pixels, used to compose
+			* the executor's crop-normalized child ROI back into frame-normalized
+			* coordinates. Auxiliary to the image source (`image`/`frame`/…), NOT one
+			* of the mutually-exclusive image inputs. Absent ⇒ tile-crop children
+			* (today's behaviour on the fallback path).
+			*/
+			nativeCropRef: NativeCropRefSchema.optional()
 		}), PipelineRunResultBridge, { kind: "mutation" }),
 		/**
 		* Batched run — N raw frames packed into one cap call. The provider
@@ -12374,7 +12405,11 @@ var DetailResultSchema = object({
 	bbox: NativeCropBboxSchema.optional(),
 	embedding: string().optional(),
 	label: string().optional(),
-	alignedCropJpeg: string().optional()
+	alignedCropJpeg: string().optional(),
+	/** Face short side (px) measured on the NATIVE crop surface. The `bbox`
+	*  above is detection-frame px (≈6× smaller on a 4K camera) — min-face-size
+	*  consumers MUST prefer this when present (2026-07-22 native-gate fix). */
+	nativeFaceShortSidePx: number().optional()
 });
 /**
 * Per-camera tunable ranges + defaults. Single source of truth used
@@ -17041,6 +17076,226 @@ method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSche
 	enabled: boolean()
 }), _void(), { kind: "mutation" });
 /**
+* notification-rules — the Notification Center rule surface (P1 core).
+*
+* Spec: `docs/superpowers/specs/2026-07-22-notification-center-requirements.md`
+* (operator decisions D-1/D-2/D-3 are binding):
+*
+*  - D-2: rule EVALUATION lives in `addon-post-analysis` (the
+*    `notification-center` module), hooked on the durable persistence
+*    moments (object-event insert, TrackCloser.closeExpired) with a
+*    persisted outbox + retry — never the lossy telemetry bus (D8).
+*  - D-3: urgency belongs to the RULE. `delivery: 'immediate'` fires on the
+*    FIRST persisted detection matching the conditions (per-track dedup,
+*    `maxPerTrack` fixed at 1 — see {@link NC_MAX_PER_TRACK_IMMEDIATE});
+*    `delivery: 'track-end'` evaluates the finalized track record at close.
+*  - DISPATCH stays behind `notification-output` (rules reference targets
+*    by id; per-backend params are a passthrough blob capped by the
+*    target kind's own caps/degrade engine).
+*
+* P1 scope: admin-authored rules only (`createdBy` stamped from the
+* server-injected caller identity — the first `caller: 'required'`
+* adopter). The P1 condition subset is: devices, classes(+exclude),
+* minConfidence, admin zones (any/all + exclude), weekly schedule
+* windows, and the optional label/identity/plate matchers. User rules,
+* private zones, per-recipient fan-out and the wider condition table are
+* P2+ (see spec §7).
+*
+* All schemas here are the single source of truth — `NcRule` etc. are
+* `z.infer` exports; no duplicate interfaces (the advanced-notifier
+* schema/interface drift is explicitly not repeated).
+*/
+/** D-3: the urgency of a rule — which persistence moment evaluates it. */
+var NcDeliverySchema = _enum(["immediate", "track-end"]);
+/** Weekly schedule — OR of windows; absence on the rule = always active. */
+var NcScheduleSchema = object({
+	windows: array(object({
+		/** Days of week the window STARTS on (0 = Sunday … 6 = Saturday). */
+		days: array(number().int().min(0).max(6)).min(1),
+		startMinute: number().int().min(0).max(1439),
+		endMinute: number().int().min(0).max(1439)
+	})).min(1),
+	/** IANA timezone; default = hub host timezone. */
+	timezone: string().optional(),
+	/** Active OUTSIDE the windows (e.g. "only outside business hours"). */
+	invert: boolean().optional()
+});
+/** Fuzzy plate matcher — OCR noise makes exact match useless (spec row 12/13). */
+var NcPlateMatcherSchema = object({
+	values: array(string().min(1)).min(1),
+	/** Max Levenshtein distance after normalization (uppercase alphanumeric). */
+	maxDistance: number().int().min(0).max(3).default(1)
+});
+/** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
+var NcZoneConditionSchema = object({
+	ids: array(string().min(1)).min(1),
+	/** Quantifier over `ids` — at least one / every one visited. */
+	match: _enum(["any", "all"]).default("any")
+});
+/**
+* The P1 condition set — a flat AND of groups; absent group = pass;
+* membership lists are OR within the list (spec §2.3).
+*/
+var NcConditionsSchema = object({
+	/** Device scope — absent = all devices. */
+	devices: array(number()).optional(),
+	/** Detector class names (any overlap with the record's class set). */
+	classes: array(string().min(1)).optional(),
+	/** Veto classes — any overlap fails the rule. */
+	classesExclude: array(string().min(1)).optional(),
+	/** Minimum detection confidence 0–1 (fails when the record has none). */
+	minConfidence: number().min(0).max(1).optional(),
+	/** Admin zone membership over event `zones` / track `zonesVisited`. */
+	zones: NcZoneConditionSchema.optional(),
+	/** Veto zones — any hit fails the rule. */
+	zonesExclude: array(string().min(1)).optional(),
+	/**
+	* Exact (case-insensitive) match on the record's collapsed `label`
+	* (identity name / plate text / subclass).
+	*/
+	labelEquals: array(string().min(1)).optional(),
+	/**
+	* Identity matcher. P1 boundary: matched against the record's collapsed
+	* `label` (the identity display name propagated by the face pipeline) —
+	* identity-ID matching rides in P2 when identity ids reach the record.
+	*/
+	identities: array(string().min(1)).optional(),
+	/** Fuzzy plate matcher against the record's `label` (plate text). */
+	plates: NcPlateMatcherSchema.optional()
+});
+/** One delivery target: a `notification-output` Target ref + passthrough params. */
+var NcRuleTargetSchema = object({
+	/** `notification-output` Target id. */
+	targetId: string().min(1),
+	/**
+	* Per-backend passthrough. Recognized keys are mapped onto the canonical
+	* Notification (`priority`, `level`, `sound`, `clickUrl`, `ttl`); the
+	* degrade engine drops what the backend can't render.
+	*/
+	params: record(string(), unknown()).optional()
+});
+/**
+* Media attachment policy (P1 still-image subset). `best` = the best
+* AVAILABLE media at dispatch time (D-3); `best-matching` (track-end
+* condition-best) is deferred — operator open point.
+*/
+var NcMediaPolicySchema = object({ attach: _enum([
+	"best",
+	"keyFrame",
+	"none"
+]).default("best") });
+/** Throttle — cooldown survives restarts (rebuilt from the outbox on boot). */
+var NcThrottleSchema = object({
+	cooldownSec: number().int().min(0).max(86400).default(60),
+	/** `rule` = one shared cooldown; `rule-device` = per-camera cooldown. */
+	scope: _enum(["rule", "rule-device"]).default("rule-device")
+});
+/** Client-supplied rule fields (server stamps id/createdBy/createdAt/updatedAt). */
+var NcRuleInputSchema = object({
+	name: string().min(1).max(200),
+	enabled: boolean().default(true),
+	delivery: NcDeliverySchema,
+	conditions: NcConditionsSchema.default({}),
+	schedule: NcScheduleSchema.optional(),
+	targets: array(NcRuleTargetSchema).min(1),
+	media: NcMediaPolicySchema.default({ attach: "best" }),
+	throttle: NcThrottleSchema.default({
+		cooldownSec: 60,
+		scope: "rule-device"
+	}),
+	/** `{{var}}` templating over camera/class/label/zones/confidence/time. */
+	template: object({
+		title: string().max(500).optional(),
+		body: string().max(2e3).optional()
+	}).optional(),
+	/** Canonical notification priority ordinal (1..5); per-target overridable. */
+	priority: number().int().min(1).max(5).default(3)
+});
+/** Partial patch for `updateRule` — any subset of the input fields. */
+var NcRulePatchSchema = NcRuleInputSchema.partial();
+/** A persisted rule. */
+var NcRuleSchema = NcRuleInputSchema.extend({
+	id: string(),
+	/** userId of the admin who created the rule (server-stamped caller). */
+	createdBy: string(),
+	createdAt: number(),
+	updatedAt: number()
+});
+var NcTestResultSchema = object({
+	recordId: string(),
+	recordKind: _enum(["object-event", "track"]),
+	deviceId: number(),
+	timestamp: number(),
+	wouldFire: boolean(),
+	/** Condition id that failed (first failing group), when `wouldFire` is false. */
+	failedCondition: string().optional(),
+	className: string().optional(),
+	label: string().optional()
+});
+var NcConditionDescriptorSchema = object({
+	/** Field id inside `NcConditions` (or `'schedule'` for the rule-level group). */
+	id: string(),
+	group: _enum([
+		"scope",
+		"class",
+		"zones",
+		"quality",
+		"label",
+		"schedule"
+	]),
+	label: string(),
+	/** Editor widget the UI renders — never hardcode per-condition forms. */
+	valueType: _enum([
+		"deviceIdList",
+		"stringList",
+		"number01",
+		"zoneSelection",
+		"zoneIdList",
+		"schedule",
+		"plateMatcher"
+	]),
+	operator: _enum([
+		"in",
+		"notIn",
+		"anyOf",
+		"allOf",
+		"gte",
+		"fuzzyIn",
+		"withinSchedule"
+	]),
+	/** Which delivery kinds the condition applies to. */
+	appliesTo: array(NcDeliverySchema),
+	phase: string(),
+	description: string().optional()
+});
+method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), method(object({ ruleId: string() }), object({ rule: NcRuleSchema.nullable() }), { auth: "admin" }), method(object({ rule: NcRuleInputSchema }), object({ rule: NcRuleSchema }), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({
+	ruleId: string(),
+	patch: NcRulePatchSchema
+}), object({ rule: NcRuleSchema }), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
+}), method(object({ ruleId: string() }), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	ruleId: string(),
+	enabled: boolean()
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	rule: NcRuleInputSchema,
+	lookbackMinutes: number().int().min(1).max(1440).default(60)
+}), object({ results: array(NcTestResultSchema) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), object({ catalog: array(NcConditionDescriptorSchema) }));
+/**
 * Shared LLM generate contracts — imported by BOTH `llm.cap.ts` (consumer
 * surface) and `llm-runtime.cap.ts` (node-side managed executor) so the two
 * caps stay wire-compatible without a circular cap→cap import.
@@ -24585,6 +24840,54 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"notificationRules.createRule": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"notificationRules.deleteRule": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"notificationRules.getConditionCatalog": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"notificationRules.getRule": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"notificationRules.listRules": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"notificationRules.setRuleEnabled": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"notificationRules.testRule": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"notificationRules.updateRule": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"notifier.cancel": {
 		capName: "notifier",
 		capScope: "device",

package/dist/motion-wasm/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-CtQsET1Q.js");
+const require_dist = require("../dist-CAT3VF7A.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { A as motionDetectionCapability, J as hydrateSchema, K as DeviceType, T as evaluateZoneRules, U as BaseAddon } from "../dist-ZB-B8UrH.mjs";
+import { A as motionDetectionCapability, J as hydrateSchema, K as DeviceType, T as evaluateZoneRules, U as BaseAddon } from "../dist-BwyGTnMu.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/pipeline-runner/index.js

@@ -3,11 +3,11 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-CtQsET1Q.js");
+const require_dist = require("../dist-CAT3VF7A.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 const require_sheet_geometry = require("../sheet-geometry-BR-ip0CP.js");
 const require_worker_protocol = require("../worker-protocol-DextwlTX.js");
-const require_step_definitions = require("../step-definitions-DrRnEQPM.js");
+const require_step_definitions = require("../step-definitions-BPEExRug.js");
 let node_child_process = require("node:child_process");
 let node_url = require("node:url");
 let sharp = require("sharp");
@@ -1284,15 +1284,20 @@ var RETAINED_FRAME_BUDGET_BYTES = (() => {
 /**
 * How many of each device's MOST RECENT frames are protected from a busy
 * neighbour's budget eviction. Sized to cover the late two-plane / cross-process
-* enrichment horizon (~150-500 ms): 6 frames ≈ 0.6 s @10 fps of guaranteed
-* survival for every active camera. Read ONCE from
-* `CAMSTACK_SESSION_RETAIN_FLOOR`; `0` disables the floor (pure global FIFO — the
-* pre-2026-07-19 behaviour). The hard byte ceiling always overrides the floor,
-* so this can never push retention past {@link RETAINED_FRAME_BUDGET_BYTES}.
+* enrichment horizon (~150-500 ms) at the REAL delivered rate: the store writes
+* every DELIVERED rgb frame, and a high-fps camera delivers ~25 fps (observed on
+* the 4K outdoor cams), so the old floor of 6 protected only ~240 ms there and
+* its late captures hit "frame recycled before resolve" (2026-07-22 triage —
+* missing thumbnails/firstFrames concentrated on exactly those cameras).
+* 16 frames ≈ 0.64 s @25 fps (1.6 s @10 fps). Only ACTIVE cameras hold frames,
+* so the worst-case protected footprint stays well inside the byte budget for
+* realistic concurrency (4 active cams ≈ 44 MB of 96); the hard ceiling always
+* overrides the floor regardless. Read ONCE from `CAMSTACK_SESSION_RETAIN_FLOOR`;
+* `0` disables the floor (pure global FIFO — the pre-2026-07-19 behaviour).
 */
 var RETAINED_FRAME_PER_DEVICE_FLOOR = (() => {
 	const raw = Number(process.env["CAMSTACK_SESSION_RETAIN_FLOOR"]);
-	return Number.isFinite(raw) && raw >= 0 ? Math.floor(raw) : 6;
+	return Number.isFinite(raw) && raw >= 0 ? Math.floor(raw) : 16;
 })();
 /** Opaque RAM-key prefix stamped into a retained frame's `FrameHandle.shmId`. */
 var RETAINED_FRAME_KEY_PREFIX = "ram:";
@@ -2210,14 +2215,18 @@ function toDetailResult(detection, stepId, crop) {
 		bbox: mapBboxToFrameSpace(detection.bbox, crop),
 		...detection.embedding !== void 0 ? { embedding: encodeEmbeddingBase64(detection.embedding) } : {},
 		...label !== void 0 ? { label } : {},
-		...detection.faceAlignedCrop !== void 0 ? { alignedCropJpeg: detection.faceAlignedCrop } : {}
+		...detection.faceAlignedCrop !== void 0 ? { alignedCropJpeg: detection.faceAlignedCrop } : {},
+		...detection.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: detection.nativeFaceShortSidePx } : {}
 	};
 }
 async function resolveCrop(deps, input) {
 	if (input.frameHandle) {
 		const normalized = normalizeRect(padAndClampFrameBbox(input.parent.bbox, input.frameHandle.width, input.frameHandle.height), input.frameHandle.width, input.frameHandle.height);
 		const native = await deps.getNativeCrop(input.deviceId, input.frameHandle, normalized);
-		if (native) return native;
+		if (native) return {
+			...native,
+			source: "native"
+		};
 	}
 	if (input.cropJpeg) {
 		const jpeg = Buffer.from(input.cropJpeg, "base64");
@@ -2230,7 +2239,8 @@ async function resolveCrop(deps, input) {
 			jpeg,
 			width,
 			height,
-			frameSpace: input.parent.bbox
+			frameSpace: input.parent.bbox,
+			source: "fallback"
 		};
 	}
 	return null;
@@ -2258,10 +2268,14 @@ async function runDetailSubtree(deps, input) {
 	const steps = requested === void 0 ? matched : matched.map((step) => pruneChildStepsToRequested(step, requested));
 	const crop = await resolveCrop(deps, input);
 	if (!crop) return null;
+	const nativeCropRef = input.frameHandle !== void 0 && crop.source === "native" ? {
+		handle: input.frameHandle,
+		cropFrameSpace: crop.frameSpace
+	} : void 0;
 	const details = [];
 	for (const step of steps) {
 		const deviceKey = deps.resolveStepDevice?.(input.deviceId, step);
-		const result = await deps.runPipeline([step], crop.jpeg, input.deviceId, deviceKey);
+		const result = await deps.runPipeline([step], crop.jpeg, input.deviceId, deviceKey, nativeCropRef);
 		if (!result) continue;
 		for (const detection of result.detections) details.push(toDetailResult(detection, step.addonId, crop));
 	}
@@ -3367,7 +3381,7 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 		return runDetailSubtree({
 			resolveChildSteps: (deviceId, parentClassName, filter) => this.resolveDetailChildSteps(deviceId, parentClassName, filter),
 			getNativeCrop: (deviceId, handle, paddedBbox) => this.getNativeCropForDetail(deviceId, handle, paddedBbox),
-			runPipeline: (steps, imageJpeg, deviceId, deviceKey) => this.runDetailPipeline(steps, imageJpeg, deviceId, deviceKey),
+			runPipeline: (steps, imageJpeg, deviceId, deviceKey, nativeCropRef) => this.runDetailPipeline(steps, imageJpeg, deviceId, deviceKey, nativeCropRef),
 			resolveStepDevice: (deviceId, step) => this.resolveDetailStepDevice(deviceId, step)
 		}, input);
 	}
@@ -3519,7 +3533,7 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 		})();
 	}
 	/** Real `runPipeline` dep: node-local `pipelineExecutor.runPipeline` on the `'full'` plane. */
-	async runDetailPipeline(steps, imageJpeg, deviceId, stepDeviceKey) {
+	async runDetailPipeline(steps, imageJpeg, deviceId, stepDeviceKey, nativeCropRef) {
 		const api = this.ctxIfReady?.api;
 		if (!api) return null;
 		const detailDeviceKey = stepDeviceKey ?? this.attached.get(deviceId)?.config?.deviceKey;
@@ -3529,7 +3543,8 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 				image: new Uint8Array(imageJpeg),
 				deviceId,
 				...detailDeviceKey ? { deviceKey: detailDeviceKey } : {},
-				plane: "full"
+				plane: "full",
+				...nativeCropRef ? { nativeCropRef } : {}
 			});
 		} catch (err) {
 			this.ctxIfReady?.logger.warn("runDetailSubtree: runPipeline failed", {

package/dist/pipeline-runner/index.mjs

@@ -1,8 +1,8 @@
-import { H as errMsg, N as pipelineRunnerCapability, S as defineCustomActions, U as BaseAddon, b as customAction, ct as number, dt as string, it as boolean, j as nodePin, lt as object, nt as _enum, ot as lazy, pt as EventCategory, q as createEvent, rt as array, s as DEVICE_BACKEND_TO_FORMAT } from "../dist-ZB-B8UrH.mjs";
+import { H as errMsg, N as pipelineRunnerCapability, S as defineCustomActions, U as BaseAddon, b as customAction, ct as number, dt as string, it as boolean, j as nodePin, lt as object, nt as _enum, ot as lazy, pt as EventCategory, q as createEvent, rt as array, s as DEVICE_BACKEND_TO_FORMAT } from "../dist-BwyGTnMu.mjs";
 import { n as profileForStreamId, t as isRemoteRestream } from "../remote-restream-BeHi78PZ.mjs";
 import { r as resolveHubHostname } from "../sheet-geometry-DcpuGTCm.mjs";
 import { t as isWorkerReply } from "../worker-protocol-D7RzZIla.mjs";
-import { a as getStepDefinition } from "../step-definitions-BKJI5CXI.mjs";
+import { a as getStepDefinition } from "../step-definitions-DN1obXS7.mjs";
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import sharp from "sharp";
@@ -1278,15 +1278,20 @@ var RETAINED_FRAME_BUDGET_BYTES = (() => {
 /**
 * How many of each device's MOST RECENT frames are protected from a busy
 * neighbour's budget eviction. Sized to cover the late two-plane / cross-process
-* enrichment horizon (~150-500 ms): 6 frames ≈ 0.6 s @10 fps of guaranteed
-* survival for every active camera. Read ONCE from
-* `CAMSTACK_SESSION_RETAIN_FLOOR`; `0` disables the floor (pure global FIFO — the
-* pre-2026-07-19 behaviour). The hard byte ceiling always overrides the floor,
-* so this can never push retention past {@link RETAINED_FRAME_BUDGET_BYTES}.
+* enrichment horizon (~150-500 ms) at the REAL delivered rate: the store writes
+* every DELIVERED rgb frame, and a high-fps camera delivers ~25 fps (observed on
+* the 4K outdoor cams), so the old floor of 6 protected only ~240 ms there and
+* its late captures hit "frame recycled before resolve" (2026-07-22 triage —
+* missing thumbnails/firstFrames concentrated on exactly those cameras).
+* 16 frames ≈ 0.64 s @25 fps (1.6 s @10 fps). Only ACTIVE cameras hold frames,
+* so the worst-case protected footprint stays well inside the byte budget for
+* realistic concurrency (4 active cams ≈ 44 MB of 96); the hard ceiling always
+* overrides the floor regardless. Read ONCE from `CAMSTACK_SESSION_RETAIN_FLOOR`;
+* `0` disables the floor (pure global FIFO — the pre-2026-07-19 behaviour).
 */
 var RETAINED_FRAME_PER_DEVICE_FLOOR = (() => {
 	const raw = Number(process.env["CAMSTACK_SESSION_RETAIN_FLOOR"]);
-	return Number.isFinite(raw) && raw >= 0 ? Math.floor(raw) : 6;
+	return Number.isFinite(raw) && raw >= 0 ? Math.floor(raw) : 16;
 })();
 /** Opaque RAM-key prefix stamped into a retained frame's `FrameHandle.shmId`. */
 var RETAINED_FRAME_KEY_PREFIX = "ram:";
@@ -2204,14 +2209,18 @@ function toDetailResult(detection, stepId, crop) {
 		bbox: mapBboxToFrameSpace(detection.bbox, crop),
 		...detection.embedding !== void 0 ? { embedding: encodeEmbeddingBase64(detection.embedding) } : {},
 		...label !== void 0 ? { label } : {},
-		...detection.faceAlignedCrop !== void 0 ? { alignedCropJpeg: detection.faceAlignedCrop } : {}
+		...detection.faceAlignedCrop !== void 0 ? { alignedCropJpeg: detection.faceAlignedCrop } : {},
+		...detection.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: detection.nativeFaceShortSidePx } : {}
 	};
 }
 async function resolveCrop(deps, input) {
 	if (input.frameHandle) {
 		const normalized = normalizeRect(padAndClampFrameBbox(input.parent.bbox, input.frameHandle.width, input.frameHandle.height), input.frameHandle.width, input.frameHandle.height);
 		const native = await deps.getNativeCrop(input.deviceId, input.frameHandle, normalized);
-		if (native) return native;
+		if (native) return {
+			...native,
+			source: "native"
+		};
 	}
 	if (input.cropJpeg) {
 		const jpeg = Buffer.from(input.cropJpeg, "base64");
@@ -2224,7 +2233,8 @@ async function resolveCrop(deps, input) {
 			jpeg,
 			width,
 			height,
-			frameSpace: input.parent.bbox
+			frameSpace: input.parent.bbox,
+			source: "fallback"
 		};
 	}
 	return null;
@@ -2252,10 +2262,14 @@ async function runDetailSubtree(deps, input) {
 	const steps = requested === void 0 ? matched : matched.map((step) => pruneChildStepsToRequested(step, requested));
 	const crop = await resolveCrop(deps, input);
 	if (!crop) return null;
+	const nativeCropRef = input.frameHandle !== void 0 && crop.source === "native" ? {
+		handle: input.frameHandle,
+		cropFrameSpace: crop.frameSpace
+	} : void 0;
 	const details = [];
 	for (const step of steps) {
 		const deviceKey = deps.resolveStepDevice?.(input.deviceId, step);
-		const result = await deps.runPipeline([step], crop.jpeg, input.deviceId, deviceKey);
+		const result = await deps.runPipeline([step], crop.jpeg, input.deviceId, deviceKey, nativeCropRef);
 		if (!result) continue;
 		for (const detection of result.detections) details.push(toDetailResult(detection, step.addonId, crop));
 	}
@@ -3361,7 +3375,7 @@ var PipelineRunnerAddon = class extends BaseAddon {
 		return runDetailSubtree({
 			resolveChildSteps: (deviceId, parentClassName, filter) => this.resolveDetailChildSteps(deviceId, parentClassName, filter),
 			getNativeCrop: (deviceId, handle, paddedBbox) => this.getNativeCropForDetail(deviceId, handle, paddedBbox),
-			runPipeline: (steps, imageJpeg, deviceId, deviceKey) => this.runDetailPipeline(steps, imageJpeg, deviceId, deviceKey),
+			runPipeline: (steps, imageJpeg, deviceId, deviceKey, nativeCropRef) => this.runDetailPipeline(steps, imageJpeg, deviceId, deviceKey, nativeCropRef),
 			resolveStepDevice: (deviceId, step) => this.resolveDetailStepDevice(deviceId, step)
 		}, input);
 	}
@@ -3513,7 +3527,7 @@ var PipelineRunnerAddon = class extends BaseAddon {
 		})();
 	}
 	/** Real `runPipeline` dep: node-local `pipelineExecutor.runPipeline` on the `'full'` plane. */
-	async runDetailPipeline(steps, imageJpeg, deviceId, stepDeviceKey) {
+	async runDetailPipeline(steps, imageJpeg, deviceId, stepDeviceKey, nativeCropRef) {
 		const api = this.ctxIfReady?.api;
 		if (!api) return null;
 		const detailDeviceKey = stepDeviceKey ?? this.attached.get(deviceId)?.config?.deviceKey;
@@ -3523,7 +3537,8 @@ var PipelineRunnerAddon = class extends BaseAddon {
 				image: new Uint8Array(imageJpeg),
 				deviceId,
 				...detailDeviceKey ? { deviceKey: detailDeviceKey } : {},
-				plane: "full"
+				plane: "full",
+				...nativeCropRef ? { nativeCropRef } : {}
 			});
 		} catch (err) {
 			this.ctxIfReady?.logger.warn("runDetailSubtree: runPipeline failed", {

package/dist/recorder/index.js

@@ -1,5 +1,5 @@
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-CtQsET1Q.js");
+const require_dist = require("../dist-CAT3VF7A.js");
 const require_sheet_geometry = require("../sheet-geometry-BR-ip0CP.js");
 const require_model_download_service_Cp9f4dk6 = require("../model-download-service-Cp9f4dk6-Dv-oFwjN.js");
 let node_child_process = require("node:child_process");

package/dist/recorder/index.mjs

@@ -1,4 +1,4 @@
-import { F as recordingExportCapability, H as errMsg, I as resolveScrubThumbnailGeometry, J as hydrateSchema, K as DeviceType, P as recordingCapability, R as storageEvictableCapability, U as BaseAddon, Y as isEvent, c as EVENT_PAD_MS, dt as string, et as selectAssignedProfileSlots, f as OpsLogEntrySchema, j as nodePin, k as migrateConfigToBands, p as RecordingConfigSchema, pt as EventCategory, rt as array, u as ExportRecordSchema, ut as record } from "../dist-ZB-B8UrH.mjs";
+import { F as recordingExportCapability, H as errMsg, I as resolveScrubThumbnailGeometry, J as hydrateSchema, K as DeviceType, P as recordingCapability, R as storageEvictableCapability, U as BaseAddon, Y as isEvent, c as EVENT_PAD_MS, dt as string, et as selectAssignedProfileSlots, f as OpsLogEntrySchema, j as nodePin, k as migrateConfigToBands, p as RecordingConfigSchema, pt as EventCategory, rt as array, u as ExportRecordSchema, ut as record } from "../dist-BwyGTnMu.mjs";
 import { n as computeSheetGeometry, r as resolveHubHostname, t as allTilePlacements } from "../sheet-geometry-DcpuGTCm.mjs";
 import { n as createFileDataPlaneHandler, s as parseRangeHeader, t as contentTypeFor } from "../model-download-service-Cp9f4dk6-CwUb5v3Y.mjs";
 import { spawn } from "node:child_process";