@hot-updater/server 1.0.0-rc.1 → 1.0.0-rc.16

package/dist/plugins/insights/reads.mjs

@@ -0,0 +1,466 @@
+import "../../insights/provider.mjs";
+import { DAILY_EVENTS, DAY_MS, HOUR_MS } from "./schema.mjs";
+import { PAIR_FIELD, bundlePairKey, insightsIdentity } from "./recordEvent.mjs";
+import { DatabasePluginInputError } from "@hot-updater/plugin-core";
+import { countInsightsDistinct, mergeInsightsDistinct } from "@hot-updater/plugin-core/internal";
+//#region src/plugins/insights/reads.ts
+const PAGE = 500;
+const hourFloor = (ms) => ms - ms % HOUR_MS;
+const hourCeil = (ms) => hourFloor(ms + HOUR_MS - 1);
+const dayFloor = (ms) => ms - ms % DAY_MS;
+const dayCeil = (ms) => dayFloor(ms + DAY_MS - 1);
+/** Every page of one read, in order. */
+const drain = async (read) => {
+	const rows = [];
+	let cursor;
+	do {
+		const page = await read(cursor === void 0 ? {} : { cursor });
+		rows.push(...page.rows);
+		cursor = page.next;
+	} while (cursor !== void 0);
+	return rows;
+};
+const EVENT_FIELDS = [
+	"id",
+	"type",
+	"install_id",
+	"user_id",
+	"from_release_id",
+	"from_bundle_id",
+	"to_release_id",
+	"to_bundle_id",
+	"platform",
+	"app_version",
+	"channel",
+	"metadata",
+	"received_at_ms"
+];
+/** A stored event or head, as the event row it holds. */
+const toEvent = (row) => Object.fromEntries(EVENT_FIELDS.map((field) => [field, row[field]]));
+const bundleRef = (filter) => filter.type === "RECOVERED" ? `from:${filter.fromBundleId}` : `to:${filter.toBundleId}`;
+const scopeOf = (filter) => ({
+	platform: filter.platform,
+	channel: filter.channel,
+	type: filter.type,
+	bundle_ref: bundleRef(filter)
+});
+/** One UTC day of a global or bundle list, newest first. */
+const eventsOfDay = (db, filter, day, range, limit) => filter.kind === "all" ? db.findMany("bundle_events", {
+	index: "byDay",
+	where: { day },
+	range,
+	order: "desc",
+	limit
+}) : db.findMany("bundle_events", {
+	index: "byBundle",
+	where: {
+		...scopeOf(filter),
+		day
+	},
+	range,
+	order: "desc",
+	limit
+});
+/**
+* The newest UTC day before `day`, and not before `since`'s, that holds an
+* event the list matches, from one outcome row: the global list's per-day
+* count, or the bundle filter's own hourly one.
+*/
+const newestDayBelow = async (db, filter, day, since) => {
+	const counted = filter.kind === "all" ? {
+		where: DAILY_EVENTS,
+		from: dayFloor(since)
+	} : {
+		where: scopeOf(filter),
+		from: hourFloor(since)
+	};
+	const [newest] = (await db.findAggregates("insights_outcomes", {
+		index: "byRef",
+		where: counted.where,
+		range: {
+			gte: counted.from,
+			lt: day
+		},
+		order: "desc",
+		limit: 1
+	})).rows;
+	return newest === void 0 ? void 0 : dayFloor(newest.bucket_start_ms);
+};
+/**
+* Newest first over [since, before), after the cursor. The global and bundle
+* lists cover at most 90 × 24 hours, however many UTC days that touches, and
+* reject a longer range instead of cutting it short. They read one query per
+* UTC day that holds a matching event: a day that holds none is read once,
+* then one outcome row names the newest day below it that does, so a gap of
+* any length costs two reads.
+*/
+const listEvents = async (db, input) => {
+	const since = input.sinceMs ?? 0;
+	const range = {
+		gte: since,
+		lt: input.after === void 0 ? input.beforeReceivedAtMs : [input.after.receivedAtMs, input.after.id]
+	};
+	const { filter, limit } = input;
+	if (filter.kind === "installationMovement") return (await db.findMany("bundle_events", {
+		index: "movementsByInstall",
+		where: { movement_install_id: filter.installId },
+		range,
+		order: "desc",
+		limit
+	})).rows.map(toEvent);
+	if (input.beforeReceivedAtMs - since > 7776e6) throw new DatabasePluginInputError("invalid-query");
+	const rows = [];
+	const bottom = dayFloor(since);
+	let day = dayFloor(input.after?.receivedAtMs ?? input.beforeReceivedAtMs - 1);
+	while (day !== void 0 && day >= bottom && rows.length < limit) {
+		const page = await eventsOfDay(db, filter, day, range, limit - rows.length);
+		rows.push(...page.rows.map(toEvent));
+		day = page.rows.length > 0 ? day - DAY_MS : day > bottom ? await newestDayBelow(db, filter, day, since) : void 0;
+	}
+	return rows;
+};
+/** One point read for an installation; a user's installations in binary install id order. */
+const findLatestEvents = async (db, input) => {
+	if ("installId" in input) {
+		const head = await db.findOne("bundle_event_heads", { install_id: input.installId });
+		return head === null ? [] : [toEvent(head)];
+	}
+	return (await db.findMany("bundle_event_heads", {
+		index: "byUser",
+		where: { user_id: input.userId },
+		...input.afterInstallId === void 0 ? {} : { range: { gt: input.afterInstallId } },
+		order: "asc",
+		limit: input.limit
+	})).rows.map(toEvent);
+};
+/** Raw events of one bundle filter over [from, to), which spans at most two partial hours. */
+const countRaw = async (db, filter, from, to) => {
+	let total = 0;
+	for (let day = dayFloor(from); from < to && day < to; day += DAY_MS) {
+		const rows = await drain((page) => db.findMany("bundle_events", {
+			index: "byBundle",
+			where: {
+				...scopeOf(filter),
+				day
+			},
+			range: {
+				gte: from,
+				lt: to
+			},
+			limit: PAGE,
+			...page
+		}));
+		total += rows.length;
+	}
+	return total;
+};
+/** Whole hours from outcome counters; the partial hours at either edge from raw events. */
+const countEvents = async (db, input) => {
+	const { filter, sinceMs, beforeReceivedAtMs } = input;
+	const start = hourCeil(sinceMs);
+	const end = hourFloor(beforeReceivedAtMs);
+	if (start >= end) return countRaw(db, filter, sinceMs, beforeReceivedAtMs);
+	const hours = await drain((page) => db.findAggregates("insights_outcomes", {
+		index: "byRef",
+		where: scopeOf(filter),
+		range: {
+			gte: start,
+			lt: end
+		},
+		limit: PAGE,
+		...page
+	}));
+	return await countRaw(db, filter, sinceMs, start) + hours.reduce((sum, row) => sum + row.events, 0) + await countRaw(db, filter, end, beforeReceivedAtMs);
+};
+/** A bundle filter's distinct (field, value, type) predicates. */
+const latestPredicates = (bundle) => {
+	if (bundle === void 0) return void 0;
+	return [...new Map(bundle.flatMap(({ field, value, types }) => types.map((type) => [JSON.stringify([
+		field,
+		value,
+		type
+	]), {
+		field,
+		value,
+		type
+	}]))).values()];
+};
+/** Heads whose latest event falls in [sinceMs, end), a partial hour: those events' installs, then their heads. */
+const countPartialHeads = async (db, input, predicates, end) => {
+	const events = await drain((page) => db.findMany("bundle_events", {
+		index: "recent",
+		where: {
+			channel: input.channel,
+			platform: input.platform,
+			day: dayFloor(input.sinceMs)
+		},
+		range: {
+			gte: input.sinceMs,
+			lt: end
+		},
+		limit: PAGE,
+		...page
+	}));
+	const ids = new Set(events.map(({ id }) => id));
+	return (await Promise.all([...new Set(events.map(({ install_id }) => install_id))].map((install) => db.findOne("bundle_event_heads", { install_id: install })))).filter((head) => head !== null && ids.has(head.id) && (predicates === void 0 || predicates.some(({ field, value, type }) => head[field] === value && head.type === type))).length;
+};
+/** Latest events at or after `sinceMs`: whole hours from gauges, the first partial hour from heads. */
+const countLatestEvents = async (db, input) => {
+	const { platform, channel, sinceMs } = input;
+	const start = hourCeil(sinceMs);
+	const predicates = latestPredicates(input.bundle);
+	let total = 0;
+	if (predicates === void 0) {
+		const rows = await drain((page) => db.findAggregates("insights_distribution", {
+			index: "byScope",
+			where: {
+				channel,
+				platform
+			},
+			range: { gte: start },
+			limit: PAGE,
+			...page
+		}));
+		total += rows.reduce((sum, row) => sum + row.latest_installations, 0);
+	} else {
+		const gauge = async (bundleField, bundleId, type) => {
+			return (await drain((page) => db.findAggregates("insights_latest_by_bundle", {
+				index: "byBundle",
+				where: {
+					platform,
+					channel,
+					bundle_field: bundleField,
+					bundle_id: bundleId,
+					type
+				},
+				range: { gte: start },
+				limit: PAGE,
+				...page
+			}))).reduce((sum, row) => sum + row.installations, 0);
+		};
+		for (const { field, value, type } of predicates) total += await gauge(field, value, type);
+		for (const from of predicates) {
+			if (from.field !== "from_bundle_id") continue;
+			for (const to of predicates) {
+				if (to.field !== "to_bundle_id" || to.type !== from.type) continue;
+				total -= await gauge(PAIR_FIELD, bundlePairKey(from.value, to.value), from.type);
+			}
+		}
+	}
+	return sinceMs < start ? total + await countPartialHeads(db, input, predicates, start) : total;
+};
+/** Periods covering [start, end): whole UTC days when `days` and the window is over 48 hours, hours elsewhere. */
+const periodsOf = (range, days) => {
+	const { start, end } = range;
+	if (!days || end - start <= 1728e5) return [{
+		periodKind: "hour",
+		start,
+		end
+	}];
+	const first = Math.min(end, dayCeil(start));
+	const last = Math.max(first, dayFloor(end));
+	return [
+		{
+			periodKind: "hour",
+			start,
+			end: first
+		},
+		{
+			periodKind: "day",
+			start: first,
+			end: last
+		},
+		{
+			periodKind: "hour",
+			start: last,
+			end
+		}
+	].filter((period) => period.start < period.end);
+};
+/** Every overview or sketch row of one identity over [start, end), mixing day and hour periods. */
+const windowRows = async (db, model, parts, range, days) => {
+	const rows = [];
+	for (const period of periodsOf(range, days)) {
+		const identity = insightsIdentity({
+			...parts,
+			periodKind: period.periodKind
+		});
+		rows.push(...await drain((page) => db.findAggregates(model, {
+			index: "window",
+			where: { identity },
+			range: {
+				gte: period.start,
+				lt: period.end
+			},
+			limit: PAGE,
+			...page
+		})));
+	}
+	return rows;
+};
+const counterRows = (...args) => windowRows(args[0], "insights_overview", args[1], args[2], args[3]);
+const sketchRows = (...args) => windowRows(args[0], "insights_sketches", args[1], args[2], args[3]);
+const releaseParts = (release) => ({
+	scopeKind: "release",
+	releaseKind: "specific",
+	releaseId: release.releaseId,
+	channel: release.channel,
+	platform: release.platform,
+	appVersionKind: "all",
+	appVersion: ""
+});
+/** A release's lifetime counters: one logical row at bucket 0. */
+const lifetimeMetrics = async (db, release) => {
+	const identity = insightsIdentity({
+		...releaseParts(release),
+		periodKind: "lifetime"
+	});
+	const [lifetime] = (await db.findAggregates("insights_overview", {
+		index: "window",
+		where: { identity },
+		range: {
+			gte: 0,
+			lte: 0
+		},
+		limit: PAGE
+	})).rows;
+	return {
+		downloads: lifetime?.downloads ?? 0,
+		launches: lifetime?.launches ?? 0,
+		failedLaunches: lifetime?.failed_launches ?? 0
+	};
+};
+/** Counters, unique users, and a per-UTC-day series over a window. */
+const rangedMetrics = async (db, parts, range, days) => {
+	const [counters, sketches] = await Promise.all([counterRows(db, parts, range, days), sketchRows(db, parts, range, days)]);
+	const series = /* @__PURE__ */ new Map();
+	for (const row of counters) {
+		const day = dayFloor(row.bucket_start_ms);
+		const point = series.get(day) ?? {
+			launches: 0,
+			failedLaunches: 0
+		};
+		point.launches += row.launches;
+		point.failedLaunches += row.failed_launches;
+		series.set(day, point);
+	}
+	const total = (field) => counters.reduce((sum, row) => sum + row[field], 0);
+	return {
+		downloads: total("downloads"),
+		launches: total("launches"),
+		failedLaunches: total("failed_launches"),
+		uniqueUsers: countInsightsDistinct(mergeInsightsDistinct(sketches.map((row) => row.launch_users))),
+		series: [...series].sort(([left], [right]) => left - right).map(([startMs, point]) => ({
+			startMs,
+			...point
+		}))
+	};
+};
+const getReleaseActivity = async (db, input, now) => {
+	return {
+		coverage: {
+			kind: "complete",
+			sinceMs: 0
+		},
+		data: input.scope !== void 0 ? [{
+			scope: input.scope,
+			metrics: await rangedMetrics(db, {
+				scopeKind: "channel",
+				releaseKind: "all",
+				releaseId: "",
+				channel: input.scope.channel,
+				platform: input.scope.platform,
+				appVersionKind: "all",
+				appVersion: ""
+			}, input.timeRange, true)
+		}] : await Promise.all(input.releases.map(async (release) => ({
+			release,
+			metrics: input.timeRange === void 0 ? await lifetimeMetrics(db, release) : await rangedMetrics(db, releaseParts(release), input.timeRange, false)
+		}))),
+		measuredAtMs: now()
+	};
+};
+const byInstallations = (values) => [...values].map(([name, installations]) => ({
+	name,
+	installations
+})).sort((left, right) => right.installations - left.installations || left.name.localeCompare(right.name, "en", { numeric: true }));
+const getAppUsage = async (db, input, now) => {
+	const { timeRange, intervalMs } = input;
+	const usage = await sketchRows(db, {
+		scopeKind: "usage",
+		releaseKind: "all",
+		releaseId: "",
+		channel: input.channel,
+		platform: input.platform,
+		appVersionKind: input.appVersion === void 0 ? "all" : "specific",
+		appVersion: input.appVersion ?? ""
+	}, timeRange, intervalMs % 864e5 === 0 && timeRange.start % 864e5 === 0);
+	const distribution = [];
+	for (const platform of input.platform === "all" ? ["ios", "android"] : [input.platform]) distribution.push(...await drain((page) => input.appVersion === void 0 ? db.findAggregates("insights_distribution", {
+		index: "byScope",
+		where: {
+			channel: input.channel,
+			platform
+		},
+		range: {
+			gte: timeRange.start,
+			lt: timeRange.end
+		},
+		limit: PAGE,
+		...page
+	}) : db.findAggregates("insights_distribution", {
+		index: "byVersion",
+		where: {
+			channel: input.channel,
+			platform,
+			app_version: input.appVersion
+		},
+		range: {
+			gte: timeRange.start,
+			lt: timeRange.end
+		},
+		limit: PAGE,
+		...page
+	})));
+	const points = [];
+	for (let start = timeRange.start; start < timeRange.end; start += intervalMs) points.push({
+		startMs: start,
+		installations: countInsightsDistinct(mergeInsightsDistinct(usage.filter((row) => row.bucket_start_ms >= start && row.bucket_start_ms < start + intervalMs).map((row) => row.activity_users)))
+	});
+	const versions = /* @__PURE__ */ new Map();
+	const platforms = /* @__PURE__ */ new Map();
+	const bundles = /* @__PURE__ */ new Map();
+	for (const row of distribution) {
+		const count = row.latest_installations;
+		versions.set(row.app_version, (versions.get(row.app_version) ?? 0) + count);
+		platforms.set(row.platform, (platforms.get(row.platform) ?? 0) + count);
+		const releaseId = row.release_id === "" ? null : row.release_id;
+		const key = JSON.stringify([
+			row.app_version,
+			row.platform,
+			releaseId
+		]);
+		bundles.set(key, {
+			appVersion: row.app_version,
+			platform: row.platform,
+			releaseId,
+			installations: (bundles.get(key)?.installations ?? 0) + count
+		});
+	}
+	const sortedVersions = byInstallations(versions);
+	return {
+		coverage: {
+			kind: "complete",
+			sinceMs: 0
+		},
+		activeInstallations: countInsightsDistinct(mergeInsightsDistinct(usage.map((row) => row.activity_users))),
+		points,
+		appVersions: sortedVersions.map(({ name }) => name),
+		versions: sortedVersions,
+		platforms: byInstallations(platforms),
+		bundleDistribution: [...bundles.values()],
+		measuredAtMs: now()
+	};
+};
+//#endregion
+export { countEvents, countLatestEvents, findLatestEvents, getAppUsage, getReleaseActivity, listEvents };

package/dist/plugins/insights/recordEvent.cjs

@@ -0,0 +1,135 @@
+const require_schema = require("./schema.cjs");
+let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
+//#region src/plugins/insights/recordEvent.ts
+const hourOf = (ms) => ms - ms % require_schema.HOUR_MS;
+const dayOf = (ms) => ms - ms % require_schema.DAY_MS;
+/** The `identity` of an overview or sketch row: its scope and period, hashed. */
+const insightsIdentity = (identity) => (0, _hot_updater_plugin_core_internal.insightsOverviewId)({
+	...identity,
+	periodKind: identity.periodKind,
+	bucketStartMs: 0
+});
+/** The head columns besides its key: the whole event and its current release. */
+const headFields = (event) => {
+	const { install_id: _, ...fields } = event;
+	return {
+		...fields,
+		current_release_id: (0, _hot_updater_plugin_core_internal.currentInsightsReleaseId)(event)
+	};
+};
+/**
+* The `insights_latest_by_bundle` field of a head's (from, to) pair. A head
+* matches a `from` and a `to` predicate of one type at once only through its
+* pair, so this gauge is what a count subtracts to count it once.
+*/
+const PAIR_FIELD = "from_to";
+/** The pair gauge's `bundle_id`: a hash of the two bundle ids, which fit no single 36-character column. */
+const bundlePairKey = (from, to) => (0, _hot_updater_plugin_core_internal.insightsKey)(`${from.length}:${from}${to.length}:${to}`);
+/** Moves a head's gauges: the distribution row, one row per bundle it references, and its pair. */
+const countHead = (tx, head, delta) => {
+	const bucket = hourOf(head.received_at_ms);
+	const shardBy = head.install_id;
+	tx.aggregate("insights_distribution", {
+		channel: head.channel,
+		platform: head.platform,
+		app_version: head.app_version,
+		release_id: head.current_release_id ?? "",
+		bucket_start_ms: bucket
+	}, { latest_installations: delta }, { shardBy });
+	for (const field of ["from_bundle_id", "to_bundle_id"]) {
+		const bundleId = head[field];
+		if (bundleId === null) continue;
+		tx.aggregate("insights_latest_by_bundle", {
+			platform: head.platform,
+			channel: head.channel,
+			bundle_field: field,
+			bundle_id: bundleId,
+			type: head.type,
+			bucket_start_ms: bucket
+		}, { installations: delta }, { shardBy });
+	}
+	if (head.from_bundle_id !== null) tx.aggregate("insights_latest_by_bundle", {
+		platform: head.platform,
+		channel: head.channel,
+		bundle_field: PAIR_FIELD,
+		bundle_id: bundlePairKey(head.from_bundle_id, head.to_bundle_id),
+		type: head.type,
+		bucket_start_ms: bucket
+	}, { installations: delta }, { shardBy });
+};
+/**
+* Counters and sketches for one event: release, channel, and usage rows, with
+* day rollups for channel and usage; and its outcome rows, its bundle
+* filter's hour and every event's day.
+*/
+const countEvent = (tx, event) => {
+	const shardBy = event.install_id;
+	for (const delta of (0, _hot_updater_plugin_core_internal.insightsOverviewDeltas)(event)) {
+		const { bucketStartMs, ...parts } = delta.identity;
+		const periods = parts.scopeKind === "channel" || parts.scopeKind === "usage" ? [["hour", bucketStartMs], ["day", dayOf(event.received_at_ms)]] : [[parts.periodKind, bucketStartMs]];
+		for (const [periodKind, bucket] of periods) {
+			const key = {
+				identity: insightsIdentity({
+					...parts,
+					periodKind
+				}),
+				bucket_start_ms: bucket
+			};
+			const counters = Object.fromEntries([
+				["downloads", delta.downloads],
+				["launches", delta.launches],
+				["failed_launches", delta.failedLaunches]
+			].filter(([, value]) => value !== 0));
+			if (Object.keys(counters).length > 0) tx.aggregate("insights_overview", key, counters, { shardBy });
+			const sketches = {
+				...delta.launchIdentity === void 0 ? {} : { launch_users: (0, _hot_updater_plugin_core_internal.addInsightsDistinct)(null, delta.launchIdentity) },
+				...delta.activityIdentity === void 0 ? {} : { activity_users: (0, _hot_updater_plugin_core_internal.addInsightsDistinct)(null, delta.activityIdentity) }
+			};
+			if (Object.keys(sketches).length > 0) tx.aggregate("insights_sketches", key, sketches, { shardBy });
+		}
+	}
+	tx.aggregate("insights_outcomes", {
+		platform: event.platform,
+		channel: event.channel,
+		type: event.type,
+		bundle_ref: event.type === "RECOVERED" ? `from:${event.from_bundle_id}` : `to:${event.to_bundle_id}`,
+		bucket_start_ms: hourOf(event.received_at_ms)
+	}, { events: 1 }, { shardBy });
+	tx.aggregate("insights_outcomes", {
+		...require_schema.DAILY_EVENTS,
+		bucket_start_ms: dayOf(event.received_at_ms)
+	}, { events: 1 }, { shardBy });
+};
+const isNewer = (event, head) => event.received_at_ms !== head.received_at_ms ? event.received_at_ms > head.received_at_ms : (0, _hot_updater_plugin_core_internal.compareUtf8)(event.id, head.id) > 0;
+/**
+* Records one event in one transaction: one batch read of the event and its
+* installation's head, one of the gauge and sketch rows it changes, then one
+* write. A repeated id changes nothing, whichever installation sends it; an
+* older event still counts in its own hour but never replaces the head.
+*/
+const recordEvent = (db, event) => {
+	(0, _hot_updater_plugin_core_internal.assertBundleEventRow)(event);
+	return db.transaction(async (tx) => {
+		const [existing, previous] = await Promise.all([tx.findOne("bundle_events", { id: event.id }), tx.findOne("bundle_event_heads", { install_id: event.install_id })]);
+		if (existing !== null) return;
+		tx.create("bundle_events", event);
+		countEvent(tx, event);
+		const fields = headFields(event);
+		const head = {
+			...fields,
+			install_id: event.install_id
+		};
+		if (previous !== null && !isNewer(head, previous)) return;
+		if (previous === null) tx.create("bundle_event_heads", head);
+		else {
+			countHead(tx, previous, -1);
+			tx.update("bundle_event_heads", previous, fields);
+		}
+		countHead(tx, head, 1);
+	});
+};
+//#endregion
+exports.PAIR_FIELD = PAIR_FIELD;
+exports.bundlePairKey = bundlePairKey;
+exports.insightsIdentity = insightsIdentity;
+exports.recordEvent = recordEvent;

package/dist/plugins/insights/recordEvent.d.cts

@@ -0,0 +1,13 @@
+import "../../database/database.cjs";
+import "./schema.cjs";
+import { BundleEventRow } from "@hot-updater/plugin-core";
+import { InsightsOverviewIdentity } from "@hot-updater/plugin-core/internal";
+//#region src/plugins/insights/recordEvent.d.ts
+/** An overview or sketch row's scope and period; day periods roll up channel and usage rows. */
+type InsightsIdentityParts = Omit<InsightsOverviewIdentity, "bucketStartMs" | "periodKind"> & {
+  readonly periodKind: InsightsOverviewIdentity["periodKind"] | "day";
+};
+/** The `identity` of an overview or sketch row: its scope and period, hashed. */
+declare const insightsIdentity: (identity: InsightsIdentityParts) => string;
+//#endregion
+export { InsightsIdentityParts, insightsIdentity };

package/dist/plugins/insights/recordEvent.d.mts

@@ -0,0 +1,13 @@
+import "../../database/database.mjs";
+import "./schema.mjs";
+import { BundleEventRow } from "@hot-updater/plugin-core";
+import { InsightsOverviewIdentity } from "@hot-updater/plugin-core/internal";
+//#region src/plugins/insights/recordEvent.d.ts
+/** An overview or sketch row's scope and period; day periods roll up channel and usage rows. */
+type InsightsIdentityParts = Omit<InsightsOverviewIdentity, "bucketStartMs" | "periodKind"> & {
+  readonly periodKind: InsightsOverviewIdentity["periodKind"] | "day";
+};
+/** The `identity` of an overview or sketch row: its scope and period, hashed. */
+declare const insightsIdentity: (identity: InsightsIdentityParts) => string;
+//#endregion
+export { InsightsIdentityParts, insightsIdentity };