@camstack/types 1.2.421 → 1.2.422

package/dist/{composition-B2rw5L29.mjs → composition-CpETZ4HL.mjs}

@@ -2232,6 +2232,544 @@ function sourcePickForAppliance() {
 	};
 }
 //#endregion
+//#region src/composition/helpers/energy.ts
+/**
+* Watts integrated over time, in kWh (D944).
+*
+* 1 kWh = 1 000 W × 3 600 000 ms. The history energy series uses the same
+* factor (`tw_sum / 3.6e9`), so a chart and an integral helper cannot diverge.
+*/
+var KWH_PER_WATT_MS = 1 / 36e8;
+function wattMillisecondsToKwh(wattMilliseconds) {
+	return wattMilliseconds * KWH_PER_WATT_MS;
+}
+//#endregion
+//#region src/composition/helpers/history-math.ts
+/**
+* Statistics and integrals over a history read (D944).
+*
+* Pure: the same points always give the same answer, so a restart recomputes
+* rather than trusting a buffer. A gauge mean is time-weighted (value × ms),
+* never the mean of the samples. A hole with no held value is not integrated
+* as zero. A truncated read is not published.
+*/
+var STATISTIC_STATS = [
+	"min",
+	"max",
+	"mean",
+	"sum",
+	"count",
+	"change"
+];
+var SERIES_KINDS = [
+	"gauge",
+	"counter",
+	"boolean"
+];
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function pointValue(point) {
+	if (finite(point.value)) return point.value;
+	if (finite(point.last)) return point.last;
+	return null;
+}
+function stepCoverage(read) {
+	const points = read.points.filter((point) => point.t >= read.from && point.t < read.to);
+	const start = finite(read.before?.value) ? read.before.value : null;
+	let held = start;
+	let cursor = read.from;
+	let gaps = 0;
+	const segments = [];
+	if (held === null) {
+		const first = points.find((point) => pointValue(point) !== null);
+		if (first === void 0) return {
+			segments,
+			included: 0,
+			gaps: 1,
+			end: null,
+			start: null
+		};
+		if (first.t > read.from) gaps += 1;
+		cursor = first.t;
+		held = pointValue(first);
+	}
+	for (const point of points) {
+		const next = pointValue(point);
+		if (held !== null && point.t > cursor) segments.push({
+			value: held,
+			ms: point.t - cursor
+		});
+		if (next !== null) held = next;
+		if (point.t > cursor) cursor = point.t;
+	}
+	if (held !== null && read.to > cursor) segments.push({
+		value: held,
+		ms: read.to - cursor
+	});
+	const end = points.reduce((latest, point) => pointValue(point) ?? latest, held);
+	return {
+		segments,
+		included: points.length,
+		gaps,
+		end,
+		start
+	};
+}
+function rollupCoverage(read) {
+	const weighted = read.points.filter((point) => finite(point.twMean) && finite(point.twMs) && point.twMs > 0);
+	if (weighted.length === 0) return null;
+	const first = weighted[0];
+	const gaps = read.before === null && first !== void 0 && first.t > read.from ? 1 : 0;
+	const levels = read.points.flatMap((point) => finite(point.last) ? [point.last] : []);
+	const end = levels.length > 0 ? levels[levels.length - 1] ?? null : null;
+	return {
+		segments: weighted.flatMap((point) => finite(point.twMean) && finite(point.twMs) ? [{
+			value: point.twMean,
+			ms: point.twMs
+		}] : []),
+		included: weighted.length,
+		gaps,
+		end,
+		start: finite(read.before?.value) ? read.before.value : null
+	};
+}
+function coverageOf(read) {
+	if (read.tier !== "raw") {
+		const rolled = rollupCoverage(read);
+		if (rolled !== null) return rolled;
+	}
+	return stepCoverage(read);
+}
+function timeWeighted(segments) {
+	let ms = 0;
+	let sum = 0;
+	for (const segment of segments) {
+		ms += segment.ms;
+		sum += segment.value * segment.ms;
+	}
+	if (ms <= 0) return null;
+	return sum / ms;
+}
+function extremes(read, covered) {
+	const lows = [];
+	const highs = [];
+	for (const point of read.points) {
+		if (finite(point.min)) lows.push(point.min);
+		if (finite(point.max)) highs.push(point.max);
+	}
+	if (covered.start !== null) {
+		lows.push(covered.start);
+		highs.push(covered.start);
+	}
+	return {
+		min: lows.length === 0 ? null : Math.min(...lows),
+		max: highs.length === 0 ? null : Math.max(...highs)
+	};
+}
+function counterGrowth(read) {
+	const deltas = read.points.flatMap((point) => finite(point.delta) ? [point.delta] : []);
+	if (deltas.length === 0) return null;
+	return deltas.reduce((sum, delta) => sum + delta, 0);
+}
+function hold(reason) {
+	return {
+		write: "hold",
+		value: null,
+		included: 0,
+		excluded: 0,
+		reason
+	};
+}
+function gapValue(reason, included) {
+	return {
+		write: "null",
+		value: null,
+		included,
+		excluded: 1,
+		reason
+	};
+}
+function numberValue(value, included, gaps, reason) {
+	return {
+		write: "number",
+		value,
+		included,
+		excluded: gaps,
+		reason: gaps > 0 ? reason : null
+	};
+}
+var GAP_REASON = "history has a gap — that interval was not counted as zero";
+function evaluateStatistic(stat, read) {
+	if (read.truncated) return hold("the history query was truncated — the last statistic is kept");
+	if (stat === "sum" && read.kind !== "counter") return hold("a gauge has no sum — that is the integral template");
+	if (read.to <= read.from) return gapValue("the range is empty", 0);
+	const covered = coverageOf(read);
+	if (covered.segments.length === 0 && covered.start === null) return gapValue(GAP_REASON, covered.included);
+	if (stat === "count") return numberValue(covered.included, covered.included, covered.gaps, GAP_REASON);
+	if (stat === "sum" || stat === "change" && read.kind === "counter") {
+		const growth = counterGrowth(read);
+		if (growth === null) return gapValue("the counter has no growth in this range", covered.included);
+		return numberValue(growth, covered.included, covered.gaps, GAP_REASON);
+	}
+	if (stat === "change") {
+		if (covered.start === null || covered.end === null) return gapValue("the change has no value at the start of the range", covered.included);
+		return numberValue(covered.end - covered.start, covered.included, covered.gaps, GAP_REASON);
+	}
+	if (stat === "min" || stat === "max") {
+		const ends = extremes(read, covered);
+		const value = stat === "min" ? ends.min : ends.max;
+		if (value === null) return gapValue(GAP_REASON, covered.included);
+		return numberValue(value, covered.included, covered.gaps, GAP_REASON);
+	}
+	const mean = timeWeighted(covered.segments);
+	if (mean === null) return gapValue(GAP_REASON, covered.included);
+	return numberValue(mean, covered.included, covered.gaps, GAP_REASON);
+}
+function integrateReading(read, scale) {
+	if (read.truncated) return hold("the history query was truncated — the last total is kept");
+	if (read.kind === "counter") return hold("a counter is already a total — it is not integrated again");
+	if (read.to <= read.from) return gapValue("the range is empty", 0);
+	const covered = coverageOf(read);
+	if (covered.segments.length === 0) return {
+		write: "hold",
+		value: null,
+		included: covered.included,
+		excluded: covered.gaps,
+		reason: GAP_REASON
+	};
+	let unitMs = 0;
+	for (const segment of covered.segments) unitMs += segment.value * segment.ms;
+	return numberValue(scale === "energy-kwh" ? wattMillisecondsToKwh(unitMs) : unitMs / 1e3, covered.included, covered.gaps, GAP_REASON);
+}
+//#endregion
+//#region src/composition/helpers/history-window.ts
+/**
+* The range a statistics or integral helper asks history for (D944).
+*
+* Calendar edges are the hub's timezone, never UTC midnight: a day is 23, 24
+* or 25 hours across a DST change. A tier is eligible only when its retention
+* is strictly longer than the longest that range can be. Forever qualifies.
+* Equal to a tier's retention is a refusal, not a short answer.
+*/
+var MINUTE_MS = 6e4;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var ROLLING_SPANS = [
+	"1h",
+	"24h",
+	"2d",
+	"7d",
+	"30d",
+	"custom"
+];
+var CALENDAR_PERIODS = [
+	"today",
+	"yesterday",
+	"this-week",
+	"this-month"
+];
+var HISTORY_TIERS = [
+	"raw",
+	"5m",
+	"1h",
+	"1d"
+];
+var RESET_PERIODS = [
+	"never",
+	"daily",
+	"weekly",
+	"monthly"
+];
+var MIN_CUSTOM_MINUTES = 5;
+/** Faster than this is not a history query. Rolling windows at most this often. */
+var HISTORY_FAST_MS = 6e4;
+var HISTORY_SLOW_MS = 5 * MINUTE_MS;
+var ROLLING_MS = {
+	"1h": HOUR_MS,
+	"24h": 24 * HOUR_MS,
+	"2d": 2 * DAY_MS,
+	"7d": 7 * DAY_MS,
+	"30d": 30 * DAY_MS
+};
+/** The device-history defaults: raw 7 d, 5 m 30 d, 1 h 365 d, 1 d forever. */
+var DEFAULT_HISTORY_RETENTION = {
+	rawMs: 7 * DAY_MS,
+	fiveMinuteMs: 30 * DAY_MS,
+	hourMs: 365 * DAY_MS,
+	dayMs: null
+};
+var rollingWindowObject = z.object({
+	kind: z.literal("rolling"),
+	span: z.enum(ROLLING_SPANS),
+	customMinutes: z.number().int().min(5).optional()
+}).check((payload) => {
+	if (payload.value.span === "custom" && payload.value.customMinutes === void 0) payload.issues.push({
+		code: "custom",
+		message: "a custom range needs a duration in minutes",
+		path: ["customMinutes"],
+		input: payload.value
+	});
+	if (payload.value.span !== "custom" && payload.value.customMinutes !== void 0) payload.issues.push({
+		code: "custom",
+		message: "only a custom range carries a duration",
+		path: ["customMinutes"],
+		input: payload.value
+	});
+});
+var RollingWindowSchema = rollingWindowObject;
+var calendarWindowObject = z.object({
+	kind: z.literal("calendar"),
+	period: z.enum(CALENDAR_PERIODS)
+});
+var CalendarWindowSchema = calendarWindowObject;
+var StatisticWindowSchema = z.discriminatedUnion("kind", [rollingWindowObject, calendarWindowObject]);
+var WEEKDAY_INDEX = {
+	Sun: 0,
+	Mon: 1,
+	Tue: 2,
+	Wed: 3,
+	Thu: 4,
+	Fri: 5,
+	Sat: 6
+};
+var FORMATTERS = /* @__PURE__ */ new Map();
+function formatterFor(timeZone) {
+	const held = FORMATTERS.get(timeZone);
+	if (held !== void 0) return held;
+	let made;
+	try {
+		made = new Intl.DateTimeFormat("en-US", {
+			timeZone,
+			weekday: "short",
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit",
+			hourCycle: "h23"
+		});
+	} catch {
+		made = null;
+	}
+	FORMATTERS.set(timeZone, made);
+	return made;
+}
+function zonedClock(ms, timeZone) {
+	const formatter = formatterFor(timeZone);
+	if (formatter === null) return null;
+	const parts = formatter.formatToParts(new Date(ms));
+	const read = (type) => parts.find((part) => part.type === type)?.value;
+	const year = Number(read("year"));
+	const month = Number(read("month"));
+	const day = Number(read("day"));
+	const hourRaw = Number(read("hour"));
+	const minute = Number(read("minute"));
+	const second = Number(read("second"));
+	const weekday = WEEKDAY_INDEX[read("weekday") ?? ""];
+	if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day) || !Number.isInteger(hourRaw) || !Number.isInteger(minute) || !Number.isInteger(second) || weekday === void 0) return null;
+	return {
+		year,
+		month,
+		day,
+		hour: hourRaw === 24 ? 0 : hourRaw,
+		minute,
+		second,
+		weekday
+	};
+}
+function utcOf(clock, timeZone) {
+	const guess = Date.UTC(clock.year, clock.month - 1, clock.day, clock.hour, clock.minute, clock.second);
+	const first = zonedClock(guess, timeZone);
+	if (first === null) return null;
+	const offset = Date.UTC(first.year, first.month - 1, first.day, first.hour, first.minute, first.second) - guess;
+	const shifted = guess - offset;
+	const second = zonedClock(shifted, timeZone);
+	if (second === null) return null;
+	const offset2 = Date.UTC(second.year, second.month - 1, second.day, second.hour, second.minute, second.second) - shifted;
+	return offset2 === offset ? shifted : guess - offset2;
+}
+function midnightOf(ms, timeZone) {
+	const clock = zonedClock(ms, timeZone);
+	if (clock === null) return null;
+	return utcOf({
+		...clock,
+		hour: 0,
+		minute: 0,
+		second: 0
+	}, timeZone);
+}
+function monthStart(ms, timeZone) {
+	const clock = zonedClock(ms, timeZone);
+	if (clock === null) return null;
+	return utcOf({
+		...clock,
+		day: 1,
+		hour: 0,
+		minute: 0,
+		second: 0
+	}, timeZone);
+}
+function weekStart(ms, timeZone) {
+	const clock = zonedClock(ms, timeZone);
+	let cursor = midnightOf(ms, timeZone);
+	if (clock === null || cursor === null) return null;
+	const back = clock.weekday === 0 ? 6 : clock.weekday - 1;
+	for (let step = 0; step < back; step++) {
+		const previous = midnightOf(cursor - 1, timeZone);
+		if (previous === null) return null;
+		cursor = previous;
+	}
+	return cursor;
+}
+function keptLabel(ms) {
+	if (ms === null) return "forever";
+	if (ms % 864e5 === 0) return `${ms / DAY_MS} d`;
+	if (ms % 36e5 === 0) return `${ms / HOUR_MS} h`;
+	return `${ms / MINUTE_MS} min`;
+}
+function retentionSentence(retention) {
+	return `raw ${keptLabel(retention.rawMs)}, 5m ${keptLabel(retention.fiveMinuteMs)}, 1h ${keptLabel(retention.hourMs)}, 1d ${keptLabel(retention.dayMs)}`;
+}
+function tierFor(durationMs, retention) {
+	const rows = [
+		{
+			tier: "raw",
+			keptMs: retention.rawMs
+		},
+		{
+			tier: "5m",
+			keptMs: retention.fiveMinuteMs
+		},
+		{
+			tier: "1h",
+			keptMs: retention.hourMs
+		},
+		{
+			tier: "1d",
+			keptMs: retention.dayMs
+		}
+	];
+	for (const row of rows) if (row.keptMs === null || row.keptMs > durationMs) return {
+		ok: true,
+		tier: row.tier,
+		maxDurationMs: durationMs
+	};
+	return {
+		ok: false,
+		reason: `the range is ${keptLabel(durationMs)} and no history tier is kept strictly longer (${retentionSentence(retention)})`
+	};
+}
+function rollingDurationMs(window) {
+	if (window.span === "custom") return window.customMinutes === void 0 ? null : window.customMinutes * MINUTE_MS;
+	return ROLLING_MS[window.span];
+}
+/** Longest the window can be. Calendar periods use their full length, not the elapsed part. */
+function maxDurationMs(window) {
+	if (window.kind === "rolling") return rollingDurationMs(window);
+	switch (window.period) {
+		case "today":
+		case "yesterday": return 25 * HOUR_MS;
+		case "this-week": return 6084e5;
+		case "this-month": return 2682e6;
+	}
+}
+function planStatisticTier(window, retention) {
+	const duration = maxDurationMs(window);
+	if (duration === null) return {
+		ok: false,
+		reason: "a custom range needs a duration of at least 5 minutes"
+	};
+	return tierFor(duration, retention);
+}
+function planResetTier(reset, retention) {
+	switch (reset) {
+		case "never": return tierFor(Number.POSITIVE_INFINITY, retention);
+		case "daily": return tierFor(25 * HOUR_MS, retention);
+		case "weekly": return tierFor(6084e5, retention);
+		case "monthly": return tierFor(2682e6, retention);
+	}
+}
+function openStatistic(window, now, timeZone) {
+	if (window.kind === "rolling") {
+		const duration = rollingDurationMs(window);
+		if (duration === null) return null;
+		return {
+			from: now - duration,
+			to: now
+		};
+	}
+	const today = midnightOf(now, timeZone);
+	if (today === null) return null;
+	switch (window.period) {
+		case "today": return {
+			from: today,
+			to: now
+		};
+		case "yesterday": {
+			const start = midnightOf(today - 1, timeZone);
+			return start === null ? null : {
+				from: start,
+				to: today
+			};
+		}
+		case "this-week": {
+			const start = weekStart(now, timeZone);
+			return start === null ? null : {
+				from: start,
+				to: now
+			};
+		}
+		case "this-month": {
+			const start = monthStart(now, timeZone);
+			return start === null ? null : {
+				from: start,
+				to: now
+			};
+		}
+	}
+}
+function openReset(reset, now, timeZone) {
+	if (reset === "never") return {
+		from: 0,
+		to: now
+	};
+	const today = midnightOf(now, timeZone);
+	if (today === null) return null;
+	if (reset === "daily") return {
+		from: today,
+		to: now
+	};
+	if (reset === "weekly") {
+		const start = weekStart(now, timeZone);
+		return start === null ? null : {
+			from: start,
+			to: now
+		};
+	}
+	const start = monthStart(now, timeZone);
+	return start === null ? null : {
+		from: start,
+		to: now
+	};
+}
+/** The next hub-local midnight, strictly after `now`. Monday is one of these. */
+function nextLocalMidnight(now, timeZone) {
+	const today = midnightOf(now, timeZone);
+	if (today === null) return null;
+	return midnightOf(today + 26 * HOUR_MS, timeZone);
+}
+function statisticCadenceMs(window) {
+	if (window.kind === "calendar") return window.period === "today" ? HISTORY_FAST_MS : HISTORY_SLOW_MS;
+	const duration = rollingDurationMs(window);
+	if (duration !== null && duration <= 24 * 36e5) return HISTORY_FAST_MS;
+	return HISTORY_SLOW_MS;
+}
+function integralCadenceMs(tier) {
+	return tier === "raw" ? HISTORY_FAST_MS : HISTORY_SLOW_MS;
+}
+//#endregion
 //#region src/composition/source-ref.ts
 /**
 * A composition source identity: `(addonId, stableId)`, never a numeric device
@@ -2297,10 +2835,7 @@ var HelperMemberSchema = z.object({
 	cap: z.string().min(1),
 	fieldPath: z.string().min(1)
 });
-/**
-* Phase 1a is groups only. Math, integral and statistics stay off this union
-* until the composer can run them — a control must not save a spec it cannot.
-*/
+/** A group, a statistic, or an integral (D944). The composer runs all three. */
 var GroupHelperSpecSchema = z.object({
 	kind: z.literal("group"),
 	templateId: GroupTemplateIdSchema,
@@ -2318,10 +2853,35 @@ var ApplianceHelperSpecSchema = z.object({
 	stopDwellMs: z.number().int().nonnegative(),
 	member: HelperMemberSchema
 });
-var HelperSpecSchema = z.discriminatedUnion("kind", [GroupHelperSpecSchema, ApplianceHelperSpecSchema]);
-/** Every member a helper reads. An appliance has one. */
+var statisticHelperObject = z.object({
+	kind: z.literal("statistic"),
+	stat: z.enum(STATISTIC_STATS),
+	window: StatisticWindowSchema,
+	source: HelperMemberSchema
+});
+var StatisticHelperSpecSchema = statisticHelperObject;
+var INTEGRAL_OUTPUTS = ["energy", "meter"];
+var integralHelperObject = z.object({
+	kind: z.literal("integral"),
+	reset: z.enum(RESET_PERIODS),
+	output: z.enum(INTEGRAL_OUTPUTS),
+	source: HelperMemberSchema
+});
+var IntegralHelperSpecSchema = integralHelperObject;
+var HelperSpecSchema = z.discriminatedUnion("kind", [
+	GroupHelperSpecSchema,
+	ApplianceHelperSpecSchema,
+	statisticHelperObject,
+	integralHelperObject
+]);
+/** Every member a helper reads. A group has many; the others have one. */
 function helperMembers(spec) {
-	return spec.kind === "group" ? spec.members : [spec.member];
+	switch (spec.kind) {
+		case "group": return spec.members;
+		case "appliance": return [spec.member];
+		case "statistic":
+		case "integral": return [spec.source];
+	}
 }
 //#endregion
 //#region src/composition/composition.ts
@@ -2432,11 +2992,36 @@ var CompositionAggregateSourceSchema = z.object({
 		"offline"
 	])
 });
+/**
+* `series`: a statistics or integral field. The composer writes it from a
+* history query. The live pass does not recompute it (D944).
+*/
+var CompositionSeriesSourceSchema = z.object({
+	kind: z.literal("series"),
+	read: CompositionFieldReadSchema,
+	/** `value` is the statistic or the integral. The others are the gap counts. */
+	publish: z.enum([
+		"value",
+		"included",
+		"excluded",
+		"total"
+	]),
+	/**
+	* What an unanswered `value` does. Counts ignore this. `offline` leaves the
+	* device unseeded until history answers, so a restart cannot publish 0.
+	*/
+	empty: z.enum([
+		"null",
+		"omit",
+		"offline"
+	])
+});
 var CompositionFieldSourceSchema = z.discriminatedUnion("kind", [
 	CompositionFromSourceSchema,
 	CompositionExpressionSourceSchema,
 	CompositionCodeSourceSchema,
-	CompositionAggregateSourceSchema
+	CompositionAggregateSourceSchema,
+	CompositionSeriesSourceSchema
 ]);
 /** `forward`: RESERVED for slice 3. Argument mapping arrives there as an additive optional `args`. */
 var CompositionForwardCommandSchema = z.object({
@@ -2556,6 +3141,7 @@ function fieldReads(source) {
 			fieldPath: binding.fieldPath
 		}] : []);
 		case "aggregate": return source.reads;
+		case "series": return [source.read];
 		case "code": return [];
 	}
 }
@@ -2582,4 +3168,4 @@ function featureSources(feature) {
 	return featureFieldEntries(feature).map((e) => e.source);
 }
 //#endregion
-export { APPLIANCE_DEFAULTS as $, audioPlanFromEncodeProfile as $t, compositionFeatureEnabled as A, evaluateRose as At, ActiveCriterionSchema as B, evaluateSensorLevelEdge as Bt, CompositionTargetSchema as C, MAX_EXPRESSION_EVAL_STEPS as Ct, MAX_COMPOSITION_ITEMS as D, EXPRESSION_BUILTIN_NAMES as Dt, MAX_COMPOSITION_FIELDS_PER_FEATURE as E, EXPRESSION_BUILTINS as Et, featureFieldEntries as F, SOURCE_CAPS as Ft, GroupHelperSpecSchema as G, chooseFfmpegBinary as Gt, ApplianceHelperSpecSchema as H, sliceActiveValue as Ht, featureSources as I, SOURCE_CAP_ACTIVE_FIELD as It, HelperSpecSchema as J, getFfmpegArtifact as Jt, GroupTemplateIdSchema as K, ffmpegBinaryName as Kt, fieldReads as L, SOURCE_CAP_CHANGED_AT_FIELD as Lt, compositionReadKey as M, ExpressionEvalError as Mt, compositionSliceKey as N, ExpressionParseError as Nt, composedDeviceRef as O, disarmRoseMemory as Ot, compositionSourceKey as P, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as Pt, CompositionSourceRefSchema as Q, AUDIO_PRESETS as Qt, ACTIVE_CRITERIA as R, SOURCE_DEVICE_TYPES as Rt, CompositionSchema as S, MAX_EXPRESSION_CALL_ARGS as St, MAX_COMPOSITION_FEATURES as T, RESERVED_BINDING_NAMES as Tt, BINARY_AGGREGATES as U, sliceChangedAt as Ut, AggregateReducerSchema as V, isSourceCap as Vt, GROUP_TEMPLATE_IDS as W, FFMPEG_PATH_ENV as Wt, NUMERIC_AGGREGATES as X, canonicalHash as Xt, MAX_HELPER_MEMBERS as Y, getFfmpegDownloadUrl as Yt, helperMembers as Z, Fmp4BoxSplitter as Zt, CompositionFromSourceSchema as _, tokenize as _t, CUSTOMIZATION_BLOCK_NAME_PREFIX as a, isSoftwareDecode as an, EXPRESSION_INJECTED_NOW as at, CompositionNewTargetSchema as b, MAX_EXPRESSION_AST_NODES as bt, CompositionCodeSourceSchema as c, resolveStreamMaps as cn, evaluateExpressionSource as ct, CompositionExpressionSourceSchema as d, validateExpressionSource as dt, buildAudioArgs as en, APPLIANCE_KINDS as et, CompositionFeatureSchema as f, createExpressionScope as ft, CompositionForwardCommandSchema as g, parseExpression as gt, CompositionFieldsFeatureSchema as h, compileExpressionSafe as ht, COMPOSITION_ITEM_KEY_RE as i, invocationFromEncodeProfile as in, sourcePickForAppliance as it, compositionItemFieldPath as j, isStatefulBuiltin as jt, composedDeviceStableId as k, evaluateCount as kt, CompositionCommandTargetSchema as l, evaluateStatefulExpressionCall as lt, CompositionFieldSourceSchema as m, compileExpression as mt, COMPOSER_ADDON_ID as n, buildInputArgs as nn, applianceDeviceType as nt, CompositionAggregateSourceSchema as o, logBannerArgs as on, cloneStatefulExpressionMemory as ot, CompositionFieldReadSchema as p, evaluateAst as pt, HelperMemberSchema as q, FFMPEG_RELEASE as qt, COMPOSITION_ITEM_ARRAY_PATH as r, buildVideoArgs as rn, isApplianceKind as rt, CompositionBindingSchema as s, pickVideoEncoder as sn, createStatefulExpressionMemory as st, COMPOSED_DEVICE_STABLE_ID_PREFIX as t, buildFfmpegArgs as tn, APPLIANCE_TEMPLATE_ID as tt, CompositionExistingTargetSchema as u, toExpressionValue as ut, CompositionItemEntrySchema as v, EXPRESSION_COMPILE_CACHE_CAPACITY as vt, MAX_COMPOSITION_CODE_LENGTH as w, MAX_EXPRESSION_SOURCE_LENGTH as wt, CompositionPassthroughFeatureSchema as x, MAX_EXPRESSION_BINDINGS as xt, CompositionLiteralBindingSchema as y, EXPRESSION_IDENTIFIER_RE as yt, AGGREGATE_REDUCERS as z, evaluateSensorEdge as zt };
+export { NUMERIC_AGGREGATES as $, MAX_EXPRESSION_AST_NODES as $t, composedDeviceStableId as A, Fmp4BoxSplitter as An, KWH_PER_WATT_MS as At, AGGREGATE_REDUCERS as B, pickVideoEncoder as Bn, createStatefulExpressionMemory as Bt, CompositionSeriesSourceSchema as C, FFMPEG_PATH_ENV as Cn, planStatisticTier as Ct, MAX_COMPOSITION_FIELDS_PER_FEATURE as D, getFfmpegArtifact as Dn, STATISTIC_STATS as Dt, MAX_COMPOSITION_FEATURES as E, FFMPEG_RELEASE as En, SERIES_KINDS as Et, compositionSourceKey as F, buildInputArgs as Fn, applianceDeviceType as Ft, GROUP_TEMPLATE_IDS as G, createExpressionScope as Gt, AggregateReducerSchema as H, evaluateStatefulExpressionCall as Ht, featureFieldEntries as I, buildVideoArgs as In, isApplianceKind as It, HelperMemberSchema as J, compileExpressionSafe as Jt, GroupHelperSpecSchema as K, evaluateAst as Kt, featureSources as L, invocationFromEncodeProfile as Ln, sourcePickForAppliance as Lt, compositionItemFieldPath as M, audioPlanFromEncodeProfile as Mn, APPLIANCE_DEFAULTS as Mt, compositionReadKey as N, buildAudioArgs as Nn, APPLIANCE_KINDS as Nt, MAX_COMPOSITION_ITEMS as O, getFfmpegDownloadUrl as On, evaluateStatistic as Ot, compositionSliceKey as P, buildFfmpegArgs as Pn, APPLIANCE_TEMPLATE_ID as Pt, MAX_HELPER_MEMBERS as Q, EXPRESSION_IDENTIFIER_RE as Qt, fieldReads as R, isSoftwareDecode as Rn, EXPRESSION_INJECTED_NOW as Rt, CompositionSchema as S, sliceChangedAt as Sn, planResetTier as St, MAX_COMPOSITION_CODE_LENGTH as T, ffmpegBinaryName as Tn, statisticCadenceMs as Tt, ApplianceHelperSpecSchema as U, toExpressionValue as Ut, ActiveCriterionSchema as V, resolveStreamMaps as Vn, evaluateExpressionSource as Vt, BINARY_AGGREGATES as W, validateExpressionSource as Wt, INTEGRAL_OUTPUTS as X, tokenize as Xt, HelperSpecSchema as Y, parseExpression as Yt, IntegralHelperSpecSchema as Z, EXPRESSION_COMPILE_CACHE_CAPACITY as Zt, CompositionFromSourceSchema as _, SOURCE_DEVICE_TYPES as _n, integralCadenceMs as _t, CUSTOMIZATION_BLOCK_NAME_PREFIX as a, EXPRESSION_BUILTINS as an, DAY_MS as at, CompositionNewTargetSchema as b, isSourceCap as bn, openReset as bt, CompositionCodeSourceSchema as c, evaluateCount as cn, HISTORY_SLOW_MS as ct, CompositionExpressionSourceSchema as d, ExpressionEvalError as dn, MINUTE_MS as dt, MAX_EXPRESSION_BINDINGS as en, StatisticHelperSpecSchema as et, CompositionFeatureSchema as f, ExpressionParseError as fn, MIN_CUSTOM_MINUTES as ft, CompositionForwardCommandSchema as g, SOURCE_CAP_CHANGED_AT_FIELD as gn, StatisticWindowSchema as gt, CompositionFieldsFeatureSchema as h, SOURCE_CAP_ACTIVE_FIELD as hn, RollingWindowSchema as ht, COMPOSITION_ITEM_KEY_RE as i, RESERVED_BINDING_NAMES as in, CalendarWindowSchema as it, compositionFeatureEnabled as j, AUDIO_PRESETS as jn, wattMillisecondsToKwh as jt, composedDeviceRef as k, canonicalHash as kn, integrateReading as kt, CompositionCommandTargetSchema as l, evaluateRose as ln, HISTORY_TIERS as lt, CompositionFieldSourceSchema as m, SOURCE_CAPS as mn, ROLLING_SPANS as mt, COMPOSER_ADDON_ID as n, MAX_EXPRESSION_EVAL_STEPS as nn, CompositionSourceRefSchema as nt, CompositionAggregateSourceSchema as o, EXPRESSION_BUILTIN_NAMES as on, DEFAULT_HISTORY_RETENTION as ot, CompositionFieldReadSchema as p, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as pn, RESET_PERIODS as pt, GroupTemplateIdSchema as q, compileExpression as qt, COMPOSITION_ITEM_ARRAY_PATH as r, MAX_EXPRESSION_SOURCE_LENGTH as rn, CALENDAR_PERIODS as rt, CompositionBindingSchema as s, disarmRoseMemory as sn, HISTORY_FAST_MS as st, COMPOSED_DEVICE_STABLE_ID_PREFIX as t, MAX_EXPRESSION_CALL_ARGS as tn, helperMembers as tt, CompositionExistingTargetSchema as u, isStatefulBuiltin as un, HOUR_MS as ut, CompositionItemEntrySchema as v, evaluateSensorEdge as vn, maxDurationMs as vt, CompositionTargetSchema as w, chooseFfmpegBinary as wn, rollingDurationMs as wt, CompositionPassthroughFeatureSchema as x, sliceActiveValue as xn, openStatistic as xt, CompositionLiteralBindingSchema as y, evaluateSensorLevelEdge as yn, nextLocalMidnight as yt, ACTIVE_CRITERIA as z, logBannerArgs as zn, cloneStatefulExpressionMemory as zt };

package/dist/device/cap-vocabulary/entries/sensors.d.ts

@@ -1,5 +1,5 @@
 import type { CapVocabularySlice } from '../types.js';
-type SensorCap = 'air-quality-sensor' | 'ambient-light-sensor' | 'binary' | 'carbon-monoxide' | 'connectivity' | 'contact' | 'enum-sensor' | 'flood' | 'gas' | 'group-commands' | 'group-status' | 'humidity-sensor' | 'motion' | 'numeric-sensor' | 'power-meter' | 'presence' | 'pressure-sensor' | 'smoke' | 'tamper' | 'temperature-sensor' | 'vibration' | 'weather' | 'battery' | 'network-link' | 'device-status' | 'doorbell' | 'event-emitter';
+type SensorCap = 'air-quality-sensor' | 'ambient-light-sensor' | 'binary' | 'carbon-monoxide' | 'connectivity' | 'contact' | 'enum-sensor' | 'flood' | 'gas' | 'group-commands' | 'group-status' | 'humidity-sensor' | 'meter' | 'motion' | 'numeric-sensor' | 'power-meter' | 'presence' | 'pressure-sensor' | 'smoke' | 'tamper' | 'temperature-sensor' | 'vibration' | 'weather' | 'battery' | 'network-link' | 'device-status' | 'doorbell' | 'event-emitter';
 /** The sensor family of the vocabulary. */
 export declare const SENSOR_CAP_VOCABULARY: CapVocabularySlice<SensorCap>;
 export {};

package/dist/generated/addon-api.d.ts

@@ -4940,6 +4940,20 @@ export type AppRouter = TrpcCoreRouter<{
             meta: object;
         }>;
     }>>;
+    meter: TRPCBuiltRouter<{
+        ctx: TrpcContext;
+        meta: object;
+        errorShape: AugmentedErrorShape;
+        transformer: true;
+    }, TRPCDecorateCreateRouterOptions<{
+        getStatus: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof DEVICE_STATUS_METHOD.getStatus.input>;
+            output: z.infer<typeof DEVICE_STATUS_METHOD.getStatus.output>;
+            meta: object;
+        }>;
+    }>>;
     metricsProvider: TRPCBuiltRouter<{
         ctx: TrpcContext;
         meta: object;