@camstack/addon-pipeline 1.2.145 → 1.2.148

package/dist/{dist-cZopp8Xm.mjs → dist-DjplinYP.mjs}

@@ -9351,18 +9351,61 @@ var RelocateFootageInputSchema = object({
 * `RecordingConfig.enabled` or camera wrapper bindings. */
 var StorageMigrationLeaseInputSchema = object({ leaseId: string().min(1) });
 var StorageMigrationFootageMoveInputSchema = RelocateFootageInputSchema.extend({ leaseId: string().min(1) });
+/**
+* What a `relocateMedia` pass DOES. One engine, three passes — never a second
+* mover (the engine already walks both collections with a timestamp cursor and
+* already has a stamp-without-copy path).
+*
+*  - `move`    — the default and the historical behaviour: event-media and
+*                retrain blobs move to `toLocationId` and their rows are
+*                stamped. The enrolled gallery is skipped (D197).
+*  - `seal`    — ROWS ONLY, no bytes. Every row whose `locationId` is NULL is
+*                stamped with `toLocationId`. `toLocationId` here is the id the
+*                bytes ALREADY sit on — today's `eventMedia` default — because
+*                a NULL row means "wherever `eventMedia` points *now*", and the
+*                instant a repoint moves that pointer the row reads from the
+*                new disk while its bytes are on the old one.
+*  - `gallery` — the inverse selection of `move`: ONLY the retention-exempt
+*                (enrolled-gallery) rows, which `move` deliberately skips.
+*                `galleryMedia` is `cardinality: 'single'`, so this pass can
+*                never run beside a live second location: it is stop-the-world
+*                by construction, which is acceptable only because the gallery
+*                is a few KB per enrolled sample.
+*/
+var MediaRelocateModeSchema = _enum([
+	"move",
+	"seal",
+	"gallery"
+]);
 var RelocateMediaInputSchema = object({
 	toLocationId: string(),
-	throttleMbps: number().min(1).max(1e3).optional()
+	throttleMbps: number().min(1).max(1e3).optional(),
+	/** Omitted = `move`, the pre-existing behaviour. */
+	mode: MediaRelocateModeSchema.optional()
+});
+/** How many rows still carry NO `locationId` — the population a repoint would
+*  silently re-aim at a disk that does not hold their bytes. Zero is the only
+*  value that permits a non-blocking `eventMedia` cutover. */
+var UnstampedEventMediaCountSchema = object({
+	media: number().int().nonnegative(),
+	retrainFrames: number().int().nonnegative(),
+	total: number().int().nonnegative()
 });
 var StorageMigrationMediaMoveInputSchema = RelocateMediaInputSchema.extend({ leaseId: string().min(1) });
-/** The independently selectable logical storage classes. `recordings`
-* encompasses the high and mid segment profiles; `recordingsLow` is low
-* segments; `eventMedia` is post-analysis blobs. */
+/** The independently selectable logical storage classes — every class
+* `storage.listLocationDeclarations` reports, so an operator never meets a
+* Zod enum error where they should meet an explanation.
+*
+* `recordings` encompasses the high and mid segment profiles; `recordingsLow`
+* is low segments; `eventMedia` is post-analysis blobs; `galleryMedia` is the
+* enrolled gallery; `backups` is the system backup archive. The last two have
+* their own rules — see {@link StorageMigrationFindingCodeSchema}. */
 var StorageMigrationClassSchema = _enum([
 	"recordings",
 	"recordingsLow",
-	"eventMedia"
+	"eventMedia",
+	"backups",
+	"galleryMedia"
 ]);
 /** A destination is always an existing, fully-qualified location id. The
 * migration API intentionally never changes a source location's `basePath`:
@@ -9370,20 +9413,56 @@ var StorageMigrationClassSchema = _enum([
 var StorageMigrationDestinationsSchema = object({
 	recordings: string().min(1).optional(),
 	recordingsLow: string().min(1).optional(),
-	eventMedia: string().min(1).optional()
+	eventMedia: string().min(1).optional(),
+	backups: string().min(1).optional(),
+	galleryMedia: string().min(1).optional()
 }).refine((value) => Object.keys(value).length > 0, { message: "select at least one storage class" });
+/**
+* How a migration sequences the cutover against the byte move.
+*
+*  - `blocking`     — the historical order: pause, move every byte, repoint,
+*                     resume. Recording is stopped for the whole move. Right
+*                     for a small or a cold class, and the only legal mode for
+*                     a `cardinality: 'single'` class.
+*  - `nonBlocking`  — repoint FIRST, drain behind: seal, pause, repoint,
+*                     refresh, resume, then move the past with everything
+*                     running. The pause is three bounded instants (a detach +
+*                     attach round, a write-gate drain, a lease) instead of one
+*                     bounded by bytes. 1.09 TB at 7–14 MB/s is thirty hours of
+*                     stopped recording under `blocking`; the same move is
+*                     seconds of stopped recording under `nonBlocking`.
+*
+* The mode is on the JOB, not only on the input, because `status` is where an
+* operator finds out which one is running.
+*/
+var StorageMigrationModeSchema = _enum(["blocking", "nonBlocking"]);
 /** Shared input for planning and starting an orchestrated storage migration. */
 var StorageMigrationInputSchema = object({
 	destinations: StorageMigrationDestinationsSchema,
-	throttleMbps: number().min(1).max(1e3).optional()
+	throttleMbps: number().min(1).max(1e3).optional(),
+	/** Omitted = `blocking`, which stays the default. */
+	mode: StorageMigrationModeSchema.optional()
 });
-/** The durable coordinator state machine. The only phase that changes default
-* locations is `repointing`, after every selected mover has completed and been
-* verified. */
+/**
+* The durable coordinator state machine.
+*
+* `blocking`:
+*   planning → pausing → moving → verifying → repointing → refreshing → resuming → done
+*
+* `nonBlocking`:
+*   planning → sealing → pausing → repointing → refreshing → resuming → draining → verifying → done
+*
+* Same phases, different order plus two new ones — not a second mover.
+* `sealing` closes the `eventMedia` NULL-row hole BEFORE anything is paused;
+* `draining` runs the same movers UNLEASED, after every writer is back up.
+* `repointing` is still the only phase that changes a default location.
+*/
 var StorageMigrationPhaseSchema = _enum([
 	"planning",
+	"sealing",
 	"pausing",
 	"moving",
+	"draining",
 	"verifying",
 	"repointing",
 	"refreshing",
@@ -9408,6 +9487,9 @@ var StorageMigrationMoveSchema = object({
 var StorageMigrationJobSchema = object({
 	jobId: string(),
 	phase: StorageMigrationPhaseSchema,
+	/** Which order this job is running. `status` is the only place an operator
+	*  can tell a seconds-long cutover from a thirty-hour one. */
+	mode: StorageMigrationModeSchema,
 	destinations: StorageMigrationDestinationsSchema,
 	throttleMbps: number(),
 	moves: array(StorageMigrationMoveSchema),
@@ -9420,13 +9502,30 @@ var StorageMigrationJobSchema = object({
 	finishedAt: number().nullable(),
 	error: string().nullable()
 });
+var StorageMigrationFindingSchema = object({
+	code: _enum([
+		"sharesDeviceWithSource",
+		"deviceIdentityUnknown",
+		"unstampedEventMediaRows",
+		"blockingOnly",
+		"noMover"
+	]),
+	storageClass: StorageMigrationClassSchema,
+	/** Human-readable, already carrying the ids and counts. */
+	message: string()
+});
 var StorageMigrationPlanSchema = object({
 	destinations: StorageMigrationDestinationsSchema,
+	/** The mode this plan was built for. A plan is only valid for its mode: the
+	*  `eventMedia` seal gate and the single-cardinality refusal both depend on
+	*  it. */
+	mode: StorageMigrationModeSchema,
 	moves: array(object({
 		storageClass: StorageMigrationClassSchema,
 		fromLocationId: string(),
 		toLocationId: string()
-	}))
+	})),
+	findings: array(StorageMigrationFindingSchema)
 });
 /**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
@@ -21099,7 +21198,7 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), method(RelocateMediaInputSchema, object({ jobId: string() }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), array(RelocateJobSchema).readonly(), {
+}), method(object({}), UnstampedEventMediaCountSchema, { auth: "admin" }), method(object({}), array(RelocateJobSchema).readonly(), {
 	kind: "query",
 	auth: "admin"
 }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
@@ -23148,7 +23247,10 @@ method(object({
 }), StorageLocationSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ id: string() }), _void(), {
+}), method(object({
+	id: string(),
+	force: boolean().optional()
+}), _void(), {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({ id: string() }), object({
@@ -34108,6 +34210,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.countUnstampedEventMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.deleteDeviceEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",

package/dist/event-loop-stall-monitor-DXLNBMkY.mjs

@@ -0,0 +1,138 @@
+import { PerformanceObserver } from "node:perf_hooks";
+//#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 { startEventLoopStallMonitor as n, attributeStall as t };

package/dist/event-loop-stall-monitor-DaUBcb13.js

@@ -0,0 +1,149 @@
+let node_perf_hooks = require("node:perf_hooks");
+//#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 node_perf_hooks.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
+Object.defineProperty(exports, "attributeStall", {
+	enumerable: true,
+	get: function() {
+		return attributeStall;
+	}
+});
+Object.defineProperty(exports, "startEventLoopStallMonitor", {
+	enumerable: true,
+	get: function() {
+		return startEventLoopStallMonitor;
+	}
+});

package/dist/{lazy-sharp-BzXIjfN8.js → lazy-sharp-BI4LsfMM.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-DML3mpn9.js");
+const require_dist = require("./dist-DLy_uz82.js");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
 let node_url = require("node:url");

package/dist/{event-loop-stall-monitor-DH_vFYWu.mjs → local-frame-registry-77FL9ua_.mjs}

@@ -1,6 +1,5 @@
-import { M as audioKindId, Z as hfModelUrl, a as COCO_80_LABELS, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS } from "./dist-cZopp8Xm.mjs";
+import { M as audioKindId, Z as hfModelUrl, a as COCO_80_LABELS, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS } from "./dist-DjplinYP.mjs";
 import { randomUUID } from "node:crypto";
-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";
@@ -2111,140 +2110,4 @@ var localFrameRegistry = new LocalFrameRegistry({
 	maxBytes: envPositiveInt("CAMSTACK_LOCAL_FRAME_BUDGET_MB", DEFAULT_MAX_BYTES / 1048576) * 1048576
 });
 //#endregion
-//#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 { ALL_PIPELINE_STEPS as a, getDefaultModelForFormatFromDef as c, resolveModelForFormat as d, landmarkPrecisionVerdict as f, resolveFrameViewGeometry as i, getStep as l, startEventLoopStallMonitor as n, ALL_STEPS as o, localFrameRegistry as r, getDefaultModelForFormat as s, attributeStall as t, getStepDefinition as u };
+export { getDefaultModelForFormat as a, getStepDefinition as c, ALL_STEPS as i, resolveModelForFormat as l, resolveFrameViewGeometry as n, getDefaultModelForFormatFromDef as o, ALL_PIPELINE_STEPS as r, getStep as s, localFrameRegistry as t, landmarkPrecisionVerdict as u };