@camstack/addon-pipeline 1.2.38 → 1.2.39

package/dist/{dist-Du7_SNiR.mjs → dist-COgGdFMv.mjs}

@@ -7497,14 +7497,7 @@ var RecordingConfigSchema = object({
 	* windows only — existing sheets are immutable, and each window's index
 	* carries its own tile dims so mixed-preset history renders correctly.
 	*/
-	scrubThumbnails: ScrubThumbnailPresetSchema.optional(),
-	/**
-	* OPT-IN thumbnail-strip generation for this camera: every keyframe of the
-	* low recording saved as a JPEG (the fast-drag scrub depth), a derived
-	* cache that eviction reclaims with the footage. Absent/false = no strips
-	* are written and scrub reads exact keyframes at every velocity.
-	*/
-	stripsEnabled: boolean().optional()
+	scrubThumbnails: ScrubThumbnailPresetSchema.optional()
 }).strict();
 /**
 * Derive the {@link RecordingStorageModeSchema} summary from the authoritative
@@ -7582,7 +7575,7 @@ var OpsLogQueryInputSchema = object({
 /**
 * Entity-relocation job state (storage entity-routing spec, Phase 4).
 *
-* One shape shared by the recorder's `relocateFootage` (segments + strips) and
+* One shape shared by the recorder's `relocateFootage` (segments) and
 * pipeline-analytics' `relocateMedia` (event media blobs) so the admin Data
 * page renders both movers with one component. Jobs are in-RAM (a restart
 * forgets them — re-running is safe by construction: copy-if-absent, delete
@@ -7604,7 +7597,7 @@ var RelocateJobSchema = object({
 	toLocationId: string(),
 	/** Scoped device, or null = every device. */
 	deviceId: number().nullable(),
-	/** What the job moves (owner-addon specific: segments/strips or media). */
+	/** What the job moves (owner-addon specific: segments or media). */
 	entities: array(string()),
 	filesMoved: number().int(),
 	bytesMoved: number().int(),
@@ -7618,7 +7611,7 @@ var RelocateFootageInputSchema = object({
 	deviceId: number().optional(),
 	fromLocationId: string(),
 	toLocationId: string(),
-	entities: array(_enum(["segments", "strips"])).optional(),
+	entities: array(_enum(["segments"])).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()
@@ -16266,6 +16259,167 @@ method(object({ codec: string() }), boolean()), method(_void(), object({
 	auth: "admin"
 });
 /**
+* Query filter for settings-store collections.
+*/
+var QueryFilterSchema = object({
+	where: record(string(), unknown()).optional(),
+	whereIn: record(string(), array(unknown())).optional(),
+	whereBetween: record(string(), tuple([unknown(), unknown()])).optional(),
+	orderBy: object({
+		field: string(),
+		direction: _enum(["asc", "desc"])
+	}).optional(),
+	limit: number().optional(),
+	offset: number().optional()
+});
+/** A single stored record: `{ id, data }`. */
+var SettingsRecordSchema = object({
+	id: string(),
+	data: record(string(), unknown())
+});
+/**
+* Column declaration for a structured (SQL-backed) collection.
+*
+* Logical types — the backend translates each to the matching SQLite
+* storage class and handles per-type marshaling:
+*   - `TEXT` / `INTEGER` / `REAL` — native SQLite types, pass-through
+*   - `JSON`    — TEXT under the hood; serialised on write, parsed on read
+*   - `BOOLEAN` — INTEGER 0/1 under the hood; coerced both directions
+*/
+var CollectionColumnSchema = object({
+	name: string(),
+	type: _enum([
+		"TEXT",
+		"INTEGER",
+		"REAL",
+		"JSON",
+		"BOOLEAN"
+	]),
+	primaryKey: boolean().optional(),
+	notNull: boolean().optional(),
+	unique: boolean().optional()
+});
+var CollectionIndexSchema = object({
+	name: string(),
+	columns: array(string()).readonly(),
+	unique: boolean().optional()
+});
+method(object({
+	namespace: string().optional(),
+	collection: string(),
+	key: string()
+}), unknown()), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	key: string(),
+	value: unknown()
+}), _void(), { kind: "mutation" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	filter: QueryFilterSchema.optional()
+}), array(SettingsRecordSchema).readonly()), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	record: SettingsRecordSchema
+}), _void(), { kind: "mutation" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	id: string(),
+	data: record(string(), unknown())
+}), _void(), { kind: "mutation" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	key: string()
+}), _void(), { kind: "mutation" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	filter: QueryFilterSchema.optional()
+}), number()), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	field: string(),
+	bucketSize: number().int().positive(),
+	origin: number().int(),
+	filter: QueryFilterSchema.optional()
+}), array(object({
+	bucket: number().int(),
+	count: number().int()
+})).readonly()), method(object({
+	namespace: string().optional(),
+	collection: string()
+}), boolean()), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	columns: array(CollectionColumnSchema).readonly(),
+	indexes: array(CollectionIndexSchema).readonly().optional()
+}), _void(), { kind: "mutation" });
+/**
+* What one engine says about itself. The orchestrator uses `kind` to pick
+* a registrant for a collection; `engineId` is what a log line names when
+* a call is routed or refused.
+*/
+var EngineInfoSchema = object({
+	engineId: string(),
+	/**
+	* `relational` — rows, columns, indexes, the surface `settings-store`
+	* has always described. `vector` — an embedding store answering
+	* similarity queries. A registrant declares exactly one; an engine that
+	* does both registers twice, because "both" would make the routing
+	* decision ambiguous at exactly the point it must not be.
+	*/
+	kind: _enum(["relational", "vector"]),
+	displayName: string()
+});
+method(_void(), EngineInfoSchema), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	key: string()
+}), unknown()), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	key: string(),
+	value: unknown()
+}), _void(), { kind: "mutation" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	filter: QueryFilterSchema.optional()
+}), array(SettingsRecordSchema).readonly()), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	record: SettingsRecordSchema
+}), _void(), { kind: "mutation" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	id: string(),
+	data: record(string(), unknown())
+}), _void(), { kind: "mutation" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	key: string()
+}), _void(), { kind: "mutation" }), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	filter: QueryFilterSchema.optional()
+}), number()), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	field: string(),
+	bucketSize: number().int().positive(),
+	origin: number().int(),
+	filter: QueryFilterSchema.optional()
+}), array(object({
+	bucket: number().int(),
+	count: number().int()
+})).readonly()), method(object({
+	namespace: string().optional(),
+	collection: string()
+}), boolean()), method(object({
+	namespace: string().optional(),
+	collection: string(),
+	columns: array(CollectionColumnSchema).readonly(),
+	indexes: array(CollectionIndexSchema).readonly().optional()
+}), _void(), { kind: "mutation" });
+/**
 * detection-pipeline — device-scoped facade over the system
 * `pipeline-executor`.
 *
@@ -19528,6 +19682,28 @@ var ServerUpdateStateSchema = _enum([
 	"pending-restart",
 	"awaiting-confirmation"
 ]);
+var ImageContractSchema = object({
+	state: _enum([
+		"in-sync",
+		"behind-patch",
+		"behind-series",
+		"ahead",
+		"unknown"
+	]),
+	/** The baked seed closure version — the image/app-bundle fingerprint. */
+	seedVersion: string().nullable(),
+	/** Best-known version the deployment contract delivers today. */
+	contractVersion: string().nullable(),
+	/**
+	* Where `contractVersion` came from: a real registry check (`registry`), or
+	* the node's own running version (`running` — a node can never run code
+	* newer than the newest release, so `seed < running` proves image staleness
+	* even before any registry check has run).
+	*/
+	contractSource: _enum(["registry", "running"]).nullable(),
+	/** One operator-grade sentence: this node runs image X; the contract says Y. */
+	message: string()
+});
 var ServerRollbackInfoSchema = object({
 	/** The version that failed (or was manually rolled back). */
 	fromVersion: string(),
@@ -19564,7 +19740,12 @@ var ServerPackageStatusSchema = object({
 	* versions are being IGNORED. Surfaced as a warning in the UI.
 	*/
 	stateFileCorrupt: boolean(),
-	lastCheckedAtMs: number().nullable()
+	lastCheckedAtMs: number().nullable(),
+	/**
+	* Seed-vs-contract verdict (see {@link ImageContractSchema}). Optional for
+	* version skew: an older provider's payload simply omits it.
+	*/
+	imageContract: ImageContractSchema.optional()
 });
 var ServerUpdateCheckResultSchema = object({
 	packageName: string(),
@@ -19599,101 +19780,6 @@ version: string().optional() }), ServerUpdateActionResultSchema, {
 	auth: "admin"
 });
 /**
-* Query filter for settings-store collections.
-*/
-var QueryFilterSchema = object({
-	where: record(string(), unknown()).optional(),
-	whereIn: record(string(), array(unknown())).optional(),
-	whereBetween: record(string(), tuple([unknown(), unknown()])).optional(),
-	orderBy: object({
-		field: string(),
-		direction: _enum(["asc", "desc"])
-	}).optional(),
-	limit: number().optional(),
-	offset: number().optional()
-});
-/** A single stored record: `{ id, data }`. */
-var SettingsRecordSchema = object({
-	id: string(),
-	data: record(string(), unknown())
-});
-/**
-* Column declaration for a structured (SQL-backed) collection.
-*
-* Logical types — the backend translates each to the matching SQLite
-* storage class and handles per-type marshaling:
-*   - `TEXT` / `INTEGER` / `REAL` — native SQLite types, pass-through
-*   - `JSON`    — TEXT under the hood; serialised on write, parsed on read
-*   - `BOOLEAN` — INTEGER 0/1 under the hood; coerced both directions
-*/
-var CollectionColumnSchema = object({
-	name: string(),
-	type: _enum([
-		"TEXT",
-		"INTEGER",
-		"REAL",
-		"JSON",
-		"BOOLEAN"
-	]),
-	primaryKey: boolean().optional(),
-	notNull: boolean().optional(),
-	unique: boolean().optional()
-});
-var CollectionIndexSchema = object({
-	name: string(),
-	columns: array(string()).readonly(),
-	unique: boolean().optional()
-});
-method(object({
-	namespace: string().optional(),
-	collection: string(),
-	key: string()
-}), unknown()), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	key: string(),
-	value: unknown()
-}), _void(), { kind: "mutation" }), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	filter: QueryFilterSchema.optional()
-}), array(SettingsRecordSchema).readonly()), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	record: SettingsRecordSchema
-}), _void(), { kind: "mutation" }), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	id: string(),
-	data: record(string(), unknown())
-}), _void(), { kind: "mutation" }), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	key: string()
-}), _void(), { kind: "mutation" }), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	filter: QueryFilterSchema.optional()
-}), number()), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	field: string(),
-	bucketSize: number().int().positive(),
-	origin: number().int(),
-	filter: QueryFilterSchema.optional()
-}), array(object({
-	bucket: number().int(),
-	count: number().int()
-})).readonly()), method(object({
-	namespace: string().optional(),
-	collection: string()
-}), boolean()), method(object({
-	namespace: string().optional(),
-	collection: string(),
-	columns: array(CollectionColumnSchema).readonly(),
-	indexes: array(CollectionIndexSchema).readonly().optional()
-}), _void(), { kind: "mutation" });
-/**
 * `smtp-provider` — pluggable email delivery surface.
 *
 * Collection cap: a deployment may install multiple SMTP relays (e.g.
@@ -22458,7 +22544,7 @@ var recordingCapability = {
 			auth: "admin"
 		}),
 		/**
-		* Move footage (segments and/or strips) from one recordings location to
+		* Move footage (recorded segments) from one recordings location to
 		* another — the drain workflow's mover (entity-routing spec Phase 4).
 		* Throttled copy → size-verify → delete source → index refresh; resumable
 		* by construction (copy-if-absent). Single-flight: one job at a time.
@@ -23783,6 +23869,72 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"dataStoreProvider.count": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.declareCollection": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"dataStoreProvider.delete": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"dataStoreProvider.get": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.getEngineInfo": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.histogram": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.insert": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"dataStoreProvider.isEmpty": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.query": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"dataStoreProvider.set": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"dataStoreProvider.update": {
+		capName: "data-store-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"dayNight.getOptions": {
 		capName: "day-night",
 		capScope: "device",

package/dist/{step-definitions-C8tk9fPJ.mjs → event-loop-stall-monitor-naFYvcOO.mjs}

@@ -1,4 +1,5 @@
-import { D as hfModelUrl, a as COCO_TO_MACRO, i as COCO_80_LABELS, r as AUDIO_MACRO_LABELS } from "./dist-Du7_SNiR.mjs";
+import { D as hfModelUrl, a as COCO_TO_MACRO, i as COCO_80_LABELS, r as AUDIO_MACRO_LABELS } from "./dist-COgGdFMv.mjs";
+import { PerformanceObserver } from "node:perf_hooks";
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";
 var HF_SCRYPTED = "scrypted/plugin-models";
@@ -1807,4 +1808,140 @@ function resolveModelForFormat(stepId, chosenModelId, format) {
 	return getDefaultModelForFormat(stepId, format);
 }
 //#endregion
-export { getStep as a, getDefaultModelForFormatFromDef as i, ALL_STEPS as n, getStepDefinition as o, getDefaultModelForFormat as r, resolveModelForFormat as s, ALL_PIPELINE_STEPS as t };
+//#region src/detection-pipeline/diagnostics/event-loop-stall-monitor.ts
+/**
+* event-loop-stall-monitor — names the thing that freezes the detection process.
+*
+* ## What this exists to settle
+*
+* On 2026-08-01/02 inference across the whole fleet stalled in bursts: 759
+* calls in 90 minutes crossed the runner's 20s deadline, p50 41s and max 80s,
+* and EVERY one of them eventually resolved. Six explanations were killed with
+* telemetry alone:
+*
+*  - not a slow GPU or a wedged pool — the work completes, just enormously late;
+*  - not CPU starvation — hosts sat at 8-48% during the freezes;
+*  - not swap — `pswpin/pswpout` are flat zero on every host;
+*  - not a logging artifact — Loki's timestamp trails the in-process one by
+*    0.1-1.0s at p95, so the gaps are real, not buffered delivery;
+*  - not the v1.2.30 release — the stalls predate it by a day;
+*  - not only the idle-pool recompile — that is real and hub-side, but the
+*    agent stalls with no eviction and no compile at all.
+*
+* What IS established: the 10s stats timer — which touches no inference code —
+* stops firing for 22-88s and resumes at the same instant the abandoned calls
+* settle. The event loop itself freezes. From outside the process, GC and a
+* synchronous block are indistinguishable, and guessing between them is how
+* this investigation would go wrong. So measure it.
+*
+* ## How
+*
+* A 1s interval whose LATENESS is the freeze: a tick that arrives 40s late means
+* the loop was blocked ~39s, whatever blocked it. In the same window the GC
+* observer accumulates pause time. The two numbers together answer the question
+* outright:
+*
+*  - `gcMs` ≈ `stallMs` → garbage collection. Look at heap growth.
+*  - `gcMs` ≈ 0 → something SYNCHRONOUS blocked the loop, and GC is innocent.
+*
+* Heap and RSS ride along because if it is GC, the next question is always
+* "growing since when?".
+*
+* Deliberately not a histogram (`monitorEventLoopDelay`): that reports a
+* distribution, and the question here is about ONE outlier and what coincided
+* with it.
+*/
+/** Tick period. Small enough to bound attribution error, large enough to cost
+*  nothing on a process already doing frame work. */
+var STALL_TICK_MS = 1e3;
+/**
+* Report a freeze only past this. The runner's own inference deadline is 20s
+* and the observed freezes run 22-88s, so this is far below the signal while
+* staying clear of ordinary scheduling jitter (a busy frame path routinely
+* overruns a 1s timer by tens of ms).
+*/
+var STALL_REPORT_MS = 2e3;
+/**
+* Attribute a freeze. Pure, because this is the ONE judgement the whole module
+* exists to make and it must be testable without freezing a real event loop.
+*
+* `gc` when garbage collection accounts for most of the stall; a
+* `synchronous-block` when it accounts for almost none — that verdict points
+* away from the heap entirely and at whatever ran without yielding.
+*/
+function attributeStall(stallMs, gcMs, gcCount, longestGcMs) {
+	const share = stallMs > 0 ? gcMs / stallMs : 0;
+	return {
+		stallMs,
+		gcMs,
+		gcCount,
+		longestGcMs,
+		cause: share >= .7 ? "gc" : share <= .2 ? "synchronous-block" : "mixed"
+	};
+}
+/**
+* Start watching. Returns a stop function; safe to call twice.
+*
+* Never throws into the caller: a diagnostic that can take the detection
+* process down is worse than no diagnostic. `PerformanceObserver` for `gc` is
+* unavailable in some embedded runtimes, and that must degrade to
+* stall-detection-without-attribution rather than a boot failure.
+*/
+function startEventLoopStallMonitor(logger, reportThresholdMs = STALL_REPORT_MS) {
+	let gc = {
+		totalMs: 0,
+		count: 0,
+		longestMs: 0
+	};
+	let observer = null;
+	try {
+		observer = new PerformanceObserver((list) => {
+			for (const entry of list.getEntries()) {
+				gc.totalMs += entry.duration;
+				gc.count += 1;
+				if (entry.duration > gc.longestMs) gc.longestMs = entry.duration;
+			}
+		});
+		observer.observe({ entryTypes: ["gc"] });
+	} catch {
+		observer = null;
+	}
+	let expected = Date.now() + STALL_TICK_MS;
+	const timer = setInterval(() => {
+		const now = Date.now();
+		const lateBy = now - expected;
+		const window = gc;
+		gc = {
+			totalMs: 0,
+			count: 0,
+			longestMs: 0
+		};
+		expected = now + STALL_TICK_MS;
+		if (lateBy < reportThresholdMs) return;
+		const verdict = attributeStall(lateBy, Math.round(window.totalMs), window.count, Math.round(window.longestMs));
+		const mem = process.memoryUsage();
+		logger.warn("event loop stalled", { meta: {
+			stallMs: verdict.stallMs,
+			cause: verdict.cause,
+			gcMs: verdict.gcMs,
+			gcCount: verdict.gcCount,
+			longestGcMs: verdict.longestGcMs,
+			gcObserved: observer !== null,
+			heapUsedMb: Math.round(mem.heapUsed / 1e6),
+			heapTotalMb: Math.round(mem.heapTotal / 1e6),
+			rssMb: Math.round(mem.rss / 1e6),
+			externalMb: Math.round(mem.external / 1e6),
+			arrayBuffersMb: Math.round(mem.arrayBuffers / 1e6)
+		} });
+	}, STALL_TICK_MS);
+	timer.unref?.();
+	let stopped = false;
+	return () => {
+		if (stopped) return;
+		stopped = true;
+		clearInterval(timer);
+		observer?.disconnect();
+	};
+}
+//#endregion
+export { getDefaultModelForFormat as a, getStepDefinition as c, ALL_STEPS as i, resolveModelForFormat as l, startEventLoopStallMonitor as n, getDefaultModelForFormatFromDef as o, ALL_PIPELINE_STEPS as r, getStep as s, attributeStall as t };