@camstack/addon-pipeline-orchestrator 1.1.27 → 1.1.28

package/dist/index.js

@@ -4631,7 +4631,7 @@ function _instanceof(cls, params = {}) {
 	return inst;
 }
 //#endregion
-//#region ../types/dist/sleep-BiDFW0E7.mjs
+//#region ../types/dist/sleep-CZDdRBua.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -7638,7 +7638,16 @@ var DecoderStatsSchema = object({
 	inputFps: number(),
 	outputFps: number(),
 	avgDecodeTimeMs: number(),
-	droppedFrames: number()
+	droppedFrames: number(),
+	/**
+	* Pull-mode adaptive-fps telemetry (optional — only pull sessions run the
+	* lag-driven controller; push sessions omit these). `lagMs` is the EWMA of
+	* the decoder's real-time drift (rising = falling behind live); `adaptiveFps`
+	* is the current lag-throttled emit rate (≤ `effectiveFps` ceiling).
+	*/
+	lagMs: number().optional(),
+	effectiveFps: number().optional(),
+	adaptiveFps: number().optional()
 });
 var DecoderSessionConfigSchema = object({
 	codec: string(),
@@ -7679,7 +7688,15 @@ var DecoderSessionConfigSchema = object({
 	*   other — `pullFrames` returns nothing for an `'shm'` session and
 	*   `pullHandles` returns nothing for a `'callback'` session.
 	*/
-	frameSink: _enum(["callback", "shm"]).default("callback")
+	frameSink: _enum(["callback", "shm"]).default("callback"),
+	/**
+	* Per-camera decoder DEBUG facility. When `true`, a pull-mode session emits
+	* a throttled (~1Hz) structured `decoder debug` line (effective/adaptive fps,
+	* real-time lag, dropped-frame delta, avg decode time, hwaccel). Mirrors the
+	* stream-broker's `streamingDebug` gate — off by default so production logs
+	* stay quiet and the emit path pays zero per-frame cost when disabled.
+	*/
+	debug: boolean().optional()
 });
 var EncodeProfileSchema = object({
 	video: object({
@@ -9898,6 +9915,75 @@ DeviceType.Cover, method(object({ deviceId: number().int().nonnegative() }), _vo
 	auth: "admin"
 });
 /**
+* Vendor-neutral day/night (IR-cut) control — the per-camera config cap
+* shared by reolink / hikvision / amcrest. Models the common firmware
+* surface: the IR-cut switching MODE plus the two knobs that gate it
+* (photocell `sensitivity` + `switchDelaySec`). Each vendor maps these
+* onto its own ISAPI / Baichuan / Dahua-CGI fields; the cap standardises
+* the shape so ONE derived-form renders every camera.
+*
+* Follows the D14 `deviceConfig` archetype (see `stream-params.cap.ts`):
+* `getOptions` advertises per-camera availability, `getStatus` (auto-
+* injected from `status`) reports the live values, and a single
+* `setSettings` mutation applies a partial change. No hand-written
+* settings-contribution methods — the framework derives the UI + save
+* routing from this surface.
+*/
+/** IR-cut switching mode. `schedule` = time-of-day table configured on the camera. */
+var DayNightModeSchema = _enum([
+	"auto",
+	"day",
+	"night",
+	"schedule"
+]);
+/** Normalized numeric range descriptor — `{ min, max, step }` per the
+*  getOptions availability convention. Normalized values are 0–100. */
+var NormalizedRangeSchema$1 = object({
+	min: number(),
+	max: number(),
+	step: number()
+});
+object({
+	mode: DayNightModeSchema,
+	/** IR-cut trigger sensitivity, NORMALIZED 0–100 (higher = switches to night sooner). */
+	sensitivity: number().optional(),
+	/** Delay before the IR-cut filter flips, in seconds. */
+	switchDelaySec: number().optional(),
+	lastFetchedAt: number()
+});
+/**
+* Per-camera availability descriptor — drives which controls the admin UI
+* renders. Booleans as `supportsX`; numeric ranges as `{ min, max, step }`
+* (normalized 0–100); the mode choice-set as an array. A provider returns
+* honest, camera-probed values — never hardcoded.
+*/
+var DayNightOptionsSchema = object({
+	/** Modes this camera accepts. Empty → the camera has no configurable day/night mode. */
+	modes: array(DayNightModeSchema),
+	supportsSensitivity: boolean(),
+	/** Present when `supportsSensitivity` — the normalized 0–100 range. */
+	sensitivity: NormalizedRangeSchema$1.optional(),
+	supportsSwitchDelay: boolean(),
+	/** Present when `supportsSwitchDelay` — the allowed delay range in seconds. */
+	switchDelaySec: NormalizedRangeSchema$1.optional()
+});
+/**
+* Partial change to the day/night config — every field optional. A
+* provider ignores fields it does not support.
+*/
+var DayNightSettingsPatchSchema = object({
+	mode: DayNightModeSchema.optional(),
+	sensitivity: number().optional(),
+	switchDelaySec: number().optional()
+});
+DeviceType.Camera, method(object({ deviceId: number() }), DayNightOptionsSchema), method(object({
+	deviceId: number(),
+	settings: DayNightSettingsPatchSchema
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
 * Identity envelope for a device's upstream-system metadata.
 *
 * Two jobs:
@@ -10253,6 +10339,130 @@ object({
 });
 DeviceType.Image;
 /**
+* Vendor-neutral image / picture-adjustment cap — the per-camera config
+* cap shared by reolink / hikvision / amcrest. Models the common ISP
+* surface: the four picture sliders (brightness / contrast / saturation /
+* sharpness), orientation (mirror / flip / rotate), white-balance,
+* exposure and backlight-compensation modes.
+*
+* NORMALIZATION: every slider is a normalized int 0–100. Vendors expose
+* these natively as 0–100 or 0–255 (or other ranges); each provider maps
+* its native range to/from this normalized 0–100 space so the cap surface
+* (and the derived form) is identical across cameras. `warmth` (manual
+* white-balance) is likewise normalized 0–100.
+*
+* Follows the D14 `deviceConfig` archetype (see `stream-params.cap.ts`):
+* `getOptions` advertises per-camera availability, `getStatus` (auto-
+* injected from `status`) reports the live values, and a single
+* `setSettings` mutation applies a partial change. No hand-written
+* settings-contribution methods — the framework derives the UI + save
+* routing from this surface.
+*/
+/** Sensor/image rotation, degrees clockwise. */
+var ImageRotateSchema = _enum([
+	"0",
+	"90",
+	"180",
+	"270"
+]);
+/** White-balance mode. `manual` unlocks the normalized `warmth` knob. */
+var WhiteBalanceModeSchema = _enum(["auto", "manual"]);
+/** Exposure mode. */
+var ExposureModeSchema = _enum(["auto", "manual"]);
+/**
+* Backlight-compensation mode:
+*   - `off` — disabled
+*   - `blc` — backlight compensation
+*   - `wdr` — wide dynamic range
+*   - `hlc` — highlight compensation
+*/
+var BacklightModeSchema = _enum([
+	"off",
+	"blc",
+	"wdr",
+	"hlc"
+]);
+/** Normalized numeric range descriptor — `{ min, max, step }` per the
+*  getOptions availability convention. Slider values are normalized 0–100. */
+var NormalizedRangeSchema = object({
+	min: number(),
+	max: number(),
+	step: number()
+});
+object({
+	/** Normalized 0–100. */
+	brightness: number().optional(),
+	/** Normalized 0–100. */
+	contrast: number().optional(),
+	/** Normalized 0–100. */
+	saturation: number().optional(),
+	/** Normalized 0–100. */
+	sharpness: number().optional(),
+	mirror: boolean().optional(),
+	flip: boolean().optional(),
+	rotate: ImageRotateSchema.optional(),
+	whiteBalance: WhiteBalanceModeSchema.optional(),
+	/** Manual white-balance warmth, NORMALIZED 0–100. Meaningful only when `whiteBalance === 'manual'`. */
+	warmth: number().optional(),
+	exposureMode: ExposureModeSchema.optional(),
+	backlightMode: BacklightModeSchema.optional(),
+	lastFetchedAt: number()
+});
+/**
+* Per-camera availability descriptor — drives which controls the admin UI
+* renders. Booleans as `supportsX`; numeric ranges as `{ min, max, step }`
+* (the normalized 0–100 range); enums as arrays of supported values (empty
+* array → control hidden). A provider returns honest, camera-probed values
+* — never hardcoded.
+*/
+var ImageSettingsOptionsSchema = object({
+	supportsBrightness: boolean(),
+	brightness: NormalizedRangeSchema.optional(),
+	supportsContrast: boolean(),
+	contrast: NormalizedRangeSchema.optional(),
+	supportsSaturation: boolean(),
+	saturation: NormalizedRangeSchema.optional(),
+	supportsSharpness: boolean(),
+	sharpness: NormalizedRangeSchema.optional(),
+	supportsMirror: boolean(),
+	supportsFlip: boolean(),
+	/** Supported rotation values. Empty → rotation not configurable. */
+	rotateOptions: array(ImageRotateSchema),
+	/** Supported white-balance modes. Empty → white-balance not configurable. */
+	whiteBalanceModes: array(WhiteBalanceModeSchema),
+	supportsWarmth: boolean(),
+	/** Present when `supportsWarmth` — the normalized 0–100 range. */
+	warmth: NormalizedRangeSchema.optional(),
+	/** Supported exposure modes. Empty → exposure not configurable. */
+	exposureModes: array(ExposureModeSchema),
+	/** Supported backlight modes. Empty → backlight-compensation not configurable. */
+	backlightModes: array(BacklightModeSchema)
+});
+/**
+* Partial change to the image config — every field optional. Slider values
+* are normalized 0–100. A provider ignores fields it does not support.
+*/
+var ImageSettingsPatchSchema = object({
+	brightness: number().optional(),
+	contrast: number().optional(),
+	saturation: number().optional(),
+	sharpness: number().optional(),
+	mirror: boolean().optional(),
+	flip: boolean().optional(),
+	rotate: ImageRotateSchema.optional(),
+	whiteBalance: WhiteBalanceModeSchema.optional(),
+	warmth: number().optional(),
+	exposureMode: ExposureModeSchema.optional(),
+	backlightMode: BacklightModeSchema.optional()
+});
+DeviceType.Camera, method(object({ deviceId: number() }), ImageSettingsOptionsSchema), method(object({
+	deviceId: number(),
+	settings: ImageSettingsPatchSchema
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
 * Robotic lawn-mower cap. Models HA `lawn_mower.*` entities — anything
 * with a mowing lifecycle plus a dock action.
 *
@@ -11315,6 +11525,16 @@ var RunnerCameraConfigSchema = object({
 	* this gate is bypassed.
 	*/
 	onboardMotionDrivesAnalyzer: boolean().default(true),
+	/**
+	* Master toggle for the occupancy re-check. When `false` (DEFAULT) the runner
+	* never arms the periodic recheck timer, regardless of `occupancyRecheckSec` —
+	* this is off by default because the recheck re-subscribes a detection session
+	* every N seconds while `watching`, a major source of pull-decoder re-dial
+	* churn (each cycle creates+tears a session → RTSP re-dial → latency). The
+	* `occupancyRecheckSec` / `occupancyRecheckFrames` sliders only take effect
+	* (and only render) when this is enabled.
+	*/
+	occupancyRecheckEnabled: boolean().default(false),
 	occupancyRecheckSec: number().min(occupancyRecheckSecField.min).max(occupancyRecheckSecField.max).default(occupancyRecheckSecField.default),
 	occupancyRecheckFrames: number().min(occupancyRecheckFramesField.min).max(occupancyRecheckFramesField.max).default(occupancyRecheckFramesField.default),
 	/**
@@ -11365,6 +11585,8 @@ var RunnerCameraDeviceUIFields = [
 		default: motionFpsField.default,
 		showValue: true,
 		unit: "fps",
+		nullable: true,
+		nullLabel: "Default",
 		showWhen: {
 			field: "motionSources",
 			includes: "analyzer"
@@ -11379,7 +11601,9 @@ var RunnerCameraDeviceUIFields = [
 		step: detectionFpsField.step,
 		default: detectionFpsField.default,
 		showValue: true,
-		unit: "fps"
+		unit: "fps",
+		nullable: true,
+		nullLabel: "Default"
 	},
 	{
 		key: "motionCooldownMs",
@@ -11392,7 +11616,9 @@ var RunnerCameraDeviceUIFields = [
 		default: motionCooldownMsField.default,
 		showValue: true,
 		unit: "s",
-		displayScale: 1e3
+		displayScale: 1e3,
+		nullable: true,
+		nullLabel: "Default"
 	},
 	{
 		key: "onboardMotionDrivesAnalyzer",
@@ -11405,17 +11631,29 @@ var RunnerCameraDeviceUIFields = [
 			includes: "onboard"
 		}
 	},
+	{
+		key: "occupancyRecheckEnabled",
+		type: "boolean",
+		style: "checkbox",
+		label: "Occupancy re-check",
+		description: "Periodically re-sample a few frames during the watching phase to confirm the scene is truly empty (catches stationary objects motion-gating would miss). Off by default — it adds decoder re-dial churn.",
+		default: false
+	},
 	{
 		key: "occupancyRecheckSec",
 		type: "slider",
 		label: "Occupancy re-check interval",
-		description: "How often (in seconds) the runner re-samples a few frames to confirm the scene is truly empty during the watching phase. 0 = disabled.",
+		description: "How often (in seconds) the runner re-samples a few frames to confirm the scene is truly empty during the watching phase.",
 		min: occupancyRecheckSecField.min,
 		max: occupancyRecheckSecField.max,
 		step: occupancyRecheckSecField.step,
 		default: occupancyRecheckSecField.default,
 		showValue: true,
-		unit: "s"
+		unit: "s",
+		showWhen: {
+			field: "occupancyRecheckEnabled",
+			equals: true
+		}
 	},
 	{
 		key: "occupancyRecheckFrames",
@@ -11426,7 +11664,11 @@ var RunnerCameraDeviceUIFields = [
 		max: occupancyRecheckFramesField.max,
 		step: occupancyRecheckFramesField.step,
 		default: occupancyRecheckFramesField.default,
-		showValue: true
+		showValue: true,
+		showWhen: {
+			field: "occupancyRecheckEnabled",
+			equals: true
+		}
 	}
 ];
 /**
@@ -20005,6 +20247,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"dayNight.getOptions": {
+		capName: "day-night",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"dayNight.setSettings": {
+		capName: "day-night",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"decoder.createSession": {
 		capName: "decoder",
 		capScope: "system",
@@ -20935,6 +21189,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"imageSettings.getOptions": {
+		capName: "image-settings",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"imageSettings.setSettings": {
+		capName: "image-settings",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"integrations.create": {
 		capName: "integrations",
 		capScope: "system",
@@ -24514,7 +24780,8 @@ var DEFAULT_WATCHDOG_THRESHOLDS = {
 	audioMs: 9e4,
 	motionMs: 3e4,
 	detectionMs: 6e4,
-	maxRecoveryAttempts: 3
+	maxRecoveryAttempts: 3,
+	exhaustedRetryMs: 6e4
 };
 var STAGE_THRESHOLD_KEY = {
 	audio: "audioMs",
@@ -24535,7 +24802,8 @@ var PipelineWatchdog = class {
 		const stages = /* @__PURE__ */ new Map();
 		for (const [stage] of cam.continuousStages) stages.set(stage, {
 			lastSeenMs: now,
-			attempts: 0
+			attempts: 0,
+			lastAttemptMs: 0
 		});
 		this.state.set(cam.deviceId, stages);
 	}
@@ -24558,7 +24826,10 @@ var PipelineWatchdog = class {
 			else this.deps.logger.info(line);
 			for (const r of recoveries) {
 				const rt = this.state.get(cam.deviceId)?.get(r.stage);
-				if (rt) rt.attempts += 1;
+				if (rt) {
+					if (rt.attempts < this.deps.thresholds.maxRecoveryAttempts) rt.attempts += 1;
+					rt.lastAttemptMs = now;
+				}
 				this.deps.recover(cam.deviceId, r.stage, r.streamId);
 			}
 		}
@@ -24602,7 +24873,13 @@ var PipelineWatchdog = class {
 			if (staleness <= thresholdMs) parts.push(`${stage}=${stageMode[stage]}@${streamId}(OK ${sSec}s)`);
 			else if (rt.attempts >= this.deps.thresholds.maxRecoveryAttempts) {
 				stalled = true;
-				parts.push(`${stage}=${stageMode[stage]}@${streamId}(STALLED ${sSec}s · exhausted ${rt.attempts})`);
+				if (now - rt.lastAttemptMs >= this.deps.thresholds.exhaustedRetryMs) {
+					recoveries.push({
+						stage,
+						streamId
+					});
+					parts.push(`${stage}=${stageMode[stage]}@${streamId}(STALLED ${sSec}s · exhausted ${rt.attempts} · retrying)`);
+				} else parts.push(`${stage}=${stageMode[stage]}@${streamId}(STALLED ${sSec}s · exhausted ${rt.attempts})`);
 			} else {
 				stalled = true;
 				recoveries.push({
@@ -24954,6 +25231,24 @@ function isPipelinePhaseMode(v) {
 var PREFERRED_AGENT_SETTING = "preferredAgent";
 /** Key under which the orchestrator stores the per-device audio node pin. */
 var AUDIO_NODE_SETTING = "audioNodeId";
+/**
+* Target PCM window duration, in ms, for audio classification.
+*
+* Sized for the ~1 s inference window the downstream classifiers expect —
+* YAMNet consumes a 0.975 s frame and Apple SoundAnalysis a ~1 s frame.
+* The broker's `AudioCodecSession` no longer batches (its 500 ms
+* accumulator was removed for WebRTC latency), so decoded codec chunks now
+* arrive at ~21–64 ms each — ~16–48 chunks per second per camera. Feeding
+* each tiny chunk to the analyzer meant one cross-process `analyseChunk`
+* RPC + one `PipelineAudioInferenceResult` event PER chunk for a classifier
+* that (a) throttles to ~2 Hz internally anyway and (b) needs a ~1 s window
+* for accurate inference. We instead accumulate raw PCM per device and flush
+* ONE classify + ONE event per ~1 s window: ~1 RPC/event/s/camera and a
+* correctly-sized inference frame.
+*/
+var AUDIO_WINDOW_TARGET_MS = 1e3;
+/** f32le PCM = 4 bytes per sample. */
+var F32_BYTES_PER_SAMPLE = 4;
 var DEFAULT_BROKER_CALL_TIMEOUT_MS = 5e3;
 /** Debounce window for `scheduleReconcile` — coalesces bursts of topology/slot-change signals. */
 var RECONCILE_DEBOUNCE_MS = 200;
@@ -28862,6 +29157,13 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			if (typeof v !== "number") throw new Error(`orchestrator schema missing required number '${key}' for device ${deviceId}`);
 			return v;
 		};
+		const numberOrDefault = (key) => {
+			const v = flat[key];
+			if (typeof v === "number") return v;
+			const uiField = RunnerCameraDeviceUIFields.find((f) => f.key === key);
+			const dflt = uiField && "default" in uiField ? uiField.default : void 0;
+			return typeof dflt === "number" ? dflt : 0;
+		};
 		try {
 			const features = await this.lookupDeviceFeatures(deviceId);
 			const profile = resolveDeviceProfile(features);
@@ -28879,6 +29181,8 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			const audioMode = typeof userAudioMode === "string" && isPipelinePhaseMode(userAudioMode) ? userAudioMode : profile?.defaults.audioMode ?? "always-on";
 			const userOnboardMotionDrivesAnalyzer = raw["onboardMotionDrivesAnalyzer"];
 			const onboardMotionDrivesAnalyzer = typeof userOnboardMotionDrivesAnalyzer === "boolean" ? userOnboardMotionDrivesAnalyzer : true;
+			const userOccupancyRecheckEnabled = raw["occupancyRecheckEnabled"];
+			const occupancyRecheckEnabled = typeof userOccupancyRecheckEnabled === "boolean" ? userOccupancyRecheckEnabled : false;
 			const occupancyRecheckSec = mustNumber("occupancyRecheckSec");
 			const occupancyRecheckFrames = mustNumber("occupancyRecheckFrames");
 			return {
@@ -28887,12 +29191,13 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 				motionSources,
 				motionStreamProfile: mustString("motionStreamProfile"),
 				detectionStreamProfile: mustString("detectionStreamProfile"),
-				motionFps: mustNumber("motionFps"),
-				detectionFps: mustNumber("detectionFps"),
-				motionCooldownMs: mustNumber("motionCooldownMs"),
+				motionFps: numberOrDefault("motionFps"),
+				detectionFps: numberOrDefault("detectionFps"),
+				motionCooldownMs: numberOrDefault("motionCooldownMs"),
 				detectionMode,
 				audioMode,
 				onboardMotionDrivesAnalyzer,
+				occupancyRecheckEnabled,
 				occupancyRecheckSec,
 				occupancyRecheckFrames
 			};
@@ -29003,6 +29308,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			detectionMode: resolved.detectionMode,
 			audioMode: resolved.audioMode,
 			onboardMotionDrivesAnalyzer: resolved.onboardMotionDrivesAnalyzer,
+			occupancyRecheckEnabled: resolved.occupancyRecheckEnabled,
 			occupancyRecheckSec: resolved.occupancyRecheckSec,
 			occupancyRecheckFrames: resolved.occupancyRecheckFrames
 		};
@@ -29037,6 +29343,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			detectionMode: config.detectionMode,
 			audioMode: config.audioMode,
 			onboardMotionDrivesAnalyzer: config.onboardMotionDrivesAnalyzer,
+			occupancyRecheckEnabled: config.occupancyRecheckEnabled,
 			occupancyRecheckSec: config.occupancyRecheckSec,
 			occupancyRecheckFrames: config.occupancyRecheckFrames
 		};
@@ -29202,6 +29509,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		if (a.motionCooldownMs !== b.motionCooldownMs) return false;
 		if (a.audioStreamId !== b.audioStreamId) return false;
 		if (a.onboardMotionDrivesAnalyzer !== b.onboardMotionDrivesAnalyzer) return false;
+		if (a.occupancyRecheckEnabled !== b.occupancyRecheckEnabled) return false;
 		if (a.occupancyRecheckSec !== b.occupancyRecheckSec) return false;
 		if (a.occupancyRecheckFrames !== b.occupancyRecheckFrames) return false;
 		if (a.motionSources.length !== b.motionSources.length) return false;
@@ -29731,6 +30039,19 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 				isRemote: isRemoteAudio
 			}
 		});
+		let pcmParts = [];
+		let accumulatedBytes = 0;
+		let accumulatedMs = 0;
+		let windowSampleRate = 0;
+		let windowChannels = 0;
+		let windowTimestamp = 0;
+		let windowOpen = false;
+		const resetWindow = () => {
+			pcmParts = [];
+			accumulatedBytes = 0;
+			accumulatedMs = 0;
+			windowOpen = false;
+		};
 		const teardown = startAudioChunkPoller({
 			api,
 			brokerId: audioBrokerId,
@@ -29740,13 +30061,35 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 				this.pipelineWatchdog?.noteSignal(deviceId, "audio");
 				try {
 					const byteLength = chunk.data.byteLength;
-					const data = new Uint8Array(byteLength);
-					data.set(new Uint8Array(chunk.data.buffer, chunk.data.byteOffset, byteLength));
+					const bytes = new Uint8Array(byteLength);
+					bytes.set(new Uint8Array(chunk.data.buffer, chunk.data.byteOffset, byteLength));
+					if (!windowOpen) {
+						windowSampleRate = chunk.sampleRate;
+						windowChannels = chunk.channels;
+						windowTimestamp = chunk.timestamp;
+						windowOpen = true;
+					}
+					pcmParts.push(bytes);
+					accumulatedBytes += byteLength;
+					const channels = chunk.channels > 0 ? chunk.channels : 1;
+					const framesPerChannel = byteLength / F32_BYTES_PER_SAMPLE / channels;
+					accumulatedMs += framesPerChannel / chunk.sampleRate * 1e3;
+					if (accumulatedMs < AUDIO_WINDOW_TARGET_MS) return;
+					const windowData = new Uint8Array(accumulatedBytes);
+					let offset = 0;
+					for (const part of pcmParts) {
+						windowData.set(part, offset);
+						offset += part.byteLength;
+					}
+					const flushSampleRate = windowSampleRate;
+					const flushChannels = windowChannels;
+					const flushTimestamp = windowTimestamp;
+					resetWindow();
 					const audioChunkInput = {
-						data,
-						sampleRate: chunk.sampleRate,
-						channels: chunk.channels,
-						timestamp: chunk.timestamp,
+						data: windowData,
+						sampleRate: flushSampleRate,
+						channels: flushChannels,
+						timestamp: flushTimestamp,
 						deviceId
 					};
 					const result = await api.audioAnalyzer.analyseChunk.mutate({
@@ -29823,6 +30166,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		this.ctx.logger.info("Audio stream subscribed", { tags: { deviceId } });
 		return () => {
 			teardown();
+			resetWindow();
 		};
 	}
 };