@camstack/types 1.2.420 → 1.2.422

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

@@ -1,4 +1,4 @@
-import { a as DeviceType, i as DeviceRole } from "./err-msg-BXKzRBwg.mjs";
+import { a as DeviceType, i as DeviceRole } from "./err-msg-DIorGYeC.mjs";
 import { z } from "zod";
 import { createHash } from "node:crypto";
 //#region src/ffmpeg/invocation.ts
@@ -2160,6 +2160,616 @@ function evaluateExpressionSource(expr, bindingValues, now, opts) {
 	}
 }
 //#endregion
+//#region src/composition/helpers/appliance.ts
+/**
+* One power reading becomes a washer, dryer or dishwasher (D944 helper).
+*
+* Standby of the control board is under 5 W; a motor or a heater is far
+* above that, so 5 W is the line. A door lock or a short pump spike is not
+* a cycle, so running starts only after 30 s above the line.
+*
+* A wash, dry or dishwasher pause (soak, heat-wait, heater off between
+* bursts) lasts several minutes. Ending the cycle on the first dip would
+* report "finished" in the middle of the program, so the stop dwell is
+* 10 minutes on every type. The number is stored per type so one machine
+* can move later without moving the others.
+*/
+var APPLIANCE_TEMPLATE_ID = "appliance";
+var APPLIANCE_KINDS = [
+	"washer",
+	"dryer",
+	"dishwasher"
+];
+var START_DWELL_MS = 3e4;
+var STOP_DWELL_MS = 6e5;
+var THRESHOLD_WATTS = 5;
+var APPLIANCE_DEFAULTS = {
+	washer: {
+		thresholdWatts: THRESHOLD_WATTS,
+		startDwellMs: START_DWELL_MS,
+		stopDwellMs: STOP_DWELL_MS
+	},
+	dryer: {
+		thresholdWatts: THRESHOLD_WATTS,
+		startDwellMs: START_DWELL_MS,
+		stopDwellMs: STOP_DWELL_MS
+	},
+	dishwasher: {
+		thresholdWatts: THRESHOLD_WATTS,
+		startDwellMs: START_DWELL_MS,
+		stopDwellMs: STOP_DWELL_MS
+	}
+};
+var DEVICE_TYPE = {
+	washer: DeviceType.Washer,
+	dryer: DeviceType.Dryer,
+	dishwasher: DeviceType.Dishwasher
+};
+function applianceDeviceType(kind) {
+	return DEVICE_TYPE[kind];
+}
+function isApplianceKind(value) {
+	return APPLIANCE_KINDS.some((kind) => kind === value);
+}
+/** The member step: one watts reading, from a sensor or from the plug itself. */
+function sourcePickForAppliance() {
+	return {
+		purpose: "reading",
+		multiple: false,
+		max: 1,
+		deviceTypes: [DeviceType.Sensor, DeviceType.Switch],
+		accept: [{
+			cap: "power-meter",
+			fieldPath: "watts",
+			valueKind: "number"
+		}],
+		history: {
+			required: false,
+			minRetentionMs: null
+		},
+		mustBindCaps: [],
+		exclude: []
+	};
+}
+//#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
@@ -2225,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,
@@ -2237,7 +2844,45 @@ var GroupHelperSpecSchema = z.object({
 	/** Actuator groups only. Readings leave this unset. */
 	active: ActiveCriterionSchema.optional()
 });
-var HelperSpecSchema = z.discriminatedUnion("kind", [GroupHelperSpecSchema]);
+var ApplianceHelperSpecSchema = z.object({
+	kind: z.literal("appliance"),
+	templateId: z.literal(APPLIANCE_TEMPLATE_ID),
+	appliance: z.enum(APPLIANCE_KINDS),
+	thresholdWatts: z.number().positive(),
+	startDwellMs: z.number().int().nonnegative(),
+	stopDwellMs: z.number().int().nonnegative(),
+	member: HelperMemberSchema
+});
+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) {
+	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
 /**
@@ -2347,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({
@@ -2471,6 +3141,7 @@ function fieldReads(source) {
 			fieldPath: binding.fieldPath
 		}] : []);
 		case "aggregate": return source.reads;
+		case "series": return [source.read];
 		case "code": return [];
 	}
 }
@@ -2497,4 +3168,4 @@ function featureSources(feature) {
 	return featureFieldEntries(feature).map((e) => e.source);
 }
 //#endregion
-export { createStatefulExpressionMemory as $, pickVideoEncoder as $t, compositionFeatureEnabled as A, SOURCE_DEVICE_TYPES as At, ActiveCriterionSchema as B, getFfmpegArtifact as Bt, CompositionTargetSchema as C, isStatefulBuiltin as Ct, MAX_COMPOSITION_ITEMS as D, SOURCE_CAPS as Dt, MAX_COMPOSITION_FIELDS_PER_FEATURE as E, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as Et, featureFieldEntries as F, sliceChangedAt as Ft, GroupTemplateIdSchema as G, audioPlanFromEncodeProfile as Gt, BINARY_AGGREGATES as H, canonicalHash as Ht, featureSources as I, FFMPEG_PATH_ENV as It, MAX_HELPER_MEMBERS as J, buildInputArgs as Jt, HelperMemberSchema as K, buildAudioArgs as Kt, fieldReads as L, chooseFfmpegBinary as Lt, compositionReadKey as M, evaluateSensorLevelEdge as Mt, compositionSliceKey as N, isSourceCap as Nt, composedDeviceRef as O, SOURCE_CAP_ACTIVE_FIELD as Ot, compositionSourceKey as P, sliceActiveValue as Pt, cloneStatefulExpressionMemory as Q, logBannerArgs as Qt, ACTIVE_CRITERIA as R, ffmpegBinaryName as Rt, CompositionSchema as S, evaluateRose as St, MAX_COMPOSITION_FEATURES as T, ExpressionParseError as Tt, GROUP_TEMPLATE_IDS as U, Fmp4BoxSplitter as Ut, AggregateReducerSchema as V, getFfmpegDownloadUrl as Vt, GroupHelperSpecSchema as W, AUDIO_PRESETS as Wt, CompositionSourceRefSchema as X, invocationFromEncodeProfile as Xt, NUMERIC_AGGREGATES as Y, buildVideoArgs as Yt, EXPRESSION_INJECTED_NOW as Z, isSoftwareDecode as Zt, CompositionFromSourceSchema as _, RESERVED_BINDING_NAMES as _t, CUSTOMIZATION_BLOCK_NAME_PREFIX as a, evaluateAst as at, CompositionNewTargetSchema as b, disarmRoseMemory as bt, CompositionCodeSourceSchema as c, parseExpression as ct, CompositionExpressionSourceSchema as d, EXPRESSION_IDENTIFIER_RE as dt, resolveStreamMaps as en, evaluateExpressionSource as et, CompositionFeatureSchema as f, MAX_EXPRESSION_AST_NODES as ft, CompositionForwardCommandSchema as g, MAX_EXPRESSION_SOURCE_LENGTH as gt, CompositionFieldsFeatureSchema as h, MAX_EXPRESSION_EVAL_STEPS as ht, COMPOSITION_ITEM_KEY_RE as i, createExpressionScope as it, compositionItemFieldPath as j, evaluateSensorEdge as jt, composedDeviceStableId as k, SOURCE_CAP_CHANGED_AT_FIELD as kt, CompositionCommandTargetSchema as l, tokenize as lt, CompositionFieldSourceSchema as m, MAX_EXPRESSION_CALL_ARGS as mt, COMPOSER_ADDON_ID as n, toExpressionValue as nt, CompositionAggregateSourceSchema as o, compileExpression as ot, CompositionFieldReadSchema as p, MAX_EXPRESSION_BINDINGS as pt, HelperSpecSchema as q, buildFfmpegArgs as qt, COMPOSITION_ITEM_ARRAY_PATH as r, validateExpressionSource as rt, CompositionBindingSchema as s, compileExpressionSafe as st, COMPOSED_DEVICE_STABLE_ID_PREFIX as t, evaluateStatefulExpressionCall as tt, CompositionExistingTargetSchema as u, EXPRESSION_COMPILE_CACHE_CAPACITY as ut, CompositionItemEntrySchema as v, EXPRESSION_BUILTINS as vt, MAX_COMPOSITION_CODE_LENGTH as w, ExpressionEvalError as wt, CompositionPassthroughFeatureSchema as x, evaluateCount as xt, CompositionLiteralBindingSchema as y, EXPRESSION_BUILTIN_NAMES as yt, AGGREGATE_REDUCERS as z, FFMPEG_RELEASE 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 };