@camstack/addon-post-analysis 1.2.298 → 1.2.300

package/dist/{clip-model-registry-olxNKN7T.js → clip-model-registry-BeJUe0vk.js}

@@ -7660,7 +7660,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-BK-GTFYb.mjs
+//#region ../types/dist/composition-Dq42XWp0.mjs
 /**
 * Deterministic SHA-256 hash of an arbitrary serialisable value. The
 * canonical form sorts object keys alphabetically at every depth so two
@@ -7693,6 +7693,58 @@ function replaceWithSortedKeys(_key, value) {
 	return value;
 }
 /**
+* The ffmpeg build every CamStack node downloads, per platform and arch.
+*
+* ## Why a download, on every node, including the container
+*
+* The version of ffmpeg used to be CODE: baked into the image, changeable only
+* by rebuilding and rolling it. Now it is DATA — this file states the release,
+* and a node that boots with a different one downloads it. Changing ffmpeg is a
+* framework bump, not an image rebuild.
+*
+* It also settles the licence question by removing it. FFmpeg's licence is
+* chosen at compile time: the core is LGPL 2.1+, `--enable-gpl` makes it GPL
+* (for x264/x265), `--enable-version3` makes that v3, and `--enable-nonfree`
+* makes the result undistributable. These are GPL v3 builds, and we do not
+* distribute them: the user's own node fetches the archive from the project
+* that publishes it, so we convey no GPL work and inherit none of the
+* obligations that come with conveying one. That is the whole reason the image
+* no longer installs ffmpeg at all — not a technical preference.
+*
+* ## Why jellyfin-ffmpeg
+*
+* One vendor covering linux-amd64, linux-arm64, darwin-arm64 and darwin-x64
+* from one release, with the widest hardware surface of anything maintained:
+* VAAPI, QSV, NVENC/NVDEC, AMF, Vulkan, OpenCL and DRM on amd64, plus Rockchip
+* MPP on arm64. It reaches the vendor libraries through dlopen trampolines,
+* so the binary is not linked against a driver stack it may not find.
+*
+* **What it still needs from the host, measured 2026-09-19.** On the Unraid
+* HOST, which has no libva, `-vaapi_device` aborts the process outright —
+* `implib-gen: libva-drm.so.2: failed to load library ... Assertion '0 &&
+* "Assertion in generated code"' failed`. Inside our container, which installs
+* libva plus the iHD driver, the same command encodes: verified end to end with
+* `testsrc → format=nv12,hwupload → h264_vaapi`. So the image drops ffmpeg and
+* KEEPS the Intel media stack; the drivers are the part a binary cannot bring.
+*
+* ## Why each artifact carries a checksum and a claim
+*
+* The download is now the only source, so `sha256` is verified before anything
+* is extracted — jellyfin publishes no checksums on its release assets, so
+* these are ours, taken at the version bump. And `expectedHwaccels` is what the
+* build is supposed to be able to do: a binary that probes short of its own
+* claim is a source that changed under us, which is precisely what went
+* unnoticed for months when a static build turned out to carry no VAAPI at all
+* (D536).
+*/
+/** The pinned jellyfin-ffmpeg release. Changing this is the version change. */
+var FFMPEG_RELEASE = "8.1.2-5";
+var BASE = `https://github.com/jellyfin/jellyfin-ffmpeg/releases/download/v${FFMPEG_RELEASE}`;
+function portable(target) {
+	return `${BASE}/jellyfin-ffmpeg_${FFMPEG_RELEASE}_portable_${target}-gpl.tar.xz`;
+}
+portable("linux64"), portable("linuxarm64"), portable("macarm64"), portable("mac64");
+/**
 * LA tabella "quale booleano di questo tipo di device conta come ALTO", e il
 * valutatore puro del suo FRONTE.
 *
@@ -8781,6 +8833,110 @@ var BASE_LIVE_EGRESS_PROFILE = {
 ({ ...BASE_LIVE_EGRESS_PROFILE }), { ...BASE_LIVE_EGRESS_PROFILE.video };
 ({ ...BASE_LIVE_EGRESS_PROFILE }), { ...BASE_LIVE_EGRESS_PROFILE.video };
 /**
+* The notification GIF's filter chain and argv — ONE definition for every
+* process that derives a gif from a notification video.
+*
+* ## Why this lives in `@camstack/types`
+*
+* Two addons derive a notification gif from an mp4, and they may never import
+* each other:
+*
+*  - the stream broker (`addon-pipeline`), from the clip it just cut out of its
+*    own ring (`gif-from-mp4.ts`);
+*  - the notification centre (`addon-post-analysis`), from a clip cut out of
+*    the RECORDINGS when the moment is older than any ring holds
+*    ([D682](../../../../docs/decisions/adr-0682-a-pick-ups-footage-is-cut-around-the-pick-up.md)).
+*
+* Two copies of this chain would be two gifs of the same kind of moment that
+* look different depending on how old the moment was — the class of defect
+* D85/D91 already paid for once. So the chain is here, pure and dependency
+* free, and each caller owns only its own process lifecycle.
+*
+* ## The palette was never the problem
+*
+* The `split` + `palettegen(stats_mode=diff)` + `paletteuse(bayer)` pair is
+* right and stays. The measured cause of "the gif looks de-pixellated" was a
+* 640×360 substream scaled DOWN to 480 px, upstream of the palette. The `split`
+* form is a single READ of the input, not a lesser two-pass.
+*/
+/**
+* Format a frame rate for an ffmpeg filter argument.
+*
+* `12 / 4` must reach the filter as `3` and `15 / 4` as `3.75`, not as a float
+* tail that `av_parse_video_rate` then has to guess at.
+*/
+function ffmpegRate(rate) {
+	return String(Math.round(rate * 1e3) / 1e3);
+}
+/**
+* The factor the derive must apply ON TOP of the speed the mp4 already carries.
+*
+* The gif is derived from a muxed mp4, so if that mux already ran `setpts` at
+* the caller's `speed`, applying the absolute gif rate again would compound
+* them — a 4× gif beside a 2× video would come out at 8×. Discounting here is
+* what keeps the gif rate ABSOLUTE against real time whatever the video does.
+*/
+function gifDeriveSpeed(gifSpeed, videoSpeed) {
+	if (!Number.isFinite(videoSpeed) || videoSpeed <= 0) return gifSpeed;
+	return gifSpeed / videoSpeed;
+}
+/**
+* The filter chain. Extracted so a test can assert the palette pair without
+* spawning ffmpeg — an argv test cannot see quality, but it can see a filter
+* that somebody deleted.
+*
+* `fps` BEFORE `setpts`: decimating an already sped-up timeline yields `speed`
+* times the frames asked for, and a gif pays for every one. So the decimation
+* runs at `fps / speed` in SOURCE time and `setpts` multiplies what survived.
+* The trailing `fps` re-declares the rate, which is NOT redundant: `setpts`
+* leaves the filter link advertising the sampled rate and the gif muxer
+* believes the link — measured on 615 as a 3.01 s gif of ten frames.
+*/
+function gifFilterComplex(input) {
+	const speed = input.speed > 0 ? input.speed : 1;
+	if (speed === 1) return `[0:v]fps=${ffmpegRate(input.fps)},scale=${input.maxWidth}:-2:flags=lanczos,split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle`;
+	return `[0:v]fps=${ffmpegRate(input.fps / speed)},setpts=PTS/${speed},fps=${ffmpegRate(input.fps)},scale=${input.maxWidth}:-2:flags=lanczos,split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle`;
+}
+/** The full argv: mp4 in, gif on stdout. */
+function gifFromMp4Args(input) {
+	return [
+		"-y",
+		"-v",
+		"error",
+		"-f",
+		"mp4",
+		"-i",
+		input.input ?? "pipe:0",
+		"-filter_complex",
+		gifFilterComplex(input),
+		"-loop",
+		"0",
+		"-f",
+		"gif",
+		"pipe:1"
+	];
+}
+/**
+* Memoize `ensure` on SUCCESS only.
+*
+* A failure is not remembered: the next caller asks again, so a node whose
+* first download failed (no network at boot) recovers on the next spawn that
+* needs it — with no timer and no retry loop, because the ask is driven by
+* work that actually wants the binary.
+*/
+function memoizePinnedFfmpeg(ensure) {
+	let pending = null;
+	return () => {
+		if (pending !== null) return pending;
+		const attempt = ensure();
+		pending = attempt;
+		attempt.catch(() => {
+			if (pending === attempt) pending = null;
+		});
+		return attempt;
+	};
+}
+/**
 * Deep wiring healthcheck — snapshot of active reachability probes across
 * every declared capability + widget of every installed plugin, on every
 * node. Produced by the backend `WiringHealthService` and surfaced via
@@ -9195,6 +9351,8 @@ var DETECTION_PIPELINE_CAP_NAME = "detection-pipeline";
 * oldest-first on append.
 */
 var MAX_BIRTH_DECISION_RECORDS = 3e4;
+/** Default page size for `listBirthDecisions` when the caller omits one. */
+var BIRTH_DECISION_DEFAULT_LIMIT = 500;
 /**
 * How stale a motion onset may be and still be offered as the birth-latency
 * proxy. Beyond this the row records `null`, never a large number.
@@ -9407,6 +9565,8 @@ var BirthDecisionQueryInputSchema = object({
 * `tracks` table measured at 4.6 MB for a single 501-row page.
 */
 var MAX_ARCHIVED_DEBUG_NOTES = 5e3;
+/** Default page size for `listArchivedDebugNotes` when the caller omits one. */
+var ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT = 200;
 /** One archived note — the operator's words plus enough context to find what
 *  they were looking at, after the track itself is gone. */
 var ArchivedDebugNoteSchema = object({
@@ -9496,6 +9656,8 @@ var OpsLogQueryInputSchema = object({
 	/** Max rows returned, newest-first. */
 	limit: number().int().min(1).max(1e3).optional()
 });
+/** Default page size for a `listOpsLog` query when the caller omits `limit`. */
+var OPS_LOG_DEFAULT_LIMIT = 200;
 var LabelDefinitionSchema = object({
 	id: string(),
 	name: string(),
@@ -19111,6 +19273,12 @@ var NC_TANK_SYSTEM_EVENT_KINDS = [
 	"device-tank-normal"
 ];
 /**
+* The consumable threshold a rule that does not state one judges at (D642).
+* The operator's number ("default 15 %, configurable on the rule"), and the
+* value the cluster-wide setting it replaces shipped with.
+*/
+var NC_CONSUMABLE_LOW_PERCENT_DEFAULT = 15;
+/**
 * One coherent system-event condition. `kinds` is the required opt-in safety
 * gate; the remaining lists are optional narrowing filters relevant to the
 * selected kinds.
@@ -19803,6 +19971,24 @@ var NcMediaFrameSchema = _enum([
 * sensor linked to one camera ships that camera's plain snapshot either way.
 */
 var NcLinkedCameraModeSchema = _enum(["mosaic", "each"]);
+/**
+* The clip window a rule gets when it stores no `clipPreRollSec` /
+* `clipPostRollSec` (D654): 4 s before the moment, 6 s after.
+*
+* THE one owner. The Notification Center resolves an absent roll to these at
+* dispatch and sizes the broker's clip ring from them (`clip-retention-ask`).
+* The admin editor does not author the roll; the viewer editor still keeps its
+* own 3 / 7 until it imports these (viewer follow-up). A second copy is how the
+* viewer came to display 3 / 7 — copied from a stale comment on the schema
+* below — while the hub cut 4 / 6, and to prune a typed 3 back to "absent",
+* which the hub then read as 4.
+*
+* A product decision of the notification, not the broker's history window
+* (D381/D382): the clip is cut from the broker's per-camera clip ring, which
+* the rules size, not from a pre-roll dial.
+*/
+var NC_CLIP_PRE_ROLL_DEFAULT_SEC = 4;
+var NC_CLIP_POST_ROLL_DEFAULT_SEC = 6;
 var NcMediaPolicySchema = object({
 	attach: _enum([
 		"best",
@@ -21335,6 +21521,24 @@ var NcAlarmConfigSchema = object({
 	live: NcAlarmLiveSchema.optional()
 });
 /**
+* The most seconds of footage any notification rule may ask a camera to retain.
+*
+* Sixty, and it is the OCCUPANCY number. An occupancy edge is confirmed by an
+* independent read that lands long after the fact (D279) plus the condition's
+* own `sustainSeconds` (29 s on this hub), so its clip is anchored well in the
+* past — and the other source, the recordings, cannot cover a recent moment:
+* measured against `recording.getAvailability` for a 10 s window at several
+* anchors, full coverage arrived at −18 s on device 590 and −26 s on 615 and
+* 617. That edge is a PHASE of the 10-second segment cycle, not a number. The
+* ring therefore has to hold the moment until the recordings can take it over:
+* the worst measured phase (26 s) plus the confirmation lag (29 s) is 55 s, and
+* 60 is the round number above it.
+*
+* It is a ceiling, not a default. Every other rule kind asks for its own window
+* plus the dispatch margin, which is roughly a third of this.
+*/
+var NC_CLIP_RETENTION_MAX_SEC = 60;
+/**
 * ONE rule's demand on ONE camera's clip ring.
 *
 * A rule, not a camera: the broker takes the MAX over the asks that reach a
@@ -23012,6 +23216,21 @@ var ObjectEventSchema = object({
 	keyFrameMediaId: number().int().optional(),
 	/** Populated by B5 (recording playback URL for this event). */
 	mediaUrl: string().optional(),
+	/**
+	* When the change this row records HAPPENED, epoch ms, when that is earlier
+	* than {@link timestamp} and the producer could date it (D684).
+	*
+	* Set on a package PICK-UP row only: its `timestamp` is when the departure
+	* was CONCLUDED — five minutes of unseen observed time after the parcel went
+	* — and a notification's footage has to be cut around the pick-up, not the
+	* empty doormat after it (D682). Stored so every path that rebuilds a
+	* notification subject from the row (the boot reconcile, a dry-run) anchors
+	* on the same instant the live hook did.
+	*
+	* `timestamp` keeps its meaning. Absent on every other row and on every
+	* pick-up written before D684 — UNKNOWN, never 0 and never `timestamp`.
+	*/
+	observedAt: number().optional(),
 	/** The parent track's key-event importance [0,1], propagated to every object
 	*  event of the track (so an event row can be sorted by importance without a
 	*  track join). Absent on legacy rows / before the track was scored. */
@@ -23427,6 +23646,21 @@ var EventDensityBucketSchema = object({
 	audioDbfs: number().optional()
 });
 /**
+* Most cameras one `getEventDensityBatch` may name.
+*
+* The same ceiling the sibling batches on this cap already carry
+* (`listEventKindsBatch`, `getKeyEventsBatch`): a tablet grid is tens of
+* cameras, never hundreds, and one call's answer is N × (window / bucketMs)
+* buckets crossing a process boundary.
+*
+* The ceiling is on the SCHEMA, not only on the caller. An over-eager ask is
+* REFUSED — never truncated to the first {@link EVENT_DENSITY_BATCH_MAX} ids,
+* because that answer is indistinguishable from a complete one and the caller
+* would never learn it asked too much. A caller with more cameras sends
+* ⌈n/max⌉ calls.
+*/
+var EVENT_DENSITY_BATCH_MAX = 200;
+/**
 * One camera's row in a `getEventDensityBatch` answer.
 *
 * TWO facts, and the timeline draws them differently:
@@ -37575,6 +37809,16 @@ var ExportDenseRangeSchema = object({
 	toSec: number().nonnegative()
 }).refine((r) => r.toSec > r.fromSec, { message: "dense range must have toSec > fromSec" });
 /**
+* Hard ceiling on dense ranges in ONE render.
+*
+* The ranges become terms of a single ffmpeg `select` expression, so the count
+* is the length of a command-line argument. The producer (the timelapse
+* scheduler) coalesces and then falls back to the base cadence alone rather
+* than trimming — a truncated range list is a video that quietly omits the
+* evening.
+*/
+var EXPORT_DENSE_MAX_RANGES = 200;
+/**
 * Dense-interval overlay for a timelapse: sample at `dense.everyMs` INSIDE the
 * listed ranges and at the base `everyMs` everywhere else.
 *
@@ -38396,11 +38640,23 @@ var SceneCheckSchema = discriminatedUnion("mode", [object({
 	profileId: string().optional(),
 	hysteresisCount: number().int().positive()
 })]);
+/** Defaults, as CONSTANTS rather than only as Zod `.default()`. A Zod default
+*  does NOT run on the addon→addon cap path, so every runtime seam reads these
+*  as absent-with-a-constant (the `NcConfirmSchema` lesson, three production
+*  failures in one day). The schema defaults and these values are the same
+*  numbers on purpose. */
+var SCENE_DEFAULT_QUIET_SECONDS = 60;
+var SCENE_DEFAULT_OBSERVATION_SPACING_SEC = 120;
+var SCENE_DEFAULT_CHECK_INTERVAL_SEC = 60;
 var SCENE_DEFAULT_ANCHOR_THRESHOLD = .85;
 /** Night is OPTIONAL. A scene with only a daylight reference sits the IR hours
 *  out in silence rather than reporting a fault every night. */
 var SCENE_DEFAULT_UNCOVERED_POLICY = "skip";
 var SCENE_CONFIRM_DEFAULT_TIMEOUT_MS = 8e3;
+var SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX = 448;
+/** `resetScene({ recapture })` absent means TRUE — the operator decision. Read
+*  at the seam, because a Zod `.optional()` carries no default at all. */
+var SCENE_RESET_RECAPTURES = true;
 /**
 * Vision-model adjudication of a candidate flip. Field names deliberately
 * mirror `NcConfirmSchema` so an operator meets one vocabulary, not two.
@@ -52476,6 +52732,15 @@ function ituDbfsFromPreEpoch(law, authoredDbfs) {
 	return authoredDbfs + G711_SCALE_CORRECTION_DB[law];
 }
 Math.round(ituDbfsFromPreEpoch("PCMU", -55));
+/**
+* LABEL-mode confirm-count defaults. Chosen against the live "Pianti" rule
+* (2026-08-23): 15 notifies in 12 h, each a single YAMNet `crying` frame,
+* nobody actually crying. Two labelled frames in 5 s drops the single-frame
+* false positives and still catches a real episode (YAMNet labels 2–3
+* frames of a genuine cry).
+*/
+var NC_AUDIO_CONFIRM_HITS_DEFAULT = 2;
+var NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT = 5;
 /** Schema defaults — an untouched sub-field must author exactly these. */
 var NC_AUDIO_DEFAULTS = {
 	hitPercent: 60,
@@ -55283,6 +55548,12 @@ function buildClipModelRegistry(entries) {
 /** The built-in catalog's registry. */
 var BUILTIN_CLIP_MODELS = buildClipModelRegistry(CLIP_IMAGE_MODELS);
 //#endregion
+Object.defineProperty(exports, "ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT", {
+	enumerable: true,
+	get: function() {
+		return ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT;
+	}
+});
 Object.defineProperty(exports, "AUDIO_MACRO_LABELS", {
 	enumerable: true,
 	get: function() {
@@ -55301,6 +55572,12 @@ Object.defineProperty(exports, "ArchivedDebugNoteSchema", {
 		return ArchivedDebugNoteSchema;
 	}
 });
+Object.defineProperty(exports, "BIRTH_DECISION_DEFAULT_LIMIT", {
+	enumerable: true,
+	get: function() {
+		return BIRTH_DECISION_DEFAULT_LIMIT;
+	}
+});
 Object.defineProperty(exports, "BUILTIN_CLIP_MODELS", {
 	enumerable: true,
 	get: function() {
@@ -55427,6 +55704,12 @@ Object.defineProperty(exports, "EMBEDDING_REQUIREMENTS_UNAVAILABLE", {
 		return EMBEDDING_REQUIREMENTS_UNAVAILABLE;
 	}
 });
+Object.defineProperty(exports, "EVENT_DENSITY_BATCH_MAX", {
+	enumerable: true,
+	get: function() {
+		return EVENT_DENSITY_BATCH_MAX;
+	}
+});
 Object.defineProperty(exports, "EVENT_KIND_BY_CAP", {
 	enumerable: true,
 	get: function() {
@@ -55439,6 +55722,12 @@ Object.defineProperty(exports, "EVENT_OWNER_TYPES", {
 		return EVENT_OWNER_TYPES;
 	}
 });
+Object.defineProperty(exports, "EXPORT_DENSE_MAX_RANGES", {
+	enumerable: true,
+	get: function() {
+		return EXPORT_DENSE_MAX_RANGES;
+	}
+});
 Object.defineProperty(exports, "EventCategory", {
 	enumerable: true,
 	get: function() {
@@ -55523,12 +55812,48 @@ Object.defineProperty(exports, "NC_ALARM_SYSTEM_EVENT_KINDS", {
 		return NC_ALARM_SYSTEM_EVENT_KINDS;
 	}
 });
+Object.defineProperty(exports, "NC_AUDIO_CONFIRM_HITS_DEFAULT", {
+	enumerable: true,
+	get: function() {
+		return NC_AUDIO_CONFIRM_HITS_DEFAULT;
+	}
+});
+Object.defineProperty(exports, "NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT", {
+	enumerable: true,
+	get: function() {
+		return NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT;
+	}
+});
+Object.defineProperty(exports, "NC_CLIP_POST_ROLL_DEFAULT_SEC", {
+	enumerable: true,
+	get: function() {
+		return NC_CLIP_POST_ROLL_DEFAULT_SEC;
+	}
+});
+Object.defineProperty(exports, "NC_CLIP_PRE_ROLL_DEFAULT_SEC", {
+	enumerable: true,
+	get: function() {
+		return NC_CLIP_PRE_ROLL_DEFAULT_SEC;
+	}
+});
+Object.defineProperty(exports, "NC_CLIP_RETENTION_MAX_SEC", {
+	enumerable: true,
+	get: function() {
+		return NC_CLIP_RETENTION_MAX_SEC;
+	}
+});
 Object.defineProperty(exports, "NC_CONDITION_CATALOG", {
 	enumerable: true,
 	get: function() {
 		return NC_CONDITION_CATALOG;
 	}
 });
+Object.defineProperty(exports, "NC_CONSUMABLE_LOW_PERCENT_DEFAULT", {
+	enumerable: true,
+	get: function() {
+		return NC_CONSUMABLE_LOW_PERCENT_DEFAULT;
+	}
+});
 Object.defineProperty(exports, "NC_CONSUMABLE_SYSTEM_EVENT_KINDS", {
 	enumerable: true,
 	get: function() {
@@ -55685,6 +56010,12 @@ Object.defineProperty(exports, "NcTemplateVarDescriptorSchema", {
 		return NcTemplateVarDescriptorSchema;
 	}
 });
+Object.defineProperty(exports, "OPS_LOG_DEFAULT_LIMIT", {
+	enumerable: true,
+	get: function() {
+		return OPS_LOG_DEFAULT_LIMIT;
+	}
+});
 Object.defineProperty(exports, "OpsLogEntrySchema", {
 	enumerable: true,
 	get: function() {
@@ -55721,6 +56052,12 @@ Object.defineProperty(exports, "RetrainStatusSchema", {
 		return RetrainStatusSchema;
 	}
 });
+Object.defineProperty(exports, "SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX", {
+	enumerable: true,
+	get: function() {
+		return SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX;
+	}
+});
 Object.defineProperty(exports, "SCENE_CONFIRM_DEFAULT_TIMEOUT_MS", {
 	enumerable: true,
 	get: function() {
@@ -55733,6 +56070,24 @@ Object.defineProperty(exports, "SCENE_DEFAULT_ANCHOR_THRESHOLD", {
 		return SCENE_DEFAULT_ANCHOR_THRESHOLD;
 	}
 });
+Object.defineProperty(exports, "SCENE_DEFAULT_CHECK_INTERVAL_SEC", {
+	enumerable: true,
+	get: function() {
+		return SCENE_DEFAULT_CHECK_INTERVAL_SEC;
+	}
+});
+Object.defineProperty(exports, "SCENE_DEFAULT_OBSERVATION_SPACING_SEC", {
+	enumerable: true,
+	get: function() {
+		return SCENE_DEFAULT_OBSERVATION_SPACING_SEC;
+	}
+});
+Object.defineProperty(exports, "SCENE_DEFAULT_QUIET_SECONDS", {
+	enumerable: true,
+	get: function() {
+		return SCENE_DEFAULT_QUIET_SECONDS;
+	}
+});
 Object.defineProperty(exports, "SCENE_DEFAULT_UNCOVERED_POLICY", {
 	enumerable: true,
 	get: function() {
@@ -55745,6 +56100,12 @@ Object.defineProperty(exports, "SCENE_DIVERGED", {
 		return SCENE_DIVERGED;
 	}
 });
+Object.defineProperty(exports, "SCENE_RESET_RECAPTURES", {
+	enumerable: true,
+	get: function() {
+		return SCENE_RESET_RECAPTURES;
+	}
+});
 Object.defineProperty(exports, "SceneMonitorSchema", {
 	enumerable: true,
 	get: function() {
@@ -55973,6 +56334,18 @@ Object.defineProperty(exports, "failureContributionCapability", {
 		return failureContributionCapability;
 	}
 });
+Object.defineProperty(exports, "gifDeriveSpeed", {
+	enumerable: true,
+	get: function() {
+		return gifDeriveSpeed;
+	}
+});
+Object.defineProperty(exports, "gifFromMp4Args", {
+	enumerable: true,
+	get: function() {
+		return gifFromMp4Args;
+	}
+});
 Object.defineProperty(exports, "hydrateSchema", {
 	enumerable: true,
 	get: function() {
@@ -56057,6 +56430,12 @@ Object.defineProperty(exports, "mayWriteToLocation", {
 		return mayWriteToLocation;
 	}
 });
+Object.defineProperty(exports, "memoizePinnedFfmpeg", {
+	enumerable: true,
+	get: function() {
+		return memoizePinnedFfmpeg;
+	}
+});
 Object.defineProperty(exports, "nodePin", {
 	enumerable: true,
 	get: function() {

package/dist/embedding-encoder/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-olxNKN7T.js");
+const require_clip_model_registry = require("../clip-model-registry-BeJUe0vk.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs);
 let node_path = require("node:path");
@@ -328,6 +328,10 @@ var PythonRawTensorEngine = class {
 		await this.proc.dispose();
 	}
 };
+//#endregion
+//#region src/embedding-encoder/addon/active-clip-model.ts
+/** How long a cluster-row read is trusted. The operator's flip lands within this. */
+var ENCODER_ROW_TTL_MS = 3e4;
 var ActiveClipModel = class {
 	deps;
 	cached = null;
@@ -345,7 +349,7 @@ var ActiveClipModel = class {
 	}
 	async get() {
 		const now = this.deps.now();
-		if (this.cached !== null && now - this.cached.at < 3e4) return this.cached.modelId;
+		if (this.cached !== null && now - this.cached.at < ENCODER_ROW_TTL_MS) return this.cached.modelId;
 		const row = await this.deps.readRow();
 		if (row === null) {
 			const kept = this.lastRead ?? this.deps.fallbackModelId();
@@ -369,6 +373,10 @@ var ActiveClipModel = class {
 		return row;
 	}
 };
+//#endregion
+//#region src/embedding-encoder/addon/crash-budget.ts
+var MAX_CRASHES = 3;
+var CRASH_WINDOW_MS = 10 * 6e4;
 var CrashBudget = class {
 	deps;
 	recent = /* @__PURE__ */ new Map();
@@ -386,11 +394,11 @@ var CrashBudget = class {
 	record(modelId, reason) {
 		if (this.failedModels.has(modelId)) return false;
 		const now = this.now();
-		const windowMs = this.deps.windowMs ?? 6e5;
+		const windowMs = this.deps.windowMs ?? CRASH_WINDOW_MS;
 		const times = (this.recent.get(modelId) ?? []).filter((t) => now - t < windowMs);
 		times.push(now);
 		this.recent.set(modelId, times);
-		if (times.length < (this.deps.maxCrashes ?? 3)) return false;
+		if (times.length < (this.deps.maxCrashes ?? MAX_CRASHES)) return false;
 		const failed = {
 			modelId,
 			tower: this.deps.tower,
@@ -566,6 +574,13 @@ var ModelEngineSlot = class {
 		held.engine.dispose().catch(() => {});
 	}
 };
+//#endregion
+//#region src/embedding-encoder/addon/model-requirements.ts
+/** First cooldown after a failed attempt; doubles per failure up to the cap. */
+var REQUIREMENTS_COOLDOWN_BASE_MS = 5e3;
+var REQUIREMENTS_COOLDOWN_MAX_MS = 5 * 6e4;
+/** Failed attempts at a PERMANENTLY unmeetable requirement before it is terminal. */
+var MAX_REQUIREMENTS_ATTEMPTS = 3;
 /**
 * Thrown by the requirements stage when a retry can never help: the catalog
 * does not know the id, the server said the file does not exist (404/410), a
@@ -621,7 +636,7 @@ var RequirementsGate = class {
 		const attempts = (prior?.attempts ?? 0) + 1;
 		const permanent = isPermanentRequirementsFailure(err);
 		const permanentAttempts = (prior?.permanentAttempts ?? 0) + (permanent ? 1 : 0);
-		const cooldownMs = Math.min(this.deps.cooldownMaxMs ?? 3e5, (this.deps.cooldownBaseMs ?? 5e3) * 2 ** (attempts - 1));
+		const cooldownMs = Math.min(this.deps.cooldownMaxMs ?? REQUIREMENTS_COOLDOWN_MAX_MS, (this.deps.cooldownBaseMs ?? REQUIREMENTS_COOLDOWN_BASE_MS) * 2 ** (attempts - 1));
 		const base = {
 			sinceMs: prior?.sinceMs ?? now,
 			reason,
@@ -638,7 +653,7 @@ var RequirementsGate = class {
 			reason,
 			cooldownMs
 		} });
-		if (permanent && permanentAttempts >= (this.deps.maxAttempts ?? 3)) {
+		if (permanent && permanentAttempts >= (this.deps.maxAttempts ?? MAX_REQUIREMENTS_ATTEMPTS)) {
 			const terminal = {
 				...this.on(modelId),
 				attempts: permanentAttempts,
@@ -750,6 +765,10 @@ function l2Normalize(vec) {
 	if (norm > 0) for (let i = 0; i < vec.length; i++) vec[i] /= norm;
 	return vec;
 }
+//#endregion
+//#region src/embedding-encoder/addon/clip-text-engines.ts
+/** At most this many text towers stay loaded (SigLIP2's is ~565 MB). */
+var MAX_TEXT_ENGINES = 2;
 /**
 * A tower unused this long is disposed ({@link ClipTextEngines.evictIdle}) —
 * EXCEPT the tower of the model the cluster row names, which stays loaded for
@@ -927,7 +946,7 @@ var ClipTextEngines = class {
 	}
 	/** Fire-and-log: eviction errors never reach an encode. */
 	scheduleEviction() {
-		this.evictBeyond(this.deps.maxEngines ?? 2).catch((err) => {
+		this.evictBeyond(this.deps.maxEngines ?? MAX_TEXT_ENGINES).catch((err) => {
 			this.deps.logger.warn("CLIP text tower eviction failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
 	}