@camstack/addon-pipeline 1.2.198 → 1.2.200

package/dist/restream-intent-B1Difcnq.js

@@ -0,0 +1,313 @@
+/** {@link PREBUFFER_MAX_SEC} in ms — the widest window any consumer can be served. */
+var PREBUFFER_MAX_MS = 15 * 1e3;
+/** Clamp an enabled window's seconds into `[MIN, MAX]`; `0`/invalid means off. */
+function clampSeconds(value) {
+	if (value === void 0) return 5;
+	if (!Number.isFinite(value) || value <= 0) return 0;
+	return Math.min(15, Math.max(1, value));
+}
+/** `enabled: false` is the only representation of off — never `seconds: 0` alone. */
+var OFF = {
+	enabled: false,
+	seconds: 0
+};
+/**
+* The ONE prebuffer decision.
+*
+* Precedence: explicit per-stream override -> battery / terminal relay (off) ->
+* the profile's warm default -> off. Every layer that used to make this
+* decision somewhere else — `isDefaultWarm`, `applyPreBufferConfig`,
+* `getEffectivePreBufferSec`, `resolvePreRollMs`, `resolveRecordingPreRollMs` —
+* is this function now, so the four of them cannot disagree about one camera.
+*/
+function resolvePrebuffer(input) {
+	const override = input.overrides?.[input.camStreamId];
+	if (override !== void 0) {
+		if (!override.enabled) return OFF;
+		const seconds = clampSeconds(override.seconds);
+		return seconds > 0 ? {
+			enabled: true,
+			seconds
+		} : OFF;
+	}
+	if (input.batteryOperated === true) return OFF;
+	if (input.terminalRelay === true) return OFF;
+	if (input.defaultWarm !== true) return OFF;
+	const seconds = clampSeconds(input.clusterSeconds);
+	return seconds > 0 ? {
+		enabled: true,
+		seconds
+	} : OFF;
+}
+/** The retention, in ms — the single number the ring is trimmed to. */
+function prebufferRetentionMs(config) {
+	return config.enabled ? config.seconds * 1e3 : 0;
+}
+/**
+* What a consumer asking for `requestedMs` of history is actually served.
+*
+* The cap is the point of the record: a consumer states a WISH and the ring
+* states the truth.
+*
+* `requestedMs` is REQUIRED, and `0` means none (D382). It used to accept
+* `undefined` for "whatever you have", which is how every detection dial came
+* to be served the whole retained window: detection declares an intent for an
+* unrelated reason (the live-edge exemption) and never named an amount, so the
+* omission decided for it. A parameter that can be left out is a default that
+* acts without anybody choosing it — the shape D381 retired for the retention
+* and this one retires for the ask.
+*
+* A nonsense request resolves to `0`, never to the whole window: an
+* unparseable number arriving on a dial path must not be able to widen a burst.
+*/
+function capPreRollRequestMs(requestedMs, retainedMs) {
+	const retained = Number.isFinite(retainedMs) && retainedMs > 0 ? retainedMs : 0;
+	if (retained === 0) return 0;
+	if (!Number.isFinite(requestedMs) || requestedMs <= 0) return 0;
+	return Math.min(requestedMs, retained);
+}
+/**
+* Path suffix for the audio-free variant dialed by a DETECTION decode session.
+* Muted in every respect (no audio, still `isMuted()`), plus exempt from the
+* live-edge join withhold.
+*/
+var DETECTION_MUTED_PATH_SUFFIX = "/muted-detection";
+/**
+* Path suffix for a RECORDING dial — the `events`-band recorder's ffmpeg.
+*
+* NOT muted: a recording keeps its audio, so this cannot ride the detection
+* suffix. What it shares with detection is the reason for existing — it attaches
+* AFTER the trigger, so without the retained history its footage begins after
+* the event. Measured on camera 1438 (audit 2026-08-20): the footage started
+* after the motion in 60 % of episodes, because the writer is spawned at the
+* trigger and ffmpeg's first frame is at best the live edge.
+*/
+var RECORDING_PATH_SUFFIX = "/recording";
+/**
+* Path segment prefix carrying the AMOUNT of retained history a dial asks for.
+*
+* A path segment and not a query string: the listen server matches the request
+* URI with a path regex and strips a trailing `/trackID=N`, so anything that is
+* not a segment would either break the token lookup or be dropped silently
+* between DESCRIBE and SETUP.
+*/
+var PRE_ROLL_REQUEST_PREFIX = "/preroll-";
+/** A dial that declared nothing: no purpose, no history. */
+var NO_DECLARATION = {
+	intent: null,
+	preRollRequestMs: 0
+};
+/**
+* What the DETECTION dial asks for.
+*
+* {@link PREBUFFER_MAX_MS} — "whatever you retain" — which is byte-for-byte
+* what D381 served this population by omission, so the ask becomes explicit
+* without the behaviour changing under an operator who was never asked. It is a
+* REQUEST, not a configuration: `capPreRollRequestMs` answers it with the
+* smaller of this and what the ring holds, and the prebuffer stays the only
+* place the amount of history is decided.
+*
+* Whether detection should ask for LESS is an operator's call on measured
+* numbers, not something a session decides for itself. The per-attach evidence
+* is the broker's `restream attach live-edge` line and the runner's
+* `session-decode: detection first frame`, which now names this request.
+*/
+var DETECTION_PRE_ROLL_REQUEST_MS = PREBUFFER_MAX_MS;
+/**
+* What the RECORDING dial asks for: the whole retained window.
+*
+* Not a tuning knob and not a second ceiling — it is the recorder saying "as
+* much as you kept", the only correct answer for a writer whose keep gate is
+* itself derived from {@link PREBUFFER_MAX_MS} (D381). A narrower request would
+* write a segment that begins after media the broker was holding for it.
+*/
+var RECORDING_PRE_ROLL_REQUEST_MS = PREBUFFER_MAX_MS;
+/**
+* A request the ring could conceivably answer, or `0`.
+*
+* Clamped at {@link PREBUFFER_MAX_MS} — the widest window any prebuffer holds —
+* so a hand-typed or corrupted path cannot name a number the mechanics
+* downstream would then have to defend against. Anything unparseable is `0` and
+* never "everything": an amount nobody can read is not a declaration.
+*/
+function clampRequest(value) {
+	if (!Number.isFinite(value) || value <= 0) return 0;
+	return Math.min(PREBUFFER_MAX_MS, Math.floor(value));
+}
+/**
+* Render an amount as the request segment, or as nothing at all.
+*
+* A zero request appends NOTHING rather than `/preroll-0`: the two mean the
+* same thing, and a path with two spellings is a path with two parsers.
+*/
+function requestSegment(requestMs) {
+	const ms = clampRequest(requestMs);
+	return ms > 0 ? `${PRE_ROLL_REQUEST_PREFIX}${ms}` : "";
+}
+/** Split a trailing `/preroll-<ms>` off a path: the rest, and the amount. */
+function splitRequest(streamPath) {
+	const at = streamPath.lastIndexOf(PRE_ROLL_REQUEST_PREFIX);
+	if (at < 0) return {
+		rest: streamPath,
+		requestMs: 0
+	};
+	const digits = streamPath.slice(at + 9);
+	if (!/^\d+$/.test(digits)) return {
+		rest: streamPath.slice(0, at),
+		requestMs: 0
+	};
+	return {
+		rest: streamPath.slice(0, at),
+		requestMs: clampRequest(Number(digits))
+	};
+}
+/**
+* Split a restream request path (already stripped of `rtsp://host:port/` and of
+* any `/trackID=N` control suffix) into its token, mute bit and declaration.
+*
+* The request segment is read FIRST because it is always last on the wire, and
+* an amount with no intent in front of it is discarded: history is served on
+* the strength of a declared purpose, so a bare number has nothing to attach
+* to and the token keeps whatever it was called.
+*/
+function parseRestreamPath(streamPath) {
+	const { rest, requestMs } = splitRequest(streamPath);
+	const declare = (intent) => ({
+		intent,
+		preRollRequestMs: requestMs
+	});
+	if (rest.endsWith("/recording")) return {
+		lookupPath: rest.slice(0, -10),
+		muted: false,
+		declaration: declare("recording")
+	};
+	if (rest.endsWith("/muted-detection")) return {
+		lookupPath: rest.slice(0, -16),
+		muted: true,
+		declaration: declare("detection")
+	};
+	if (rest.endsWith("/muted")) return {
+		lookupPath: rest.slice(0, -6),
+		muted: true,
+		declaration: NO_DECLARATION
+	};
+	return {
+		lookupPath: streamPath,
+		muted: false,
+		declaration: NO_DECLARATION
+	};
+}
+/**
+* The amount a dial URL asks for, read back off the URL itself.
+*
+* For the LOG on the consumer's side. The runner's
+* `session-decode: detection first frame` line has to be able to say what this
+* attach asked for, and reading it off the string that was actually dialed —
+* rather than off the constant the caller meant to pass — is what makes the
+* line evidence instead of a restatement of intent.
+*/
+function preRollRequestOf(restreamUrl) {
+	return splitRequest(restreamUrl).requestMs;
+}
+/**
+* Rewrite an acquired restream URL to declare the detection intent and the
+* history it asks for.
+*
+* `requestMs` is REQUIRED. It used to be absent, and absent meant the whole
+* retained window — the defect D382 removes. `0` is a legitimate, explicit
+* "none": the session still declares detection, which is what lifts the
+* live-edge withhold it dialed this path for in the first place.
+*
+* Only a MUTED url is rewritten. `resolveSourceUrl` falls back to the
+* audio-bearing url when the broker has no muted variant; that session is not
+* muted, the live-edge withhold never applied to it, and appending the suffix
+* would only break the token lookup. Idempotent, amount included.
+*/
+function withDetectionIntent(restreamUrl, requestMs) {
+	const { rest } = splitRequest(restreamUrl);
+	if (rest.endsWith("/muted-detection")) return `${rest}${requestSegment(requestMs)}`;
+	if (!rest.endsWith("/muted")) return restreamUrl;
+	return `${rest.slice(0, -6)}${DETECTION_MUTED_PATH_SUFFIX}${requestSegment(requestMs)}`;
+}
+/**
+* Rewrite an acquired restream URL to declare the RECORDING intent and the
+* history it asks for.
+*
+* The mirror image of {@link withDetectionIntent}'s guard: only a NON-muted url
+* is rewritten. A recorder handed the muted variant (a device with no audio, or
+* `audio: 'none'`) is already the detection population's shape, and appending
+* this suffix would only break the token lookup. Idempotent, amount included.
+*/
+function withRecordingIntent(restreamUrl, requestMs) {
+	const { rest } = splitRequest(restreamUrl);
+	if (rest.endsWith("/muted") || rest.endsWith("/muted-detection")) return restreamUrl;
+	if (rest.endsWith("/recording")) return `${rest}${requestSegment(requestMs)}`;
+	return `${rest}${RECORDING_PATH_SUFFIX}${requestSegment(requestMs)}`;
+}
+//#endregion
+Object.defineProperty(exports, "DETECTION_PRE_ROLL_REQUEST_MS", {
+	enumerable: true,
+	get: function() {
+		return DETECTION_PRE_ROLL_REQUEST_MS;
+	}
+});
+Object.defineProperty(exports, "NO_DECLARATION", {
+	enumerable: true,
+	get: function() {
+		return NO_DECLARATION;
+	}
+});
+Object.defineProperty(exports, "PREBUFFER_MAX_MS", {
+	enumerable: true,
+	get: function() {
+		return PREBUFFER_MAX_MS;
+	}
+});
+Object.defineProperty(exports, "RECORDING_PRE_ROLL_REQUEST_MS", {
+	enumerable: true,
+	get: function() {
+		return RECORDING_PRE_ROLL_REQUEST_MS;
+	}
+});
+Object.defineProperty(exports, "capPreRollRequestMs", {
+	enumerable: true,
+	get: function() {
+		return capPreRollRequestMs;
+	}
+});
+Object.defineProperty(exports, "parseRestreamPath", {
+	enumerable: true,
+	get: function() {
+		return parseRestreamPath;
+	}
+});
+Object.defineProperty(exports, "preRollRequestOf", {
+	enumerable: true,
+	get: function() {
+		return preRollRequestOf;
+	}
+});
+Object.defineProperty(exports, "prebufferRetentionMs", {
+	enumerable: true,
+	get: function() {
+		return prebufferRetentionMs;
+	}
+});
+Object.defineProperty(exports, "resolvePrebuffer", {
+	enumerable: true,
+	get: function() {
+		return resolvePrebuffer;
+	}
+});
+Object.defineProperty(exports, "withDetectionIntent", {
+	enumerable: true,
+	get: function() {
+		return withDetectionIntent;
+	}
+});
+Object.defineProperty(exports, "withRecordingIntent", {
+	enumerable: true,
+	get: function() {
+		return withRecordingIntent;
+	}
+});

package/dist/restream-intent-DWe2kInY.mjs

@@ -0,0 +1,248 @@
+/** {@link PREBUFFER_MAX_SEC} in ms — the widest window any consumer can be served. */
+var PREBUFFER_MAX_MS = 15 * 1e3;
+/** Clamp an enabled window's seconds into `[MIN, MAX]`; `0`/invalid means off. */
+function clampSeconds(value) {
+	if (value === void 0) return 5;
+	if (!Number.isFinite(value) || value <= 0) return 0;
+	return Math.min(15, Math.max(1, value));
+}
+/** `enabled: false` is the only representation of off — never `seconds: 0` alone. */
+var OFF = {
+	enabled: false,
+	seconds: 0
+};
+/**
+* The ONE prebuffer decision.
+*
+* Precedence: explicit per-stream override -> battery / terminal relay (off) ->
+* the profile's warm default -> off. Every layer that used to make this
+* decision somewhere else — `isDefaultWarm`, `applyPreBufferConfig`,
+* `getEffectivePreBufferSec`, `resolvePreRollMs`, `resolveRecordingPreRollMs` —
+* is this function now, so the four of them cannot disagree about one camera.
+*/
+function resolvePrebuffer(input) {
+	const override = input.overrides?.[input.camStreamId];
+	if (override !== void 0) {
+		if (!override.enabled) return OFF;
+		const seconds = clampSeconds(override.seconds);
+		return seconds > 0 ? {
+			enabled: true,
+			seconds
+		} : OFF;
+	}
+	if (input.batteryOperated === true) return OFF;
+	if (input.terminalRelay === true) return OFF;
+	if (input.defaultWarm !== true) return OFF;
+	const seconds = clampSeconds(input.clusterSeconds);
+	return seconds > 0 ? {
+		enabled: true,
+		seconds
+	} : OFF;
+}
+/** The retention, in ms — the single number the ring is trimmed to. */
+function prebufferRetentionMs(config) {
+	return config.enabled ? config.seconds * 1e3 : 0;
+}
+/**
+* What a consumer asking for `requestedMs` of history is actually served.
+*
+* The cap is the point of the record: a consumer states a WISH and the ring
+* states the truth.
+*
+* `requestedMs` is REQUIRED, and `0` means none (D382). It used to accept
+* `undefined` for "whatever you have", which is how every detection dial came
+* to be served the whole retained window: detection declares an intent for an
+* unrelated reason (the live-edge exemption) and never named an amount, so the
+* omission decided for it. A parameter that can be left out is a default that
+* acts without anybody choosing it — the shape D381 retired for the retention
+* and this one retires for the ask.
+*
+* A nonsense request resolves to `0`, never to the whole window: an
+* unparseable number arriving on a dial path must not be able to widen a burst.
+*/
+function capPreRollRequestMs(requestedMs, retainedMs) {
+	const retained = Number.isFinite(retainedMs) && retainedMs > 0 ? retainedMs : 0;
+	if (retained === 0) return 0;
+	if (!Number.isFinite(requestedMs) || requestedMs <= 0) return 0;
+	return Math.min(requestedMs, retained);
+}
+/**
+* Path suffix for the audio-free variant dialed by a DETECTION decode session.
+* Muted in every respect (no audio, still `isMuted()`), plus exempt from the
+* live-edge join withhold.
+*/
+var DETECTION_MUTED_PATH_SUFFIX = "/muted-detection";
+/**
+* Path suffix for a RECORDING dial — the `events`-band recorder's ffmpeg.
+*
+* NOT muted: a recording keeps its audio, so this cannot ride the detection
+* suffix. What it shares with detection is the reason for existing — it attaches
+* AFTER the trigger, so without the retained history its footage begins after
+* the event. Measured on camera 1438 (audit 2026-08-20): the footage started
+* after the motion in 60 % of episodes, because the writer is spawned at the
+* trigger and ffmpeg's first frame is at best the live edge.
+*/
+var RECORDING_PATH_SUFFIX = "/recording";
+/**
+* Path segment prefix carrying the AMOUNT of retained history a dial asks for.
+*
+* A path segment and not a query string: the listen server matches the request
+* URI with a path regex and strips a trailing `/trackID=N`, so anything that is
+* not a segment would either break the token lookup or be dropped silently
+* between DESCRIBE and SETUP.
+*/
+var PRE_ROLL_REQUEST_PREFIX = "/preroll-";
+/** A dial that declared nothing: no purpose, no history. */
+var NO_DECLARATION = {
+	intent: null,
+	preRollRequestMs: 0
+};
+/**
+* What the DETECTION dial asks for.
+*
+* {@link PREBUFFER_MAX_MS} — "whatever you retain" — which is byte-for-byte
+* what D381 served this population by omission, so the ask becomes explicit
+* without the behaviour changing under an operator who was never asked. It is a
+* REQUEST, not a configuration: `capPreRollRequestMs` answers it with the
+* smaller of this and what the ring holds, and the prebuffer stays the only
+* place the amount of history is decided.
+*
+* Whether detection should ask for LESS is an operator's call on measured
+* numbers, not something a session decides for itself. The per-attach evidence
+* is the broker's `restream attach live-edge` line and the runner's
+* `session-decode: detection first frame`, which now names this request.
+*/
+var DETECTION_PRE_ROLL_REQUEST_MS = PREBUFFER_MAX_MS;
+/**
+* What the RECORDING dial asks for: the whole retained window.
+*
+* Not a tuning knob and not a second ceiling — it is the recorder saying "as
+* much as you kept", the only correct answer for a writer whose keep gate is
+* itself derived from {@link PREBUFFER_MAX_MS} (D381). A narrower request would
+* write a segment that begins after media the broker was holding for it.
+*/
+var RECORDING_PRE_ROLL_REQUEST_MS = PREBUFFER_MAX_MS;
+/**
+* A request the ring could conceivably answer, or `0`.
+*
+* Clamped at {@link PREBUFFER_MAX_MS} — the widest window any prebuffer holds —
+* so a hand-typed or corrupted path cannot name a number the mechanics
+* downstream would then have to defend against. Anything unparseable is `0` and
+* never "everything": an amount nobody can read is not a declaration.
+*/
+function clampRequest(value) {
+	if (!Number.isFinite(value) || value <= 0) return 0;
+	return Math.min(PREBUFFER_MAX_MS, Math.floor(value));
+}
+/**
+* Render an amount as the request segment, or as nothing at all.
+*
+* A zero request appends NOTHING rather than `/preroll-0`: the two mean the
+* same thing, and a path with two spellings is a path with two parsers.
+*/
+function requestSegment(requestMs) {
+	const ms = clampRequest(requestMs);
+	return ms > 0 ? `${PRE_ROLL_REQUEST_PREFIX}${ms}` : "";
+}
+/** Split a trailing `/preroll-<ms>` off a path: the rest, and the amount. */
+function splitRequest(streamPath) {
+	const at = streamPath.lastIndexOf(PRE_ROLL_REQUEST_PREFIX);
+	if (at < 0) return {
+		rest: streamPath,
+		requestMs: 0
+	};
+	const digits = streamPath.slice(at + 9);
+	if (!/^\d+$/.test(digits)) return {
+		rest: streamPath.slice(0, at),
+		requestMs: 0
+	};
+	return {
+		rest: streamPath.slice(0, at),
+		requestMs: clampRequest(Number(digits))
+	};
+}
+/**
+* Split a restream request path (already stripped of `rtsp://host:port/` and of
+* any `/trackID=N` control suffix) into its token, mute bit and declaration.
+*
+* The request segment is read FIRST because it is always last on the wire, and
+* an amount with no intent in front of it is discarded: history is served on
+* the strength of a declared purpose, so a bare number has nothing to attach
+* to and the token keeps whatever it was called.
+*/
+function parseRestreamPath(streamPath) {
+	const { rest, requestMs } = splitRequest(streamPath);
+	const declare = (intent) => ({
+		intent,
+		preRollRequestMs: requestMs
+	});
+	if (rest.endsWith("/recording")) return {
+		lookupPath: rest.slice(0, -10),
+		muted: false,
+		declaration: declare("recording")
+	};
+	if (rest.endsWith("/muted-detection")) return {
+		lookupPath: rest.slice(0, -16),
+		muted: true,
+		declaration: declare("detection")
+	};
+	if (rest.endsWith("/muted")) return {
+		lookupPath: rest.slice(0, -6),
+		muted: true,
+		declaration: NO_DECLARATION
+	};
+	return {
+		lookupPath: streamPath,
+		muted: false,
+		declaration: NO_DECLARATION
+	};
+}
+/**
+* The amount a dial URL asks for, read back off the URL itself.
+*
+* For the LOG on the consumer's side. The runner's
+* `session-decode: detection first frame` line has to be able to say what this
+* attach asked for, and reading it off the string that was actually dialed —
+* rather than off the constant the caller meant to pass — is what makes the
+* line evidence instead of a restatement of intent.
+*/
+function preRollRequestOf(restreamUrl) {
+	return splitRequest(restreamUrl).requestMs;
+}
+/**
+* Rewrite an acquired restream URL to declare the detection intent and the
+* history it asks for.
+*
+* `requestMs` is REQUIRED. It used to be absent, and absent meant the whole
+* retained window — the defect D382 removes. `0` is a legitimate, explicit
+* "none": the session still declares detection, which is what lifts the
+* live-edge withhold it dialed this path for in the first place.
+*
+* Only a MUTED url is rewritten. `resolveSourceUrl` falls back to the
+* audio-bearing url when the broker has no muted variant; that session is not
+* muted, the live-edge withhold never applied to it, and appending the suffix
+* would only break the token lookup. Idempotent, amount included.
+*/
+function withDetectionIntent(restreamUrl, requestMs) {
+	const { rest } = splitRequest(restreamUrl);
+	if (rest.endsWith("/muted-detection")) return `${rest}${requestSegment(requestMs)}`;
+	if (!rest.endsWith("/muted")) return restreamUrl;
+	return `${rest.slice(0, -6)}${DETECTION_MUTED_PATH_SUFFIX}${requestSegment(requestMs)}`;
+}
+/**
+* Rewrite an acquired restream URL to declare the RECORDING intent and the
+* history it asks for.
+*
+* The mirror image of {@link withDetectionIntent}'s guard: only a NON-muted url
+* is rewritten. A recorder handed the muted variant (a device with no audio, or
+* `audio: 'none'`) is already the detection population's shape, and appending
+* this suffix would only break the token lookup. Idempotent, amount included.
+*/
+function withRecordingIntent(restreamUrl, requestMs) {
+	const { rest } = splitRequest(restreamUrl);
+	if (rest.endsWith("/muted") || rest.endsWith("/muted-detection")) return restreamUrl;
+	if (rest.endsWith("/recording")) return `${rest}${requestSegment(requestMs)}`;
+	return `${rest}${RECORDING_PATH_SUFFIX}${requestSegment(requestMs)}`;
+}
+//#endregion
+export { preRollRequestOf as a, PREBUFFER_MAX_MS as c, resolvePrebuffer as d, parseRestreamPath as i, capPreRollRequestMs as l, NO_DECLARATION as n, withDetectionIntent as o, RECORDING_PRE_ROLL_REQUEST_MS as r, withRecordingIntent as s, DETECTION_PRE_ROLL_REQUEST_MS as t, prebufferRetentionMs as u };

package/dist/{prebuffer-DmBYRQWg.mjs → retire-root-keys-Csb8z2f3.js}

@@ -323,68 +323,16 @@ function isRecord(value) {
 function errText(err) {
 	return err instanceof Error ? err.message : String(err);
 }
-/** {@link PREBUFFER_MAX_SEC} in ms — the widest window any consumer can be served. */
-var PREBUFFER_MAX_MS = 15 * 1e3;
-/** Clamp an enabled window's seconds into `[MIN, MAX]`; `0`/invalid means off. */
-function clampSeconds(value) {
-	if (value === void 0) return 5;
-	if (!Number.isFinite(value) || value <= 0) return 0;
-	return Math.min(15, Math.max(1, value));
-}
-/** `enabled: false` is the only representation of off — never `seconds: 0` alone. */
-var OFF = {
-	enabled: false,
-	seconds: 0
-};
-/**
-* The ONE prebuffer decision.
-*
-* Precedence: explicit per-stream override -> battery / terminal relay (off) ->
-* the profile's warm default -> off. Every layer that used to make this
-* decision somewhere else — `isDefaultWarm`, `applyPreBufferConfig`,
-* `getEffectivePreBufferSec`, `resolvePreRollMs`, `resolveRecordingPreRollMs` —
-* is this function now, so the four of them cannot disagree about one camera.
-*/
-function resolvePrebuffer(input) {
-	const override = input.overrides?.[input.camStreamId];
-	if (override !== void 0) {
-		if (!override.enabled) return OFF;
-		const seconds = clampSeconds(override.seconds);
-		return seconds > 0 ? {
-			enabled: true,
-			seconds
-		} : OFF;
-	}
-	if (input.batteryOperated === true) return OFF;
-	if (input.terminalRelay === true) return OFF;
-	if (input.defaultWarm !== true) return OFF;
-	const seconds = clampSeconds(input.clusterSeconds);
-	return seconds > 0 ? {
-		enabled: true,
-		seconds
-	} : OFF;
-}
-/** The retention, in ms — the single number the ring is trimmed to. */
-function prebufferRetentionMs(config) {
-	return config.enabled ? config.seconds * 1e3 : 0;
-}
-/**
-* What a consumer asking for `requestedMs` of history is actually served.
-*
-* The cap is the point of the record: a consumer states a WISH and the ring
-* states the truth. `undefined` means "whatever you have", which is what a
-* consumer that configures nothing asks for — and is why the recorder no
-* longer carries a duration of its own.
-*
-* A nonsense request resolves to `0`, never to the whole window: an
-* unparseable number arriving on a dial path must not be able to widen a burst.
-*/
-function capPreRollRequestMs(requestedMs, retainedMs) {
-	const retained = Number.isFinite(retainedMs) && retainedMs > 0 ? retainedMs : 0;
-	if (retained === 0) return 0;
-	if (requestedMs === void 0) return retained;
-	if (!Number.isFinite(requestedMs) || requestedMs <= 0) return 0;
-	return Math.min(requestedMs, retained);
-}
 //#endregion
-export { retireRootKeys as a, resolvePrebuffer as i, capPreRollRequestMs as n, RowMapStore as o, prebufferRetentionMs as r, PREBUFFER_MAX_MS as t };
+Object.defineProperty(exports, "RowMapStore", {
+	enumerable: true,
+	get: function() {
+		return RowMapStore;
+	}
+});
+Object.defineProperty(exports, "retireRootKeys", {
+	enumerable: true,
+	get: function() {
+		return retireRootKeys;
+	}
+});