@camstack/addon-pipeline-orchestrator 1.2.325 → 1.2.327

package/dist/index.js

@@ -5418,7 +5418,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DRqxtc0C.mjs
+//#region ../types/dist/sleep-bwsTj221.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6685,7 +6685,6 @@ function createHandle(raw, opts) {
 	const writeAddon = (patch) => write("addon", opts.addonTree(), void 0, patch, () => readStoredAddonBlob(raw), (p) => raw.writeAddonStore(p));
 	const readAddonStoreResult = raw.readAddonStoreResult;
 	const readAddonStoreKeyResult = raw.readAddonStoreKeyResult;
-	const readDeviceStoreBatch = raw.readDeviceStoreBatch;
 	const overrides = {
 		readAddonStore: async () => resolveRead("addon", await raw.readAddonStore()),
 		...readAddonStoreResult !== void 0 ? { readAddonStoreResult: async () => {
@@ -6709,12 +6708,12 @@ function createHandle(raw, opts) {
 			};
 		} } : {},
 		readDeviceStore: async (deviceId) => resolveRead(`device:${deviceId}`, await raw.readDeviceStore(deviceId)),
-		...readDeviceStoreBatch !== void 0 ? { readDeviceStoreBatch: async (deviceIds) => {
-			const rows = await readDeviceStoreBatch.call(raw, deviceIds);
+		readDeviceStoreBatch: async (deviceIds) => {
+			const rows = await raw.readDeviceStoreBatch(deviceIds);
 			const out = /* @__PURE__ */ new Map();
 			for (const [deviceId, blob] of rows) out.set(deviceId, await resolveRead(`device:${deviceId}`, blob));
 			return out;
-		} } : {},
+		},
 		writeAddonStore: async (patch) => {
 			await writeAddon(patch);
 		},
@@ -7541,7 +7540,7 @@ var BaseAddon = class {
 		return this._addonSecretTree;
 	}
 	deviceSecretTree() {
-		this._deviceSecretTree ??= secretTreeFromSchema(this.deviceSettingsSchema());
+		this._deviceSecretTree ??= mergeSecretStatePaths(secretTreeFromSchema(this.deviceSettingsSchema()), this.secretStatePaths);
 		return this._deviceSecretTree;
 	}
 	/**
@@ -7617,42 +7616,135 @@ var BaseAddon = class {
 		this[timerOf] = timer;
 	}
 	/**
-	* Wrap `ctx.settings.readAddonStore()` with a short retry budget so a
-	* transient settings-store outage (mid-restart of sqlite-settings, tsx-watch
-	* swap, or any race where the SqliteSettingsBackend is between shutdown and
-	* re-initialize) doesn't propagate up into `initialize()` and leave the
+	* Wrap `ctx.settings.readAddonStore()` with a retry budget so a transient
+	* settings-store outage doesn't propagate up into `initialize()` and leave the
 	* addon permanently broken.
 	*
-	* Retry only the two known infra fingerprints. Anything else propagates so
-	* real bugs surface immediately. After the budget expires we fall back to
-	* `{}` (defaults) — the addon's first successful patch will rehydrate.
+	* Two kinds of outage, two budgets:
+	*  - the store's own restart fingerprints (`SqliteSettingsBackend not
+	*    initialized`, `provider not available`): a short budget, then the addon
+	*    falls back to `{}` (defaults) - its first successful patch rehydrates;
+	*  - a TRANSPORT failure (the hub is restarting while this runner boots:
+	*    `discovery deadline exceeded`, `parent could not route`, a refused or
+	*    timed-out connection). Since D870 a runner's settings read THROWS instead
+	*    of answering `{}`, so without a budget a hub restart ends in a respawn
+	*    loop. A long, bounded budget; only after it the error propagates - the
+	*    addon never runs on defaults for a store it could not ask.
+	* Anything else propagates immediately so real bugs surface.
 	*/
 	async readAddonStoreWithRetry() {
 		const settings = this.rawSettings();
 		if (!settings) return {};
-		const delaysMs = [
-			150,
-			350,
-			600,
-			900
-		];
 		let lastErr;
-		for (let attempt = 0; attempt <= delaysMs.length; attempt++) try {
+		for (let attempt = 0;; attempt++) try {
 			const stored = await settings.readAddonStore() ?? {};
 			this.settingsStoreReady = true;
 			return stored;
 		} catch (err) {
 			lastErr = err;
-			const msg = err instanceof Error ? err.message : String(err);
-			if (!(msg.includes("SqliteSettingsBackend not initialized") || msg.includes("provider not available"))) throw err;
-			if (attempt === delaysMs.length) break;
-			await new Promise((r) => setTimeout(r, delaysMs[attempt]));
+			const kind = classifyStoreError(err);
+			if (kind === "permanent") throw err;
+			const delay = (kind === "transport" ? TRANSPORT_RETRY_DELAYS_MS : RESTART_RETRY_DELAYS_MS)[attempt];
+			if (delay === void 0) {
+				if (kind === "transport") throw err;
+				break;
+			}
+			await new Promise((r) => setTimeout(r, delay));
 		}
 		this.settingsStoreReady = false;
 		this._ctx?.logger?.warn?.("readAddonStore: settings-store unavailable after retries — using defaults", { meta: { error: lastErr instanceof Error ? lastErr.message : String(lastErr) } });
 		return {};
 	}
 };
+/** The settings store's own restart fingerprints. */
+var RESTART_RETRY_DELAYS_MS = [
+	150,
+	350,
+	600,
+	900
+];
+/** A hub restarting under a booting runner: ~100 s in total. */
+var TRANSPORT_RETRY_DELAYS_MS = [
+	150,
+	350,
+	600,
+	900,
+	2e3,
+	5e3,
+	1e4,
+	2e4,
+	3e4,
+	3e4
+];
+var RESTART_FINGERPRINTS = ["SqliteSettingsBackend not initialized", "provider not available"];
+/** Node / socket error codes of a connection that did not happen or broke. */
+var TRANSPORT_CODES = new Set([
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"ETIMEDOUT",
+	"EPIPE",
+	"EHOSTUNREACH",
+	"ENETUNREACH"
+]);
+/** tRPC error codes that mean "the other side is not answering now", not "your call is wrong". */
+var UNAVAILABLE_TRPC_CODES = new Set([
+	"TIMEOUT",
+	"SERVICE_UNAVAILABLE",
+	"BAD_GATEWAY",
+	"GATEWAY_TIMEOUT"
+]);
+/** The exact phrases OUR transport raises when it cannot reach the hub. */
+var TRANSPORT_PHRASES = [
+	"discovery deadline exceeded",
+	"parent could not route child unowned cap call",
+	"UDS request timed out after",
+	"channel closed"
+];
+/** Moleculer error `type`s of a call that could not be served right now. */
+var MOLECULER_TRANSIENT_TYPES = new Set([
+	"REQUEST_TIMEOUT",
+	"SERVICE_NOT_FOUND",
+	"SERVICE_NOT_AVAILABLE",
+	"REQUEST_REJECTED",
+	"BROKER_DISCONNECTED"
+]);
+function stringProp(value, key) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const found = Reflect.get(value, key);
+	return typeof found === "string" ? found : void 0;
+}
+/** The code an error carries: its own, its cause's, or a tRPC `data.code`. */
+function errorCode(err) {
+	const out = {};
+	const cause = typeof err === "object" && err !== null ? Reflect.get(err, "cause") : void 0;
+	const data = typeof err === "object" && err !== null ? Reflect.get(err, "data") : void 0;
+	const node = stringProp(err, "code") ?? stringProp(cause, "code");
+	if (node !== void 0) out.node = node;
+	const trpc = stringProp(data, "code");
+	if (trpc !== void 0) out.trpc = trpc;
+	return out;
+}
+/**
+* Is a settings read failure worth retrying, and with which budget? Only
+* EXPLICIT signals count: a socket error code, a tRPC "unavailable" code, or
+* one of the exact phrases our own transport raises. A message that merely
+* contains "timed out" or "unreachable" is not evidence of anything, and
+* `settings store not wired` is a wiring bug that retrying cannot fix.
+*/
+function classifyStoreError(err) {
+	const message = err instanceof Error ? err.message : String(err);
+	if (RESTART_FINGERPRINTS.some((f) => message.includes(f))) return "restart";
+	const code = errorCode(err);
+	if (code.node !== void 0 && TRANSPORT_CODES.has(code.node)) return "transport";
+	if (code.trpc !== void 0 && UNAVAILABLE_TRPC_CODES.has(code.trpc)) return "transport";
+	if (typeof err === "object" && err !== null) {
+		if (Reflect.get(err, "retryable") === true) return "transport";
+		const type = stringProp(err, "type");
+		if (type !== void 0 && MOLECULER_TRANSIENT_TYPES.has(type)) return "transport";
+	}
+	if (TRANSPORT_PHRASES.some((f) => message.includes(f))) return "transport";
+	return "permanent";
+}
 /**
 * Collect the keys of every field marked `perNode: true`, recursing into
 * layout containers (`group` fields and `sub-tabs` tabs) the same way
@@ -12798,11 +12890,10 @@ var ClipModelMetaSchema = object({
 	/**
 	* The `vector-store` index this model's vectors live in. ONE feature space
 	* per index: two models share an index only when their vectors are ranked
-	* against each other, which for CLIP means never across families. MobileCLIP
-	* S1 and S2 share `object-clip` for history (separated by the row's
-	* `modelId`); any other model gets its own.
+	* against each other, which for CLIP means never across families. Every
+	* model gets its own.
 	*/
-	vectorIndex: string().regex(/^object-clip(-[a-z0-9][a-z0-9-]*)?$/),
+	vectorIndex: string().regex(/^object-clip-[a-z0-9][a-z0-9-]*$/),
 	/**
 	* The text encoder's tokenizer, a declared SIBLING file of its onnx. The name
 	* must be unique per tokenizer: every model's siblings land in ONE flat
@@ -16974,6 +17065,28 @@ id: union([string(), number()]) }), {
 	kind: "mutation",
 	auth: "admin"
 });
+/** One table of the settings database. */
+var StorageTableSchema = object({
+	/** The table's full name, e.g. `recorder:addon-settings` or `addon-device-settings`. */
+	name: string(),
+	/** The owner prefix of a scoped name (`recorder` for `recorder:addon-settings`), else null. */
+	owner: string().nullable(),
+	rows: number().int().nonnegative(),
+	/** Bytes the table's pages occupy (`dbstat`); null when the engine cannot measure. */
+	bytes: number().int().nonnegative().nullable(),
+	/** Declared by an addon since this engine process started (a running addon claims it). */
+	declaredThisBoot: boolean()
+});
+method(object({ ownerPrefix: string().min(1).optional() }), object({ tables: array(StorageTableSchema) }), { auth: "admin" }), method(object({
+	collection: string().min(1),
+	expectRows: number().int().nonnegative()
+}), object({
+	dropped: literal(true),
+	rows: number().int().nonnegative()
+}), {
+	kind: "mutation",
+	auth: "admin"
+});
 /**
 * `keychain` — the hub's encrypted store of secret values (D787).
 *
@@ -17515,6 +17628,16 @@ method(object({}), KeychainStatusSchema, { auth: "admin" }), method(object({}),
 	kind: "mutation",
 	auth: "admin",
 	caller: "required"
+}), method(object({
+	ref: string().min(1),
+	value: string().min(1)
+}), object({
+	ref: string(),
+	version: number().int()
+}), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
 }), method(object({ refs: array(string().min(1)).max(1e3) }), object({
 	deleted: array(string()).readonly(),
 	kept: array(object({
@@ -56730,7 +56853,19 @@ var TlsStatusSchema = object({
 	sans: array(string()),
 	caCertPem: string().nullable(),
 	reissueError: string().nullable(),
-	restartRequired: boolean()
+	restartRequired: boolean(),
+	/** An uploaded certificate is served but no CA is kept for it and it is not publicly signed (D873). */
+	caMissing: boolean(),
+	/** Does the hub's own generated CA carry a critical name constraint? `null` while it has none. */
+	localCaConstrained: boolean().nullable(),
+	/** ISO time the generated CA was replaced by a constrained one; devices must re-download it. */
+	caReplacedAt: string().nullable(),
+	/** The uploaded certificate kept on disk, selectable again after "Revert to generated". */
+	storedUpload: object({
+		leafFingerprintSha256: string(),
+		validTo: string(),
+		hasCa: boolean()
+	}).nullable()
 });
 method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(object({
 	/**
@@ -56786,6 +56921,9 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
 }), method(_void(), object({ pem: string() })), method(_void(), TlsStatusSchema, {
 	kind: "mutation",
 	auth: "admin"
+}), method(_void(), TlsStatusSchema, {
+	kind: "mutation",
+	auth: "admin"
 });
 object({
 	/** Lifecycle state of the lock. `jammed` means the motor reported
@@ -65921,6 +66059,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"keychainAdmin.importSecret": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"keychainAdmin.listAudit": {
 		capName: "keychain-admin",
 		capScope: "system",
@@ -66317,6 +66461,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.useStoredUploadedCertificate": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"lockControl.getStatus": {
 		capName: "lock-control",
 		capScope: "device",
@@ -69701,6 +69851,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"storageAdmin.dropCollection": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"storageAdmin.listTables": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageEvictable.evict": {
 		capName: "storage-evictable",
 		capScope: "system",
@@ -74746,7 +74908,11 @@ var REMOVED_MODEL_IDS = {
 	"face-embedding": ["arcface-r100", "inception-resnet-v1"],
 	"plate-detection": ["yolov8n-plate"],
 	"plate-ocr": ["vgg-english-g2"],
-	"clip-embedding": ["mobileclip-s1", "mobileclip-s2"],
+	"clip-embedding": [
+		"mobileclip-s0",
+		"mobileclip-s1",
+		"mobileclip-s2"
+	],
 	"package-detection": ["yolov8n-package"],
 	"bird-classifier": ["bird-classifier-aiy-edgetpu", "bird-nabirds-404"],
 	"animal-classifier": ["animals-10"],
@@ -76643,6 +76809,22 @@ var DurableLedger = class DurableLedger {
 		}
 	}
 	/**
+	* Drop every MIRRORED row about `deviceId` (per the spec's `deviceIdOf`),
+	* leaving the durable rows to the caller's `deleteWhere` (D871). Returns how
+	* many mirror entries went; a spec without `deviceIdOf` evicts nothing.
+	*/
+	evictDevice(deviceId) {
+		const of = this.spec.deviceIdOf;
+		if (of === void 0) return 0;
+		let evicted = 0;
+		for (const [key, row] of [...this.mirror.entries()]) {
+			if (of(row) !== deviceId) continue;
+			this.mirror.delete(key);
+			evicted += 1;
+		}
+		return evicted;
+	}
+	/**
 	* Drop every mirrored key NOT in `activeKeys`. Returns how many rows went.
 	*
 	* **The caller must hold an AUTHORITATIVE active set.** A prune driven by a
@@ -83974,15 +84156,10 @@ var DeviceFeaturesMirror = class {
 	async hydrate() {
 		const settings = this.settings;
 		if (settings === null) return 0;
-		const list = settings.listDeviceStoreIds;
-		if (list !== void 0) {
-			const ids = await list.call(settings);
-			const batch = settings.readDeviceStoreBatch;
-			const blobs = batch === void 0 ? new Map(await Promise.all(ids.map(async (id) => [id, await settings.readDeviceStore(id)]))) : await batch.call(settings, ids);
-			for (const [deviceId, blob] of blobs) {
-				const row = rowOf(deviceId, blob[DEVICE_FEATURES_KEY]);
-				if (row !== null) this.local.set(deviceId, row);
-			}
+		const ids = await settings.listDeviceStoreIds();
+		for (const [deviceId, blob] of await settings.readDeviceStoreBatch(ids)) {
+			const row = rowOf(deviceId, blob[DEVICE_FEATURES_KEY]);
+			if (row !== null) this.local.set(deviceId, row);
 		}
 		this.logger.info("device-features mirror restored", { meta: { devices: this.local.size } });
 		return this.local.size;
@@ -87640,25 +87817,33 @@ var NodeStressController = class NodeStressController {
 //#region src/durable/lts-aggregator.ts
 /** Wall-clock bucket width. Five minutes, matching HA's statistics tier. */
 var LTS_BUCKET_MS = 5 * 6e4;
+/** Buckets written per transaction — bounds one statement, not the flush. */
+var FLUSH_BATCH = 200;
 /** How often the row cap is enforced. Rarely: it is a bound, not a deadline. */
 var CAP_SWEEP_INTERVAL_MS = 6 * 36e5;
+/**
+* The row's identity IS its four key columns (D871): a composite
+* `primaryKey` + `WITHOUT ROWID`, so the table is its own index and there is no
+* TEXT `id` repeating what the row already says. The old layout kept
+* `<subject>|<series>|<scope>|<bucketStart>` as a TEXT primary key beside the
+* four columns — 85 MB of rows plus a 44 MB autoindex for 1.07 M rows. A
+* composite-key collection is written with `upsertMany` (a bucket flushed twice
+* replaces itself) and read with `query` / `count` / `deleteWhere`; the calls
+* that address one row by id are refused by the engine.
+*/
+var LTS_KEY_COLUMNS = [
+	"subject",
+	"series",
+	"scope",
+	"bucketStart"
+];
 var LTS_COLUMNS = [
-	(
-	/** `<subject>|<series>|<scope>|<bucketStart>` — deterministic, so a bucket
-	*  flushed twice replaces itself rather than doubling. */
-	{
-		name: "id",
-		type: "TEXT",
-		primaryKey: true,
-		notNull: true
-	}),
 	(
 	/** The camera id, or the node id. One column, because every query is
 	*  "this thing over time" and the thing is one or the other. */
 	{
 		name: "subject",
-		type: "TEXT",
-		notNull: true
+		type: "TEXT"
 	}),
 	(
 	/** Numeric mirror of `subject` for camera rows, so a per-camera question is
@@ -87670,22 +87855,19 @@ var LTS_COLUMNS = [
 	}),
 	{
 		name: "series",
-		type: "TEXT",
-		notNull: true
+		type: "TEXT"
 	},
 	(
 	/** Sub-scope within a series: a zoneId for occupancy, `''` otherwise. */
 	{
 		name: "scope",
-		type: "TEXT",
-		notNull: true
+		type: "TEXT"
 	}),
 	(
 	/** Bucket start, wall-clock aligned to {@link LTS_BUCKET_MS}. */
 	{
 		name: "bucketStart",
-		type: "INTEGER",
-		notNull: true
+		type: "INTEGER"
 	}),
 	{
 		name: "samples",
@@ -87708,12 +87890,15 @@ var LTS_COLUMNS = [
 		notNull: true
 	}
 ];
+/**
+* The primary key serves every per-subject read (`subject, series, scope` then a
+* `bucketStart` range, already in bucket order); this index serves the read that
+* names a series without a subject. The old `deviceId` index went with the TEXT
+* id: nothing queries a series by the numeric mirror.
+*/
 var LTS_INDEXES = [{
 	name: "idx_lts_series_bucket",
 	columns: ["series", "bucketStart"]
-}, {
-	name: "idx_lts_device",
-	columns: ["deviceId"]
 }];
 function ltsBucketStart(at, bucketMs = LTS_BUCKET_MS) {
 	return Math.floor(at / bucketMs) * bucketMs;
@@ -87742,6 +87927,8 @@ var LtsAggregator = class {
 		return store.declareCollection.mutate({
 			collection,
 			columns: [...LTS_COLUMNS],
+			primaryKey: [...LTS_KEY_COLUMNS],
+			withoutRowid: true,
 			indexes: [...LTS_INDEXES]
 		});
 	}
@@ -87801,43 +87988,60 @@ var LtsAggregator = class {
 			return 0;
 		}
 		let written = 0;
-		for (const bucket of due) {
-			const key = rowId(bucket.subject, bucket.series, bucket.scope, bucket.bucketStart);
-			try {
-				await this.store.set.mutate({
-					collection: this.collection,
-					key,
-					value: {
-						subject: bucket.subject,
-						...bucket.deviceId !== void 0 ? { deviceId: bucket.deviceId } : {},
-						series: bucket.series,
-						scope: bucket.scope,
-						bucketStart: bucket.bucketStart,
-						samples: bucket.samples,
-						sum: bucket.sum,
-						min: bucket.min,
-						max: bucket.max
-					}
-				});
-				written += 1;
-				this.groups.add(groupKey(bucket.subject, bucket.series, bucket.scope));
-			} catch (err) {
-				this.logger.warn("lts bucket write failed — this interval will be missing", {
-					...bucket.deviceId !== void 0 ? { tags: { deviceId: bucket.deviceId } } : {},
-					meta: {
-						collection: this.collection,
-						series: bucket.series,
-						subject: bucket.subject,
-						bucketStart: bucket.bucketStart,
-						error: String(err)
-					}
-				});
-			}
-			this.open.delete(key);
+		for (const batch of chunk(due, FLUSH_BATCH)) {
+			written += await this.writeBatch(batch);
+			for (const bucket of batch) this.open.delete(rowId(bucket.subject, bucket.series, bucket.scope, bucket.bucketStart));
 		}
 		await this.maybeSweepCap(now);
 		return written;
 	}
+	/**
+	* Upsert one batch in a single transaction. If the batch is refused as a
+	* whole (all-or-nothing), each bucket is retried alone so one bad row costs
+	* one interval, not forty. Returns the number of rows written.
+	*/
+	async writeBatch(batch) {
+		try {
+			await this.upsert(batch);
+			for (const bucket of batch) this.groups.add(groupKey(bucket.subject, bucket.series, bucket.scope));
+			return batch.length;
+		} catch (err) {
+			if (batch.length > 1) {
+				let written = 0;
+				for (const bucket of batch) written += await this.writeBatch([bucket]);
+				return written;
+			}
+			const bucket = batch[0];
+			this.logger.warn("lts bucket write failed — this interval will be missing", {
+				...bucket?.deviceId !== void 0 ? { tags: { deviceId: bucket.deviceId } } : {},
+				meta: {
+					collection: this.collection,
+					series: bucket?.series,
+					subject: bucket?.subject,
+					bucketStart: bucket?.bucketStart,
+					error: String(err)
+				}
+			});
+			return 0;
+		}
+	}
+	async upsert(batch) {
+		await this.store.upsertMany.mutate({
+			collection: this.collection,
+			conflict: [...LTS_KEY_COLUMNS],
+			records: batch.map((bucket) => ({ data: {
+				subject: bucket.subject,
+				deviceId: bucket.deviceId ?? null,
+				series: bucket.series,
+				scope: bucket.scope,
+				bucketStart: bucket.bucketStart,
+				samples: bucket.samples,
+				sum: bucket.sum,
+				min: bucket.min,
+				max: bucket.max
+			} }))
+		});
+	}
 	/** Read closed buckets back. The read surface every chart will use. */
 	async read(query = {}) {
 		const where = {};
@@ -87922,6 +88126,11 @@ var LtsAggregator = class {
 		}
 	}
 };
+function chunk(items, size) {
+	const out = [];
+	for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+	return out;
+}
 function groupKey(subject, series, scope) {
 	return `${subject}${series}${scope}`;
 }
@@ -87980,7 +88189,7 @@ function recordToRow(data) {
 *   write="one row per (node, series, 5-min bucket), written ONCE when the bucket closes; a node reporting no samples writes nothing"
 *   retention="row CAP per (subject, series, scope) — 105,120 rows ≈ one year of 5-minute buckets. Not an age sweep: an LTS row summarises an interval and has no owner to be orphaned from."
 */
-var NODE_STRESS_LTS_COLLECTION = "pipeline-orchestrator:stats-5m";
+var NODE_STRESS_LTS_COLLECTION = "pipeline-orchestrator:stats-5m-v2";
 var NodeStressLts = class {
 	lts;
 	constructor(deps) {