@camstack/addon-provider-hikvision 1.2.25 → 1.2.28

package/dist/addon.mjs

@@ -7,7 +7,7 @@ import { networkInterfaces } from "node:os";
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
-//#region ../types/dist/event-category-Bxo5yJjt.mjs
+//#region ../types/dist/event-category-XfKNtfCc.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -24,9 +24,10 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemRestartCompleted"] = "system.restart-completed";
 	/**
 	* A newer addon or server-root package version was found by the
-	* authoritative registry check. Emitted once per
-	* `(target, packageName, currentVersion, latestVersion)` transition; repeated
-	* polling of the same result is deduplicated by the checker.
+	* authoritative registry check. Emitted once when any observed
+	* `latestVersion` changes (or a package/node first appears behind);
+	* the payload carries the full currently-available list. Repeated
+	* polling of the same latests is silent.
 	*/
 	EventCategory["UpdateAvailable"] = "update.available";
 	/**
@@ -45,6 +46,22 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["AddonInstalled"] = "addon.installed";
 	EventCategory["AddonUninstalled"] = "addon.uninstalled";
 	EventCategory["AddonCrashed"] = "addon.crashed";
+	/**
+	* A RUNNER the D6 crash circuit-breaker gave up on — terminal.
+	*
+	* `AddonCrashed` is the routine, self-healing fact ("it crashed; it is being
+	* respawned"); this is the one that never resolves itself. Emitted exactly
+	* once per trip, by `process-service.ts`, carrying the node, the runner, the
+	* addons it hosted and the crash count that tripped the breaker.
+	*
+	* It exists because a runner marked terminally `failed` used to be SILENT:
+	* on 2026-08-18 the `recorder` runner died of three unhandled ffmpeg spawn
+	* errors, the breaker stopped respawning it (correctly), `/health` kept
+	* returning 200, and fleet-wide recording was gone for 3h15 before the
+	* operator's phone told him. The Notification Center's system-event intake
+	* consumes this category and maps it to the `addon-crash-loop` kind.
+	*/
+	EventCategory["AddonRunnerFailed"] = "addon.runner-failed";
 	EventCategory["AddonError"] = "addon.error";
 	EventCategory["AddonPageReady"] = "addon.page-ready";
 	EventCategory["AddonWidgetReady"] = "addon.widget-ready";
@@ -7544,6 +7561,10 @@ var RecordingBandSchema = object({
 	preBufferSec: number().min(0).optional(),
 	postBufferSec: number().min(0).optional()
 });
+({
+	preBufferSec: 10,
+	postBufferSec: 30
+}).postBufferSec * 1e3;
 /**
 * Per-device retention overrides. Every field is optional; an unset or `0`
 * value inherits the node-wide recorder default. Only footage-lifetime limits
@@ -7591,6 +7612,12 @@ var RecordingConfigSchema = object({
 	/** DERIVED summary of `bands`, stamped by the recorder on every save.
 	*  Authoring it has no effect — see {@link RecordingStorageModeSchema}. */
 	mode: RecordingStorageModeSchema.optional(),
+	/**
+	* Which assigned broker slots to record. Absent / empty = {@link
+	* DEFAULT_RECORDING_PROFILES} (`high`+`low`) intersected with the
+	* camera's currently assigned slots — never `mid` unless the operator
+	* picks it, and never a slot the broker has not assigned.
+	*/
 	profiles: array(CamProfileSchema).optional(),
 	segmentSeconds: number().int().positive().optional(),
 	/**
@@ -7671,7 +7698,11 @@ var RelocateFootageInputSchema = object({
 	profiles: array(string()).optional(),
 	/** Copy throttle in MB/s (default 40) — the drain is a background chore,
 	*  never allowed to starve live writers. */
-	throttleMbps: number().min(1).max(1e3).optional()
+	throttleMbps: number().min(1).max(1e3).optional(),
+	/** Move only segments whose startMs is >= this. Absent = the whole source
+	*  pile. Used when a full drain is too expensive and the operator only
+	*  wants the recent window on the new disk. */
+	sinceMs: number().int().optional()
 });
 /** Internal, lease-scoped participant operation. It is intentionally separate
 * from persistent recording settings: a migration never changes
@@ -14723,6 +14754,7 @@ var NcSystemEventKindSchema = _enum([
 	"node-offline",
 	"node-inference-unavailable",
 	"detection-blind",
+	"addon-crash-loop",
 	"addon-update-available",
 	"server-update-available",
 	"alarm-triggered",
@@ -14730,6 +14762,9 @@ var NcSystemEventKindSchema = _enum([
 	"alarm-disarmed",
 	"alarm-arming",
 	"alarm-arm-refused",
+	"addon-updated",
+	"server-updated",
+	"export-completed",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -16623,13 +16658,19 @@ var RetrainStatusSchema = _enum([
 * "never marked" from "already trained" must read `retrainStatus`.
 *
 * `debug` does NOT pin; it is attention, not durability.
+*
+* `favourited` IS a BOOLEAN pin (durability bit), not a retrain lifecycle.
+* A favourited track is skipped by retention the same way `staging` is, but
+* it does not enter `none|staging|trained` and has no staging budget.
 */
 var TrackFlagFields = {
 	/** Operator marked this track as training material — i.e. `retrainStatus` is
 	*  `'staging'`. */
 	markForTrain: boolean().optional(),
 	/** Operator marked this track for diagnostic attention. */
-	debug: boolean().optional()
+	debug: boolean().optional(),
+	/** Operator favourited this track. Pins it against pruning. */
+	favourited: boolean().optional()
 };
 /**
 * The lifecycle field itself, on the READ surfaces only (`Track`, `KeyEvent`).
@@ -16654,6 +16695,7 @@ var TrackFlagsSchema = object({
 	trackId: string(),
 	markForTrain: boolean(),
 	debug: boolean(),
+	favourited: boolean(),
 	/** The lifecycle state the boolean was derived from. Required here (unlike on
 	*  a track row) because this shape is only ever produced by the write body,
 	*  which always knows it — and a surface that has just written needs to render
@@ -17286,6 +17328,12 @@ var TrackCascadeCountsSchema = object({
 	/** Per-track CLIP search vectors removed (best-effort). */
 	embeddings: number().int()
 });
+/** Disk-wins reconcile: media rows whose blobs are gone, then empty tracks. */
+var DiskReconcileCountsSchema = object({
+	mediaDropped: number().int(),
+	tracks: number().int(),
+	events: number().int()
+});
 /** Event-store footprint for one camera. */
 var EventStoreDeviceFootprintSchema = object({
 	deviceId: number(),
@@ -17462,6 +17510,9 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), method(object({ deviceId: number() }), TrackCascadeCountsSchema, {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({ deviceId: number() }), DiskReconcileCountsSchema, {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	deviceId: number(),
 	trackIds: array(string()).min(1)
@@ -19012,6 +19063,24 @@ var CameraStatusDegradationSchema = object({
 *
 * See spec: `docs/superpowers/specs/2026-06-24-camera-status-aggregator-cap.md`
 */
+var DiskReconcileJobSchema = object({
+	state: _enum([
+		"idle",
+		"running",
+		"done",
+		"error"
+	]),
+	total: number().int().nonnegative(),
+	completed: number().int().nonnegative(),
+	currentDeviceId: number().int().nullable(),
+	failed: array(number().int()).readonly(),
+	mediaDropped: number().int().nonnegative(),
+	tracks: number().int().nonnegative(),
+	events: number().int().nonnegative(),
+	startedAtMs: number().int().nullable(),
+	finishedAtMs: number().int().nullable(),
+	error: string().nullable()
+});
 var CameraStatusSchema = object({
 	deviceId: number(),
 	assignment: CameraAssignmentStatusSchema,
@@ -19243,7 +19312,10 @@ method(StorageMigrationLeaseInputSchema, object({ paused: literal(true) }), {
 }), CameraSwitchGroupSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ deviceId: number() }), CameraStatusSchema), method(object({ deviceIds: array(number()).optional() }), array(CameraStatusSchema).readonly()), method(_void(), array(PipelineTemplateSchema).readonly()), method(object({
+}), method(object({ deviceId: number() }), CameraStatusSchema), method(object({ deviceIds: array(number()).optional() }), array(CameraStatusSchema).readonly()), method(_void(), DiskReconcileJobSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(_void(), DiskReconcileJobSchema, { auth: "admin" }), method(_void(), array(PipelineTemplateSchema).readonly()), method(object({
 	name: string(),
 	description: string().optional(),
 	config: CameraPipelineConfigSchema
@@ -20420,20 +20492,6 @@ var VectorStatsResultSchema = object({
 	exact: boolean()
 });
 method(VectorDeclareIndexInputSchema, _void(), { kind: "mutation" }), method(VectorUpsertInputSchema, VectorUpsertResultSchema, { kind: "mutation" }), method(VectorQueryInputSchema, VectorQueryResultSchema), method(VectorGetInputSchema, VectorGetResultSchema), method(VectorDeleteInputSchema, VectorDeleteResultSchema, { kind: "mutation" }), method(VectorDeleteByFilterInputSchema, VectorDeleteResultSchema, { kind: "mutation" }), method(VectorStatsInputSchema, VectorStatsResultSchema);
-/**
-* `videoclips` — the unified, navigable-clip surface for a camera.
-*
-* A device-scoped WRAPPER cap (like `pipeline-analytics`): exactly one active
-* provider per device, substitutable. The DEFAULT provider (registered by
-* `addon-post-analysis`, `defaultActive: true`) composes the analytics event
-* log (markers + thumbnails) with the recorder's `getPlaybackManifest` — a clip
-* is a time-WINDOW over existing footage, never a separate file. A camera that
-* exposes NATIVE onboard clips (Reolink/Hikvision NVR) can later substitute the
-* wrapper provider for its device and serve its own clip catalog + URLs.
-*
-* A `Clip` is purely time-based (subtree-blind): playback resolves segments by
-* temporal overlap, so the API never decides `continuous` vs `events`.
-*/
 var ClipSchema = object({
 	/** Opaque, provider-namespaced id. The default provider encodes the time
 	*  window so `getClipPlayback` is self-contained (no event re-query). */
@@ -20450,8 +20508,57 @@ var ClipSchema = object({
 		startMs: number(),
 		endMs: number()
 	}),
-	/** Thumbnail URL (lazy; e.g. analytics `getEventMedia`). Never inlined. */
-	thumbnail: string().optional()
+	/**
+	* Lazy thumbnail URL, never inlined.
+	*
+	* Recording-derived clips (events-mode keep-window, and the prepared
+	* continuous event+fragment visit) MUST use the snapshot of the **main
+	* event of the interval** — `getEventMedia({ eventId, kind: 'snapshot' })`
+	* of the event that owns `kind` (object > motion > audio). Do not extract
+	* a keyframe from the recorded segments. Other providers (onboard, HKSV)
+	* mint their own stills.
+	*
+	* **VOUCHED, never fabricated.** A provider emits this only for an event it
+	* has CONFIRMED owns at least one media row (its own, or its owning track's).
+	* Absent is meaningful — "this visit has no event still" — never "we did not
+	* look". Stamping it from a URL template made 35% of one camera's clips point
+	* at a 404 (device 3836, 2026-08-17: 64 of 179 clips dead, 63 of them motion).
+	* A read that FAILS drops the claim; it never invents it.
+	*/
+	thumbnail: string().optional(),
+	/**
+	* An instant INSIDE this visit's footage, hole-safe, where a recorded still
+	* can be decoded. Present whenever the visit came from recorded availability;
+	* absent on a per-event padded window (there is no footage to promise).
+	*
+	* This is not a thumbnail and not a second byte path: it is the argument to
+	* the recorder's existing still route. The surface — never the provider —
+	* decides whether to use it. It is the midpoint of the visit's LONGEST
+	* contiguous range, not of the visit: a visit spans its holes by
+	* construction, so a naive midpoint lands in dead air.
+	*/
+	stillAtMs: number().optional(),
+	/**
+	* Analytics event ids that overlap this visit — a BOUNDED sample, newest
+	* first within kind (object → motion → audio), capped at
+	* {@link MAX_CLIP_EVENT_IDS}. Empty on footage-only clips.
+	*
+	* Bounded because it is not a payload the surface pages through: one visit on
+	* device 615 carried 2 345 ids, and `eventIds` was 99% of a 153 KB
+	* camera-day. Read {@link eventCount} for the true total.
+	*/
+	eventIds: array(string()).optional(),
+	/** How many analytics events actually overlap this visit. Differs from
+	*  `eventIds.length` exactly when the sample was capped — so a truncated
+	*  list is never mistaken for a quiet visit. */
+	eventCount: number().int().nonnegative().optional(),
+	/** Intra-visit footage holes (GOP rolls, discarded segments) still shorter
+	*  than `VISIT_MERGE_GAP_MS`. Playback concatenates around them; the timeline
+	*  bar keeps showing them via `recording.getAvailability`. */
+	holes: array(object({
+		startMs: number(),
+		endMs: number()
+	})).optional()
 });
 var ClipPlaybackSchema = object({
 	/** HLS master URL through the hub data-plane (Range + token in path). */
@@ -20915,7 +21022,14 @@ var SearchResultSchema = object({
 });
 var AutoUpdateSettingsSchema = object({
 	channel: ChannelSchema,
-	intervalSeconds: number()
+	intervalSeconds: number(),
+	/**
+	* Cadence of the "an update exists" POLLER, in seconds. Independent of
+	* `channel`: the poller runs while auto-apply is `off`, because being told
+	* about a publish and installing it are different decisions. Clamped
+	* server-side to 900 s … 604800 s; defaults to 21600 s (6 h).
+	*/
+	updateCheckIntervalSeconds: number()
 });
 var AddonAutoUpdateSchema = ChannelWithInheritSchema;
 var RestartAddonResultSchema = unknown();
@@ -21056,7 +21170,9 @@ method(_void(), array(AddonListItemSchema).readonly()), method(object({
 	auth: "admin"
 }), method(_void(), AutoUpdateSettingsSchema, { auth: "admin" }), method(object({
 	channel: ChannelSchema,
-	intervalSeconds: number().min(300).max(86400).optional()
+	intervalSeconds: number().min(300).max(86400).optional(),
+	/** Availability-poll cadence; see AutoUpdateSettingsSchema. */
+	updateCheckIntervalSeconds: number().min(900).max(604800).optional()
 }), unknown(), {
 	kind: "mutation",
 	auth: "admin"
@@ -26870,7 +26986,9 @@ var ExportOptionsSchema = object({
 	includeAudio: boolean(),
 	maxLifeMs: number().int().positive(),
 	deleteAfterDownload: boolean(),
-	title: string().max(200).optional()
+	title: string().max(200).optional(),
+	/** Notification-output target ids to ping when this export becomes ready. */
+	notifyTargetIds: array(string().min(1)).max(20).optional()
 }).superRefine((v, ctx) => {
 	if (v.speed !== void 0 && v.timelapse !== void 0) ctx.addIssue({
 		code: ZodIssueCode.custom,
@@ -26929,10 +27047,18 @@ var ExportBytesSchema = object({
 });
 method(object({
 	deviceId: number(),
-	profile: string(),
+	/** @deprecated Prefer `profiles`. Kept so timelapse/notifiers keep working. */
+	profile: string().optional(),
+	profiles: array(string()).min(1).optional(),
 	fromMs: number(),
 	toMs: number(),
 	options: ExportOptionsSchema
+}).superRefine((v, ctx) => {
+	if ((v.profiles !== void 0 && v.profiles.length > 0 ? v.profiles : v.profile !== void 0 ? [v.profile] : []).length < 1) ctx.addIssue({
+		code: ZodIssueCode.custom,
+		message: "pass profiles[] (min 1) or legacy profile",
+		path: ["profiles"]
+	});
 }), ExportRecordSchema, {
 	kind: "mutation",
 	auth: "protected"
@@ -30087,15 +30213,6 @@ var BaseDeviceProvider = class extends BaseAddon {
 			labels: ["probe not implemented"]
 		};
 	}
-	/**
-	* Top-level devices restored at once in {@link onRestoreDevices}.
-	*
-	* Four covers the fleets this ships to without turning a boot into a burst a
-	* camera NVR answers with a refusal. A provider whose upstream is a single
-	* session with a serial command channel (a Baichuan hub, an NVR that
-	* serialises ISAPI) should lower it; nothing needs to raise it.
-	*/
-	restoreConcurrency = 4;
 	async restoreDevices(savedDevices) {
 		await this.onRestoreDevices(savedDevices);
 		if (savedDevices.length > 0) this.ctx.logger.info(`Restored ${savedDevices.length} ${this.providerName} device(s)`);
@@ -30150,14 +30267,7 @@ var BaseDeviceProvider = class extends BaseAddon {
 				});
 			}
 		};
-		let nextTopLevel = 0;
-		await Promise.all(Array.from({ length: Math.min(Math.max(1, this.restoreConcurrency), topLevel.length) }, async () => {
-			for (;;) {
-				const saved = topLevel[nextTopLevel++];
-				if (saved === void 0) return;
-				await restoreOne(saved);
-			}
-		}));
+		await Promise.all(topLevel.map((saved) => restoreOne(saved)));
 		const childRows = savedDevices.filter((s) => s.parentDeviceId !== null);
 		for (const saved of childRows) {
 			const Class = this.deviceClasses[saved.type];
@@ -33561,6 +33671,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.reconcileFromDisk": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.refreshStorageLocationsForMigration": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -33963,6 +34079,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getReconcileFromDiskStatus": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.listAgentSettings": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -33987,6 +34109,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.reconcileFromDisk": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.removeAgentSettings": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -36978,6 +37106,11 @@ Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"pipelineAnalytics.reconcileFromDisk": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.restageRetrainTrack": [{
 		name: "deviceId",
 		form: "single",
@@ -38043,6 +38176,8 @@ DEFAULT_NATIVE_LEASE_SETTINGS.budgetMb;
 DEFAULT_NATIVE_LEASE_SETTINGS.activityMs;
 DEFAULT_NATIVE_LEASE_SETTINGS.tileBudgetMb;
 DEFAULT_NATIVE_LEASE_SETTINGS.admission;
+var MB = 1024 * 1024;
+1024 * MB, 3072 * MB;
 //#endregion
 //#region src/accessories/base.ts
 /**
@@ -40605,36 +40740,87 @@ function parseTwoWayAudioChannels(xml) {
 	return out;
 }
 /**
-* Idle watchdog for the alarm stream. Hikvision firmware emits a keep-alive
-* heartbeat (typically a `videoloss`/`inactive` alert) roughly every ~5s even
-* when nothing is happening, so a total absence of ANY bytes for this long
-* means the pipe is dead — either a half-open TCP connection (no FIN, no data)
-* that would otherwise block `reader.read()` forever, or a stalled proxy/NAT
-* conntrack entry between the hub and a camera on a different subnet. When it
-* fires we cancel the reader, surfacing a clean stream-end that the reconnect
-* path treats as a recoverable disconnect.
-*/
-var ALARM_STREAM_IDLE_TIMEOUT_MS = 3e4;
-/**
-* Subscribe to the camera's alarm stream. Returns an `AbortController`
-* — `controller.abort()` tears the subscription down. Reconnect logic
-* is the caller's responsibility (we keep the parser simple and let
-* the device class own the lifecycle / backoff timing).
-*
-* Every terminal outcome that is NOT a deliberate `controller.abort()` is
-* reported through `onError` exactly once, so the caller's reconnect logic
-* always fires:
-*   - HTTP / boundary failure at subscribe time,
-*   - a thrown error while pumping,
-*   - AND a clean stream-end (`done`). Hikvision cameras recycle the
-*     alertStream HTTP connection periodically (firmware keep-alive limits,
-*     internal event-subsystem restarts, or an idle NAT/proxy hop closing the
-*     socket). A clean close used to fall through silently — `onError` never
-*     fired, the caller's `alarmController` stayed non-null, and the device
-*     never resubscribed — so motion stopped permanently until the provider
-*     restarted. Treating clean-end as a recoverable disconnect closes that gap.
-*/
-function subscribeAlarms(client, handlers, idleTimeoutMs = ALARM_STREAM_IDLE_TIMEOUT_MS) {
+* Why the parser adopts the boundary it SEES rather than the one declared.
+*
+* Five cameras on `C-R-*` firmware (I91DN/I91DD V5.7.1, I91EV V5.8.10) have
+* never delivered one motion event here, while the same cameras deliver real
+* hardware VMD on the same endpoint to another NVR stack. The one dimension
+* where that stack is more permissive is the multipart boundary: it accepts a
+* part framed with the declared `--<boundary>` OR with the literal constant
+* `--boundary`, because "older hikvision send a boundary in the headers, but
+* then use a totally different constant boundary value".
+*
+* We take the general form instead of that special case: if the DECLARED
+* token has never once matched, adopt the token from the first `--…` line
+* actually on the wire and use it from then on. It subsumes the literal
+* `--boundary` case (that IS the observed token on those cameras) and it also
+* covers the next firmware that invents a third constant, which a hard-coded
+* fallback would not. The risk is bounded on both sides: adoption is only ever
+* attempted while the declared token has produced ZERO parts, the candidate
+* must occupy a whole line of RFC 2046 boundary characters, and the closing
+* delimiter (`--<token>--`) is rejected.
+*/
+function detectWireBoundary(buf) {
+	const text = Buffer.from(buf).toString("binary");
+	const lineRe = /(?:^|\r?\n)--([0-9A-Za-z'()+_,./:=?-]{1,70})\r?\n/g;
+	for (;;) {
+		const m = lineRe.exec(text);
+		if (!m) return null;
+		const token = m[1];
+		if (token.endsWith("--")) continue;
+		return token;
+	}
+}
+/**
+* First occurrence of each kind is logged immediately; further occurrences are
+* counted and folded into the next line after `intervalMs`. A stream that
+* drops every part therefore costs one line per minute per kind, not one per
+* chunk.
+*/
+function createAlarmDiagnostics(logger, deviceId, intervalMs) {
+	const lastLoggedAt = /* @__PURE__ */ new Map();
+	const suppressed = /* @__PURE__ */ new Map();
+	const report = (kind, message, meta, level = "warn") => {
+		if (!logger) return;
+		const now = Date.now();
+		const last = lastLoggedAt.get(kind);
+		if (last !== void 0 && now - last < intervalMs) {
+			suppressed.set(kind, (suppressed.get(kind) ?? 0) + 1);
+			return;
+		}
+		const since = suppressed.get(kind) ?? 0;
+		suppressed.set(kind, 0);
+		lastLoggedAt.set(kind, now);
+		const extras = {
+			...deviceId === null ? {} : { tags: { deviceId } },
+			meta: {
+				kind,
+				...meta,
+				...since > 0 ? { suppressedSincePrevious: since } : {}
+			}
+		};
+		if (level === "debug") logger.debug(message, extras);
+		else logger.warn(message, extras);
+	};
+	return { report };
+}
+/** First line of a buffer, clipped — the single most useful field when asking
+*  "what is this camera actually sending?". */
+function firstLineOf(buf, maxChars = 120) {
+	const line = Buffer.from(buf.subarray(0, 1024)).toString("utf8").split(/\r?\n/, 1)[0] ?? "";
+	return line.length > maxChars ? `${line.slice(0, maxChars)}…` : line;
+}
+/** First whole line that starts with `--` — i.e. the framing the camera really
+*  uses. `null` when the buffer contains no such line. */
+function firstDashLineOf(buf, maxChars = 120) {
+	const text = Buffer.from(buf.subarray(0, 4096)).toString("utf8");
+	for (const line of text.split(/\r?\n/)) {
+		if (!line.startsWith("--")) continue;
+		return line.length > maxChars ? `${line.slice(0, maxChars)}…` : line;
+	}
+	return null;
+}
+function subscribeAlarms(client, handlers, options = {}) {
 	const controller = new AbortController();
 	let settled = false;
 	const fail = (err) => {
@@ -40661,7 +40847,7 @@ function subscribeAlarms(client, handlers, idleTimeoutMs = ALARM_STREAM_IDLE_TIM
 				return;
 			}
 			handlers.onConnected?.();
-			await pumpAlarmStream(res.body, boundary, handlers, idleTimeoutMs);
+			await pumpAlarmStream(res.body, boundary, handlers, options);
 			fail(/* @__PURE__ */ new Error("alarm stream ended"));
 		} catch (err) {
 			fail(err);
@@ -40673,10 +40859,65 @@ function parseBoundary(contentType) {
 	const m = /boundary\s*=\s*"?([^";\s]+)"?/i.exec(contentType);
 	return m ? m[1].trim() : null;
 }
-async function pumpAlarmStream(stream, boundary, handlers, idleTimeoutMs = ALARM_STREAM_IDLE_TIMEOUT_MS) {
+async function pumpAlarmStream(stream, declaredBoundary, handlers, options) {
+	const idleTimeoutMs = options.idleTimeoutMs ?? 3e4;
+	const maxBufferBytes = options.maxBufferBytes ?? 1048576;
+	const retainBytes = options.retainBytes ?? 65536;
+	const unparsedWarnBytes = options.unparsedWarnBytes ?? 32768;
+	const diagnostics = createAlarmDiagnostics(options.logger ?? null, options.deviceId ?? null, options.diagnosticIntervalMs ?? 6e4);
 	const reader = stream.getReader();
-	const dashBoundary = `--${boundary}`;
+	let activeBoundary = declaredBoundary;
+	let activeDashBoundary = `--${activeBoundary}`;
+	/** Has the ACTIVE token ever framed anything? Gates boundary adoption. */
+	let matchedAnyBoundary = false;
+	/**
+	* Is the fragment that precedes the next boundary junk?
+	*
+	* True only at the head of the stream (RFC 1521 preamble), after we already
+	* emitted the bytes sitting in the buffer, and after the overflow cap cut
+	* the buffer mid-part. It used to be true unconditionally, which meant every
+	* split after the first DISCARDED a completed part — on a stream that
+	* delivers one part per TCP read, that is every event the camera ever sent.
+	*/
+	let dropLeadingFragment = true;
 	let bufferedBytes = new Uint8Array(0);
+	const dispatchBlock = (block) => {
+		const parsed = parseMultipartBlock(block);
+		if (!parsed.ok) {
+			diagnostics.report("part-unparseable", "hikvision alarm stream: multipart part dropped", {
+				reason: parsed.reason,
+				bytes: block.byteLength,
+				firstLine: firstLineOf(block)
+			});
+			return;
+		}
+		const { contentType, bodyText } = parsed.block;
+		if (!(contentType.startsWith("application/xml") || contentType.startsWith("text/xml") || looksLikeAlertXml(bodyText))) {
+			if (contentType.startsWith("image/")) {
+				diagnostics.report("part-image-ignored", "hikvision alarm stream: image part ignored (not forwarded yet)", {
+					contentType,
+					bytes: block.byteLength
+				}, "debug");
+				return;
+			}
+			diagnostics.report("part-not-alert-xml", "hikvision alarm stream: part dropped — neither an xml Content-Type nor alert-shaped XML", {
+				contentType,
+				bytes: block.byteLength,
+				bodyPreview: bodyText.slice(0, 120)
+			});
+			return;
+		}
+		const ev = parseAlertXml(bodyText);
+		if (!ev) {
+			diagnostics.report("alert-xml-without-event-type", "hikvision alarm stream: alert part dropped — no <eventType> tag", {
+				contentType,
+				bytes: block.byteLength,
+				bodyPreview: bodyText.slice(0, 120)
+			});
+			return;
+		}
+		handlers.onEvent(ev);
+	};
 	let idleTimer = null;
 	const armIdle = () => {
 		if (idleTimeoutMs <= 0) return;
@@ -40693,16 +40934,57 @@ async function pumpAlarmStream(stream, boundary, handlers, idleTimeoutMs = ALARM
 			armIdle();
 			if (!value || value.byteLength === 0) continue;
 			bufferedBytes = concat(bufferedBytes, value);
-			const parts = splitOnBoundary(bufferedBytes, dashBoundary);
-			bufferedBytes = parts.tail;
-			for (const block of parts.blocks) {
-				const parsed = parseMultipartBlock(block);
-				if (!parsed) continue;
-				if (parsed.contentType.startsWith("application/xml") || parsed.contentType.startsWith("text/xml")) {
-					const ev = parseAlertXml(parsed.bodyText);
-					if (ev) handlers.onEvent(ev);
+			let split = splitOnBoundary(bufferedBytes, activeDashBoundary, dropLeadingFragment);
+			if (!split.sawBoundary && !matchedAnyBoundary) {
+				const observed = detectWireBoundary(bufferedBytes);
+				if (observed !== null && observed !== activeBoundary) {
+					diagnostics.report("boundary-adopted", "hikvision alarm stream: declared multipart boundary never matched — adopting the boundary seen on the wire", {
+						declaredBoundary,
+						observedBoundary: observed,
+						bufferedBytes: bufferedBytes.byteLength,
+						firstDashLine: firstDashLineOf(bufferedBytes),
+						firstLine: firstLineOf(bufferedBytes)
+					});
+					activeBoundary = observed;
+					activeDashBoundary = `--${observed}`;
+					split = splitOnBoundary(bufferedBytes, activeDashBoundary, dropLeadingFragment);
+				}
+			}
+			if (split.sawBoundary) {
+				matchedAnyBoundary = true;
+				dropLeadingFragment = false;
+			}
+			bufferedBytes = split.tail;
+			for (const block of split.blocks) dispatchBlock(block);
+			if (!dropLeadingFragment) {
+				const early = takeCompletePart(bufferedBytes);
+				if (early) {
+					dispatchBlock(early.block);
+					bufferedBytes = early.rest;
+					dropLeadingFragment = true;
 				}
 			}
+			if (!matchedAnyBoundary && bufferedBytes.byteLength >= unparsedWarnBytes) diagnostics.report("boundary-never-matched", "hikvision alarm stream: no multipart boundary found in the buffered bytes — every part is being dropped", {
+				declaredBoundary,
+				activeBoundary,
+				bufferedBytes: bufferedBytes.byteLength,
+				firstDashLine: firstDashLineOf(bufferedBytes),
+				firstLine: firstLineOf(bufferedBytes)
+			});
+			if (bufferedBytes.byteLength > maxBufferBytes) {
+				diagnostics.report("buffer-overflow", "hikvision alarm stream: unparsed multipart buffer hit its cap — discarding the head", {
+					declaredBoundary,
+					activeBoundary,
+					matchedAnyBoundary,
+					bufferedBytes: bufferedBytes.byteLength,
+					maxBufferBytes,
+					retainBytes,
+					firstDashLine: firstDashLineOf(bufferedBytes),
+					firstLine: firstLineOf(bufferedBytes)
+				});
+				bufferedBytes = bufferedBytes.slice(bufferedBytes.byteLength - retainBytes);
+				dropLeadingFragment = true;
+			}
 		}
 	} finally {
 		if (idleTimer) clearTimeout(idleTimer);
@@ -40717,27 +40999,68 @@ function concat(a, b) {
 	out.set(b, a.byteLength);
 	return out;
 }
-function splitOnBoundary(buf, dashBoundary) {
+function splitOnBoundary(buf, dashBoundary, dropLeadingFragment) {
 	const parts = Buffer.from(buf).toString("binary").split(dashBoundary);
 	if (parts.length <= 1) return {
 		blocks: [],
-		tail: buf
+		tail: buf,
+		sawBoundary: false
 	};
 	const tail = Buffer.from(parts.pop(), "binary");
-	parts.shift();
+	if (dropLeadingFragment) parts.shift();
 	return {
 		blocks: parts.filter((p) => p.length > 0 && !p.startsWith("--")).map((p) => Buffer.from(p, "binary")),
-		tail
+		tail,
+		sawBoundary: true
 	};
 }
-function parseMultipartBlock(block) {
-	let start = 0;
-	while (start < block.length && (block[start] === 13 || block[start] === 10)) start++;
-	const headerEnd = findHeaderEnd(block, start);
+function parseContentLength(headerBlob) {
+	const m = /^content-length\s*:\s*(\d+)\s*$/im.exec(headerBlob);
+	if (!m) return null;
+	const n = Number.parseInt(m[1], 10);
+	return Number.isSafeInteger(n) && n >= 0 ? n : null;
+}
+/**
+* If `buf` (which must start immediately after a boundary) already holds a
+* whole part per its `Content-Length`, return it and the leftover bytes.
+* Firmware that omits `Content-Length` falls back to boundary-framed delivery.
+*/
+function takeCompletePart(buf) {
+	const headerEnd = findHeaderEnd(buf, 0);
 	if (headerEnd < 0) return null;
-	const headerBlob = Buffer.from(block.subarray(start, headerEnd)).toString("utf8");
-	const bodyStart = headerEnd + 4;
-	const bodySlice = block.subarray(bodyStart);
+	const contentLength = parseContentLength(Buffer.from(buf.subarray(0, headerEnd)).toString("utf8"));
+	if (contentLength === null) return null;
+	const end = headerEnd + 4 + contentLength;
+	if (buf.byteLength < end) return null;
+	return {
+		block: buf.slice(0, end),
+		rest: buf.slice(end)
+	};
+}
+function looksLikeAlertXml(text) {
+	return text.includes("<eventType>") || text.includes("EventNotificationAlert");
+}
+function parseMultipartBlock(block) {
+	const headerEnd = findHeaderEnd(block, 0);
+	let headerBlob = "";
+	let bodySlice;
+	if (headerEnd >= 0) {
+		headerBlob = Buffer.from(block.subarray(0, headerEnd)).toString("utf8");
+		bodySlice = block.subarray(headerEnd + 4);
+	} else {
+		const raw = Buffer.from(block).toString("utf8");
+		if (!looksLikeAlertXml(raw)) return {
+			ok: false,
+			reason: "no-header-separator-and-not-alert-xml"
+		};
+		return {
+			ok: true,
+			block: {
+				contentType: "",
+				bodyText: raw.replace(/\r?\n--$/m, "").trim()
+			}
+		};
+	}
 	const headers = {};
 	for (const line of headerBlob.split(/\r?\n/)) {
 		const idx = line.indexOf(":");
@@ -40745,14 +41068,39 @@ function parseMultipartBlock(block) {
 		headers[line.slice(0, idx).trim().toLowerCase()] = line.slice(idx + 1).trim();
 	}
 	return {
-		contentType: headers["content-type"] ?? "",
-		bodyText: Buffer.from(bodySlice).toString("utf8").replace(/\r?\n--$/m, "").trim()
+		ok: true,
+		block: {
+			contentType: headers["content-type"] ?? "",
+			bodyText: Buffer.from(bodySlice).toString("utf8").replace(/\r?\n--$/m, "").trim()
+		}
 	};
 }
 function findHeaderEnd(buf, from) {
 	for (let i = from; i + 3 < buf.length; i++) if (buf[i] === 13 && buf[i + 1] === 10 && buf[i + 2] === 13 && buf[i + 3] === 10) return i;
 	return -1;
 }
+/**
+* Event types that imply onboard motion. Compared after `eventType`
+* is lowercased. Some firmwares emit `regionExit`, others
+* `regionexiting` — accept both.
+*/
+function isHikvisionMotionAlarmType(type) {
+	switch (type) {
+		case "vmd":
+		case "motiondetection":
+		case "linedetection":
+		case "fielddetection":
+		case "regionentrance":
+		case "regionexit":
+		case "regionexiting":
+		case "attendedbaggage":
+		case "unattendedbaggage": return true;
+		default: return false;
+	}
+}
+function isHikvisionSmartAlarmType(type) {
+	return type !== "vmd" && type !== "motiondetection" && isHikvisionMotionAlarmType(type);
+}
 function parseAlertXml(xml) {
 	const type = extractTag(xml, "eventType");
 	if (!type) return null;
@@ -44399,6 +44747,9 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 				this.alarmController = null;
 				this.scheduleAlarmReconnect();
 			}
+		}, {
+			logger: this.ctx.logger,
+			deviceId: this.id
 		});
 	}
 	scheduleAlarmReconnect() {
@@ -44413,7 +44764,7 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 	handleAlarmEvent(ev) {
 		const camStreamId = this.resolveAlarmCamStreamId(ev.channelId);
 		const isMotion = ev.type === "vmd" || ev.type === "motiondetection";
-		const isSmart = ev.type === "linedetection" || ev.type === "fielddetection" || ev.type === "regionentrance" || ev.type === "regionexiting" || ev.type === "attendedbaggage" || ev.type === "unattendedbaggage";
+		const isSmart = isHikvisionSmartAlarmType(ev.type);
 		if (isMotion) {
 			this.handleMotionEvent(ev, camStreamId);
 			return;
@@ -44423,7 +44774,17 @@ var HikvisionCamera = class HikvisionCamera extends BaseDevice {
 			this.handleMotionEvent(ev, camStreamId);
 			return;
 		}
-		this.ctx.logger.debug("hikvision: unhandled alarm event", {
+		if (ev.type === "videoloss") {
+			this.ctx.logger.debug("hikvision: unhandled alarm event", {
+				tags: { deviceId: this.id },
+				meta: {
+					type: ev.type,
+					state: ev.state
+				}
+			});
+			return;
+		}
+		this.ctx.logger.info("hikvision: unhandled alarm event", {
 			tags: { deviceId: this.id },
 			meta: {
 				type: ev.type,