@camstack/addon-pipeline 1.2.100 → 1.2.102

package/dist/retire-root-keys-DMolfhsP.mjs

@@ -0,0 +1,308 @@
+var ROW_MAP_VALUE_COLUMN = "value";
+var RowMapStore = class RowMapStore {
+	spec;
+	store;
+	logger;
+	constructor(deps) {
+		this.spec = deps.spec;
+		this.store = deps.store;
+		this.logger = deps.logger;
+	}
+	/** The collection this store owns — for the caller's own log lines. */
+	get collection() {
+		return this.spec.collection;
+	}
+	/**
+	* Register the collection. MUST run at boot, before any read or write: the
+	* SQLite backend answers 412 for an undeclared collection.
+	*/
+	static declare(store, spec) {
+		return store.declareCollection.mutate({
+			collection: spec.collection,
+			columns: [
+				{
+					name: "id",
+					type: "TEXT",
+					primaryKey: true,
+					notNull: true
+				},
+				...spec.columns,
+				{
+					name: ROW_MAP_VALUE_COLUMN,
+					type: "JSON",
+					notNull: true
+				}
+			],
+			...spec.indexes !== void 0 ? { indexes: [...spec.indexes] } : {}
+		});
+	}
+	declare() {
+		return RowMapStore.declare(this.store, this.spec);
+	}
+	/** One entry, by key. `null` when absent OR unparseable (which is said aloud). */
+	async read(key) {
+		const raw = await this.store.get.query({
+			collection: this.spec.collection,
+			key
+		});
+		if (!isRecord$1(raw)) return null;
+		const row = raw;
+		const parsed = this.spec.schema.safeParse(row[ROW_MAP_VALUE_COLUMN]);
+		if (!parsed.success) {
+			this.logger.warn("row-map row skipped as unparseable", {
+				...this.deviceTags(row),
+				meta: {
+					collection: this.spec.collection,
+					key,
+					error: parsed.error.message
+				}
+			});
+			return null;
+		}
+		return parsed.data;
+	}
+	/**
+	* Every entry, keyed. Unparseable rows are skipped — one bad entry costs that
+	* entry, never the map.
+	*/
+	async readAll() {
+		const records = await this.store.query.query({
+			collection: this.spec.collection,
+			filter: { limit: this.spec.loadLimit }
+		});
+		const out = /* @__PURE__ */ new Map();
+		let skipped = 0;
+		for (const record of records) {
+			const parsed = this.spec.schema.safeParse(record.data[ROW_MAP_VALUE_COLUMN]);
+			if (!parsed.success) {
+				skipped += 1;
+				continue;
+			}
+			out.set(record.id, parsed.data);
+		}
+		if (skipped > 0) this.logger.warn("row-map rows skipped as unparseable", { meta: {
+			collection: this.spec.collection,
+			skipped,
+			kept: out.size
+		} });
+		if (records.length >= this.spec.loadLimit) this.logger.warn("row-map read hit its own bound — the map may be truncated", { meta: {
+			collection: this.spec.collection,
+			loadLimit: this.spec.loadLimit
+		} });
+		return out;
+	}
+	/** Insert or replace ONE entry. Validates at the boundary. */
+	async write(key, value) {
+		const validated = this.spec.schema.parse(value);
+		const columns = this.spec.project(key, validated);
+		await this.store.set.mutate({
+			collection: this.spec.collection,
+			key,
+			value: {
+				...columns,
+				[ROW_MAP_VALUE_COLUMN]: validated
+			}
+		});
+	}
+	/** Drop ONE entry. Idempotent. */
+	async remove(key) {
+		await this.store.delete.mutate({
+			collection: this.spec.collection,
+			key
+		});
+	}
+	/**
+	* Make the collection hold exactly `next` — the write path for an owner whose
+	* in-memory map IS the authority (a persister handed the complete set).
+	*
+	* Returns how many rows were DELETED, and says so out loud when any were: a
+	* replace that silently drops rows is indistinguishable from one that never
+	* had them. Only an owner holding an authoritative set may call this — a
+	* prune driven by a fallible read is work destroyed (D130, D49).
+	*/
+	async replaceAll(next) {
+		const held = await this.store.query.query({
+			collection: this.spec.collection,
+			filter: { limit: this.spec.loadLimit }
+		});
+		for (const [key, value] of next) await this.write(key, value);
+		const doomed = held.filter((record) => !next.has(record.id));
+		for (const record of doomed) await this.remove(record.id);
+		if (doomed.length > 0) this.logger.warn("row-map replaceAll dropped rows", { meta: {
+			collection: this.spec.collection,
+			dropped: doomed.length,
+			keys: doomed.slice(0, 20).map((r) => r.id),
+			remaining: next.size
+		} });
+		return doomed.length;
+	}
+	/**
+	* The entries matching a projected-column predicate, in the order asked for.
+	*
+	* This is what projecting columns BUYS: "every export for camera 617, newest
+	* first, capped at 50" is an indexed `WHERE` + `ORDER BY` + `LIMIT`, not a
+	* parse of the whole map followed by a filter in JS.
+	*
+	* A `limit` is REQUIRED — `settings-store.query` silently caps an unbounded
+	* read at 2 000 rows and answers as if that were everything.
+	*/
+	async readWhere(filter) {
+		const records = await this.store.query.query({
+			collection: this.spec.collection,
+			filter: {
+				...filter.where !== void 0 ? { where: filter.where } : {},
+				...filter.whereIn !== void 0 ? { whereIn: filter.whereIn } : {},
+				...filter.whereBetween !== void 0 ? { whereBetween: filter.whereBetween } : {},
+				...filter.orderBy !== void 0 ? { orderBy: filter.orderBy } : {},
+				...filter.offset !== void 0 ? { offset: filter.offset } : {},
+				limit: filter.limit ?? this.spec.loadLimit
+			}
+		});
+		const out = [];
+		let skipped = 0;
+		for (const record of records) {
+			const parsed = this.spec.schema.safeParse(record.data[ROW_MAP_VALUE_COLUMN]);
+			if (!parsed.success) {
+				skipped += 1;
+				continue;
+			}
+			out.push({
+				key: record.id,
+				value: parsed.data
+			});
+		}
+		if (skipped > 0) this.logger.warn("row-map rows skipped as unparseable", { meta: {
+			collection: this.spec.collection,
+			skipped,
+			kept: out.length
+		} });
+		return out;
+	}
+	/** How many rows match, without materialising one. */
+	async count(filter) {
+		return this.store.count.query({
+			collection: this.spec.collection,
+			...filter !== void 0 ? { filter: {
+				...filter.where !== void 0 ? { where: filter.where } : {},
+				...filter.whereIn !== void 0 ? { whereIn: filter.whereIn } : {},
+				...filter.whereBetween !== void 0 ? { whereBetween: filter.whereBetween } : {}
+			} } : {}
+		});
+	}
+	/**
+	* Delete every row matching a predicate, in ONE statement. Returns how many
+	* went, and says so — a retention trim that silently drops rows is
+	* indistinguishable from one that had nothing to do.
+	*
+	* The predicate is REQUIRED and the engine REFUSES one that compiles to
+	* nothing: deleting a whole collection is a legitimate intent, but it must be
+	* asked for by name rather than reached through an empty object.
+	*/
+	async deleteWhere(filter) {
+		const { deleted } = await this.store.deleteWhere.mutate({
+			collection: this.spec.collection,
+			filter
+		});
+		if (deleted > 0) this.logger.warn("row-map deleteWhere dropped rows", { meta: {
+			collection: this.spec.collection,
+			deleted,
+			filter
+		} });
+		return deleted;
+	}
+	/** `tags: { deviceId }` off the PROJECTED column, when the spec names one. */
+	deviceTags(row) {
+		const column = this.spec.deviceIdColumn;
+		if (column === void 0) return {};
+		const raw = row[column];
+		return typeof raw === "number" && Number.isInteger(raw) ? { tags: { deviceId: raw } } : {};
+	}
+};
+/** A store payload that is a plain object, or `null`. A type guard, not a cast. */
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/durable/retire-root-keys.ts
+/** The canonical row a forked addon's settings live in. */
+var ADDON_SETTINGS_COLLECTION = "addon-settings";
+var ADDON_SETTINGS_ROW = "root";
+/**
+* Drop every retired key whose successor is populated. Returns the keys that
+* actually went — empty when there was nothing to do.
+*/
+async function retireRootKeys(deps) {
+	let row;
+	try {
+		const raw = await deps.store.get.query({
+			namespace: deps.addonId,
+			collection: ADDON_SETTINGS_COLLECTION,
+			key: ADDON_SETTINGS_ROW
+		});
+		if (!isRecord(raw)) return [];
+		row = raw;
+	} catch (err) {
+		deps.logger.warn("retired root keys — read failed, the settings row is untouched", { meta: {
+			addonId: deps.addonId,
+			error: errText(err)
+		} });
+		return [];
+	}
+	const present = deps.specs.filter((spec) => spec.key in row);
+	if (present.length === 0) return [];
+	/** Evidence counts, memoised — several keys may share one successor. */
+	const evidence = /* @__PURE__ */ new Map();
+	const doomed = [];
+	for (const spec of present) {
+		let count = evidence.get(spec.successor);
+		if (count === void 0) {
+			try {
+				count = await deps.store.count.query({ collection: spec.successor });
+			} catch (err) {
+				deps.logger.warn("retired root key kept — its successor is unreadable", { meta: {
+					addonId: deps.addonId,
+					key: spec.key,
+					successor: spec.successor,
+					error: errText(err)
+				} });
+				count = 0;
+			}
+			evidence.set(spec.successor, count);
+		}
+		if (count === 0) {
+			deps.logger.warn("retired root key kept — its successor is EMPTY, migration has not run", { meta: {
+				addonId: deps.addonId,
+				key: spec.key,
+				successor: spec.successor
+			} });
+			continue;
+		}
+		doomed.push(spec);
+	}
+	if (doomed.length === 0) return [];
+	const dropped = new Set(doomed.map((spec) => spec.key));
+	const next = Object.fromEntries(Object.entries(row).filter(([key]) => !dropped.has(key)));
+	await deps.store.set.mutate({
+		namespace: deps.addonId,
+		collection: ADDON_SETTINGS_COLLECTION,
+		key: ADDON_SETTINGS_ROW,
+		value: next
+	});
+	const keys = doomed.map((spec) => spec.key);
+	deps.logger.info(`purged ${keys.length} retired settings key(s) from the root blob`, { meta: {
+		addonId: deps.addonId,
+		keys,
+		keptKeys: Object.keys(next),
+		reasons: doomed.map((spec) => `${spec.key}: ${spec.reason}`)
+	} });
+	return keys;
+}
+/** A store payload that is a plain object. A type guard, not a cast. */
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function errText(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+export { RowMapStore as n, retireRootKeys as t };

package/dist/retire-root-keys-KE6D6Xh_.js

@@ -0,0 +1,319 @@
+var ROW_MAP_VALUE_COLUMN = "value";
+var RowMapStore = class RowMapStore {
+	spec;
+	store;
+	logger;
+	constructor(deps) {
+		this.spec = deps.spec;
+		this.store = deps.store;
+		this.logger = deps.logger;
+	}
+	/** The collection this store owns — for the caller's own log lines. */
+	get collection() {
+		return this.spec.collection;
+	}
+	/**
+	* Register the collection. MUST run at boot, before any read or write: the
+	* SQLite backend answers 412 for an undeclared collection.
+	*/
+	static declare(store, spec) {
+		return store.declareCollection.mutate({
+			collection: spec.collection,
+			columns: [
+				{
+					name: "id",
+					type: "TEXT",
+					primaryKey: true,
+					notNull: true
+				},
+				...spec.columns,
+				{
+					name: ROW_MAP_VALUE_COLUMN,
+					type: "JSON",
+					notNull: true
+				}
+			],
+			...spec.indexes !== void 0 ? { indexes: [...spec.indexes] } : {}
+		});
+	}
+	declare() {
+		return RowMapStore.declare(this.store, this.spec);
+	}
+	/** One entry, by key. `null` when absent OR unparseable (which is said aloud). */
+	async read(key) {
+		const raw = await this.store.get.query({
+			collection: this.spec.collection,
+			key
+		});
+		if (!isRecord$1(raw)) return null;
+		const row = raw;
+		const parsed = this.spec.schema.safeParse(row[ROW_MAP_VALUE_COLUMN]);
+		if (!parsed.success) {
+			this.logger.warn("row-map row skipped as unparseable", {
+				...this.deviceTags(row),
+				meta: {
+					collection: this.spec.collection,
+					key,
+					error: parsed.error.message
+				}
+			});
+			return null;
+		}
+		return parsed.data;
+	}
+	/**
+	* Every entry, keyed. Unparseable rows are skipped — one bad entry costs that
+	* entry, never the map.
+	*/
+	async readAll() {
+		const records = await this.store.query.query({
+			collection: this.spec.collection,
+			filter: { limit: this.spec.loadLimit }
+		});
+		const out = /* @__PURE__ */ new Map();
+		let skipped = 0;
+		for (const record of records) {
+			const parsed = this.spec.schema.safeParse(record.data[ROW_MAP_VALUE_COLUMN]);
+			if (!parsed.success) {
+				skipped += 1;
+				continue;
+			}
+			out.set(record.id, parsed.data);
+		}
+		if (skipped > 0) this.logger.warn("row-map rows skipped as unparseable", { meta: {
+			collection: this.spec.collection,
+			skipped,
+			kept: out.size
+		} });
+		if (records.length >= this.spec.loadLimit) this.logger.warn("row-map read hit its own bound — the map may be truncated", { meta: {
+			collection: this.spec.collection,
+			loadLimit: this.spec.loadLimit
+		} });
+		return out;
+	}
+	/** Insert or replace ONE entry. Validates at the boundary. */
+	async write(key, value) {
+		const validated = this.spec.schema.parse(value);
+		const columns = this.spec.project(key, validated);
+		await this.store.set.mutate({
+			collection: this.spec.collection,
+			key,
+			value: {
+				...columns,
+				[ROW_MAP_VALUE_COLUMN]: validated
+			}
+		});
+	}
+	/** Drop ONE entry. Idempotent. */
+	async remove(key) {
+		await this.store.delete.mutate({
+			collection: this.spec.collection,
+			key
+		});
+	}
+	/**
+	* Make the collection hold exactly `next` — the write path for an owner whose
+	* in-memory map IS the authority (a persister handed the complete set).
+	*
+	* Returns how many rows were DELETED, and says so out loud when any were: a
+	* replace that silently drops rows is indistinguishable from one that never
+	* had them. Only an owner holding an authoritative set may call this — a
+	* prune driven by a fallible read is work destroyed (D130, D49).
+	*/
+	async replaceAll(next) {
+		const held = await this.store.query.query({
+			collection: this.spec.collection,
+			filter: { limit: this.spec.loadLimit }
+		});
+		for (const [key, value] of next) await this.write(key, value);
+		const doomed = held.filter((record) => !next.has(record.id));
+		for (const record of doomed) await this.remove(record.id);
+		if (doomed.length > 0) this.logger.warn("row-map replaceAll dropped rows", { meta: {
+			collection: this.spec.collection,
+			dropped: doomed.length,
+			keys: doomed.slice(0, 20).map((r) => r.id),
+			remaining: next.size
+		} });
+		return doomed.length;
+	}
+	/**
+	* The entries matching a projected-column predicate, in the order asked for.
+	*
+	* This is what projecting columns BUYS: "every export for camera 617, newest
+	* first, capped at 50" is an indexed `WHERE` + `ORDER BY` + `LIMIT`, not a
+	* parse of the whole map followed by a filter in JS.
+	*
+	* A `limit` is REQUIRED — `settings-store.query` silently caps an unbounded
+	* read at 2 000 rows and answers as if that were everything.
+	*/
+	async readWhere(filter) {
+		const records = await this.store.query.query({
+			collection: this.spec.collection,
+			filter: {
+				...filter.where !== void 0 ? { where: filter.where } : {},
+				...filter.whereIn !== void 0 ? { whereIn: filter.whereIn } : {},
+				...filter.whereBetween !== void 0 ? { whereBetween: filter.whereBetween } : {},
+				...filter.orderBy !== void 0 ? { orderBy: filter.orderBy } : {},
+				...filter.offset !== void 0 ? { offset: filter.offset } : {},
+				limit: filter.limit ?? this.spec.loadLimit
+			}
+		});
+		const out = [];
+		let skipped = 0;
+		for (const record of records) {
+			const parsed = this.spec.schema.safeParse(record.data[ROW_MAP_VALUE_COLUMN]);
+			if (!parsed.success) {
+				skipped += 1;
+				continue;
+			}
+			out.push({
+				key: record.id,
+				value: parsed.data
+			});
+		}
+		if (skipped > 0) this.logger.warn("row-map rows skipped as unparseable", { meta: {
+			collection: this.spec.collection,
+			skipped,
+			kept: out.length
+		} });
+		return out;
+	}
+	/** How many rows match, without materialising one. */
+	async count(filter) {
+		return this.store.count.query({
+			collection: this.spec.collection,
+			...filter !== void 0 ? { filter: {
+				...filter.where !== void 0 ? { where: filter.where } : {},
+				...filter.whereIn !== void 0 ? { whereIn: filter.whereIn } : {},
+				...filter.whereBetween !== void 0 ? { whereBetween: filter.whereBetween } : {}
+			} } : {}
+		});
+	}
+	/**
+	* Delete every row matching a predicate, in ONE statement. Returns how many
+	* went, and says so — a retention trim that silently drops rows is
+	* indistinguishable from one that had nothing to do.
+	*
+	* The predicate is REQUIRED and the engine REFUSES one that compiles to
+	* nothing: deleting a whole collection is a legitimate intent, but it must be
+	* asked for by name rather than reached through an empty object.
+	*/
+	async deleteWhere(filter) {
+		const { deleted } = await this.store.deleteWhere.mutate({
+			collection: this.spec.collection,
+			filter
+		});
+		if (deleted > 0) this.logger.warn("row-map deleteWhere dropped rows", { meta: {
+			collection: this.spec.collection,
+			deleted,
+			filter
+		} });
+		return deleted;
+	}
+	/** `tags: { deviceId }` off the PROJECTED column, when the spec names one. */
+	deviceTags(row) {
+		const column = this.spec.deviceIdColumn;
+		if (column === void 0) return {};
+		const raw = row[column];
+		return typeof raw === "number" && Number.isInteger(raw) ? { tags: { deviceId: raw } } : {};
+	}
+};
+/** A store payload that is a plain object, or `null`. A type guard, not a cast. */
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/durable/retire-root-keys.ts
+/** The canonical row a forked addon's settings live in. */
+var ADDON_SETTINGS_COLLECTION = "addon-settings";
+var ADDON_SETTINGS_ROW = "root";
+/**
+* Drop every retired key whose successor is populated. Returns the keys that
+* actually went — empty when there was nothing to do.
+*/
+async function retireRootKeys(deps) {
+	let row;
+	try {
+		const raw = await deps.store.get.query({
+			namespace: deps.addonId,
+			collection: ADDON_SETTINGS_COLLECTION,
+			key: ADDON_SETTINGS_ROW
+		});
+		if (!isRecord(raw)) return [];
+		row = raw;
+	} catch (err) {
+		deps.logger.warn("retired root keys — read failed, the settings row is untouched", { meta: {
+			addonId: deps.addonId,
+			error: errText(err)
+		} });
+		return [];
+	}
+	const present = deps.specs.filter((spec) => spec.key in row);
+	if (present.length === 0) return [];
+	/** Evidence counts, memoised — several keys may share one successor. */
+	const evidence = /* @__PURE__ */ new Map();
+	const doomed = [];
+	for (const spec of present) {
+		let count = evidence.get(spec.successor);
+		if (count === void 0) {
+			try {
+				count = await deps.store.count.query({ collection: spec.successor });
+			} catch (err) {
+				deps.logger.warn("retired root key kept — its successor is unreadable", { meta: {
+					addonId: deps.addonId,
+					key: spec.key,
+					successor: spec.successor,
+					error: errText(err)
+				} });
+				count = 0;
+			}
+			evidence.set(spec.successor, count);
+		}
+		if (count === 0) {
+			deps.logger.warn("retired root key kept — its successor is EMPTY, migration has not run", { meta: {
+				addonId: deps.addonId,
+				key: spec.key,
+				successor: spec.successor
+			} });
+			continue;
+		}
+		doomed.push(spec);
+	}
+	if (doomed.length === 0) return [];
+	const dropped = new Set(doomed.map((spec) => spec.key));
+	const next = Object.fromEntries(Object.entries(row).filter(([key]) => !dropped.has(key)));
+	await deps.store.set.mutate({
+		namespace: deps.addonId,
+		collection: ADDON_SETTINGS_COLLECTION,
+		key: ADDON_SETTINGS_ROW,
+		value: next
+	});
+	const keys = doomed.map((spec) => spec.key);
+	deps.logger.info(`purged ${keys.length} retired settings key(s) from the root blob`, { meta: {
+		addonId: deps.addonId,
+		keys,
+		keptKeys: Object.keys(next),
+		reasons: doomed.map((spec) => `${spec.key}: ${spec.reason}`)
+	} });
+	return keys;
+}
+/** A store payload that is a plain object. A type guard, not a cast. */
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function errText(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+Object.defineProperty(exports, "RowMapStore", {
+	enumerable: true,
+	get: function() {
+		return RowMapStore;
+	}
+});
+Object.defineProperty(exports, "retireRootKeys", {
+	enumerable: true,
+	get: function() {
+		return retireRootKeys;
+	}
+});

package/dist/session-decode/decode-worker-child.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_worker_protocol = require("../worker-protocol-BrlrMxXu.js");
-const require_lazy_sharp = require("../lazy-sharp-oYppDIZR.js");
+const require_worker_protocol = require("../worker-protocol-BePduZVV.js");
+const require_lazy_sharp = require("../lazy-sharp-RxUs6on_.js");
 //#region src/session-decode/color-conversion.ts
 /**
 * Explicit YUV→RGB colorspace/range resolution for the session-decode worker.

package/dist/session-decode/decode-worker-child.mjs

@@ -1,4 +1,4 @@
-import { i as formatNativeLeaseKnobs, n as isWorkerRequest, o as resolveNativeLeaseKnobs, r as logLevelForLine } from "../worker-protocol-DJWdPLKF.mjs";
+import { i as formatNativeLeaseKnobs, n as isWorkerRequest, o as resolveNativeLeaseKnobs, r as logLevelForLine } from "../worker-protocol-DDpliBIW.mjs";
 import { n as setSharpWarnSink, r as hostExternalEntryUrls, t as getSharp } from "../lazy-sharp-6oymT_yf.mjs";
 //#region src/session-decode/color-conversion.ts
 /**

package/dist/stream-broker/_stub.js

@@ -1,7 +1,7 @@
 import { a as e, c as t, d as n, f as r, i, l as a, n as o, o as s, p as c, r as l, s as u, t as d, u as f } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_camstack_mf_1_ui_mf_2_library__loadShare__.js-DsIi4G5Q.mjs";
 import { a as p, i as m, n as h, o as g, r as _, t as v } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare__react__loadShare__.js-C9j-2lBe.mjs";
 import { n as y, r as b, t as x } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare__react_mf_1_jsx_mf_2_runtime__loadShare__.js-XO0-Pyu6.mjs";
-import { t as S } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_camstack_mf_1_types__loadShare__.js-zT-cYUdF.mjs";
+import { t as S } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_camstack_mf_1_types__loadShare__.js-DY31bUCj.mjs";
 import { n as C, t as w } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_tanstack_mf_1_react_mf_2_query__loadShare__.js-BO7TIbJV.mjs";
 //#region ../../node_modules/lucide-react/dist/esm/shared/src/utils.js
 var T = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), E = (e) => e.replace(/^([A-Z])|[\s-_]+(\w)/g, (e, t, n) => n ? n.toUpperCase() : t.toLowerCase()), D = (e) => {

package/dist/stream-broker/{_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-B7ERJocD.mjs → _virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-BdgcF1lL.mjs}

@@ -18,7 +18,7 @@ var e = {
 	},
 	"@camstack/types": {
 		name: "@camstack/types",
-		version: "1.2.90",
+		version: "1.2.92",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",
@@ -33,7 +33,7 @@ var e = {
 	},
 	"@camstack/ui-library": {
 		name: "@camstack/ui-library",
-		version: "1.2.62",
+		version: "1.2.63",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",