@happyvertical/smrt-reports 0.57.6 → 0.57.8

package/dist/chunks/runtime-time-D7JZ1e4J.js

@@ -0,0 +1,1052 @@
+import { SmrtError } from "@happyvertical/smrt-core/smrt-error";
+//#region src/runtime-spec.ts
+var RUNTIME_REPORT_SPEC_VERSION = 1;
+var RUNTIME_REPORT_LIMITS = Object.freeze({
+	maxTitleLength: 120,
+	maxDescriptionLength: 500,
+	maxDimensions: 4,
+	maxMeasures: 6,
+	maxFilters: 12,
+	maxHaving: 4,
+	maxSort: 3,
+	maxInValues: 100,
+	maxStringValueLength: 256,
+	defaultRowLimit: 100,
+	maxRowLimit: 1e3,
+	maxAliasLength: 40,
+	maxFieldNameLength: 64,
+	maxSourceIdLength: 120
+});
+var RUNTIME_REPORT_BUCKETS = [
+	"minute",
+	"hour",
+	"day",
+	"week",
+	"month",
+	"quarter",
+	"year"
+];
+var RUNTIME_REPORT_MEASURE_FNS = [
+	"count",
+	"countDistinct",
+	"sum",
+	"avg",
+	"min",
+	"max"
+];
+var RUNTIME_REPORT_FILTER_OPS = [
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in",
+	"notIn",
+	"contains",
+	"isNull",
+	"isNotNull"
+];
+var RUNTIME_REPORT_HAVING_OPS = [
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte"
+];
+var RUNTIME_REPORT_CHART_TYPES = [
+	"table",
+	"bar",
+	"line",
+	"pie",
+	"stat"
+];
+var RuntimeReportError = class extends SmrtError {
+	code;
+	path;
+	/**
+	* HTTP-style status so tool loops classify it: 4xx input problems are
+	* repairable by the caller, `tenant_required` and `confirmation_required`
+	* are denials, results that cannot be represented are server errors.
+	*/
+	status;
+	constructor(code, path, message) {
+		super(path ? `${path}: ${message}` : message, code, "validation");
+		this.name = "RuntimeReportError";
+		this.code = code;
+		this.path = path;
+		this.status = code === "tenant_required" || code === "confirmation_required" ? 403 : code === "invalid_result" ? 500 : 422;
+	}
+};
+function fail(path, message) {
+	throw new RuntimeReportError("invalid_spec", path, message);
+}
+var RESERVED_ALIASES = /* @__PURE__ */ new Set([
+	"all",
+	"and",
+	"as",
+	"asc",
+	"between",
+	"by",
+	"case",
+	"cast",
+	"check",
+	"column",
+	"constraint",
+	"create",
+	"cross",
+	"default",
+	"delete",
+	"desc",
+	"distinct",
+	"drop",
+	"else",
+	"end",
+	"except",
+	"exists",
+	"false",
+	"for",
+	"foreign",
+	"from",
+	"full",
+	"group",
+	"having",
+	"in",
+	"inner",
+	"insert",
+	"intersect",
+	"into",
+	"is",
+	"join",
+	"left",
+	"like",
+	"limit",
+	"natural",
+	"not",
+	"null",
+	"offset",
+	"on",
+	"or",
+	"order",
+	"outer",
+	"primary",
+	"references",
+	"right",
+	"select",
+	"set",
+	"table",
+	"then",
+	"to",
+	"true",
+	"union",
+	"unique",
+	"update",
+	"user",
+	"using",
+	"values",
+	"when",
+	"where",
+	"with"
+]);
+var ALIAS_PATTERN = /^[a-z][a-z0-9_]*$/;
+var FIELD_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+var SOURCE_PATTERN = /^[A-Za-z@][A-Za-z0-9_@./:-]*$/;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function strictObject(value, path, allowed) {
+	if (!isRecord(value)) fail(path, "must be an object");
+	for (const key of Object.keys(value)) if (!allowed.includes(key)) fail(`${path}.${key}`, "is not a known key");
+	return value;
+}
+function strictArray(value, path, max, min = 0) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) fail(path, "must be an array");
+	if (value.length > max) fail(path, `must have at most ${max} entries`);
+	if (value.length < min) fail(path, `must have at least ${min} entries`);
+	return value;
+}
+function text(value, path, max, options = {}) {
+	if (typeof value !== "string") {
+		if (options.optional && value === void 0) return "";
+		fail(path, "must be a string");
+	}
+	const trimmed = value.trim();
+	if (trimmed.length === 0 && !options.optional) fail(path, "must not be empty");
+	if (trimmed.length > max) fail(path, `must be at most ${max} characters`);
+	if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(trimmed)) fail(path, "must not contain control characters");
+	return trimmed;
+}
+function oneOf(value, path, allowed) {
+	if (typeof value !== "string" || !allowed.includes(value)) fail(path, `must be one of: ${allowed.join(", ")}`);
+	return value;
+}
+function fieldName(value, path) {
+	if (typeof value !== "string") fail(path, "must be a string");
+	if (value.length === 0 || value.length > RUNTIME_REPORT_LIMITS.maxFieldNameLength || !FIELD_PATTERN.test(value)) fail(path, "must be a plain field name (letters, digits, underscore)");
+	return value;
+}
+function alias(value, path) {
+	if (typeof value !== "string") fail(path, "must be a string");
+	if (value.length === 0 || value.length > RUNTIME_REPORT_LIMITS.maxAliasLength || !ALIAS_PATTERN.test(value)) fail(path, `must be a lowercase identifier of at most ${RUNTIME_REPORT_LIMITS.maxAliasLength} characters (a-z, 0-9, underscore)`);
+	if (RESERVED_ALIASES.has(value)) fail(path, `'${value}' is a reserved word`);
+	return value;
+}
+function scalar(value, path) {
+	if (typeof value === "string") {
+		if (value.length > RUNTIME_REPORT_LIMITS.maxStringValueLength) fail(path, `must be at most ${RUNTIME_REPORT_LIMITS.maxStringValueLength} characters`);
+		if (value.includes("\0")) fail(path, "must not contain NUL");
+		return value;
+	}
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) fail(path, "must be a finite number");
+		return value;
+	}
+	if (typeof value === "boolean") return value;
+	return fail(path, "must be a string, number or boolean");
+}
+function snake(name) {
+	return name.replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase();
+}
+function parseDimension(value, path) {
+	const raw = strictObject(value, path, [
+		"field",
+		"as",
+		"bucket"
+	]);
+	const field = fieldName(raw.field, `${path}.field`);
+	const bucket = raw.bucket === void 0 ? void 0 : oneOf(raw.bucket, `${path}.bucket`, RUNTIME_REPORT_BUCKETS);
+	return {
+		field,
+		as: raw.as === void 0 ? alias(bucket ? `${snake(field)}_${bucket}` : snake(field), `${path}.as`) : alias(raw.as, `${path}.as`),
+		...bucket ? { bucket } : {}
+	};
+}
+function parseMeasure(value, path) {
+	const raw = strictObject(value, path, [
+		"fn",
+		"field",
+		"as"
+	]);
+	const fn = oneOf(raw.fn, `${path}.fn`, RUNTIME_REPORT_MEASURE_FNS);
+	const field = raw.field === void 0 ? void 0 : fieldName(raw.field, `${path}.field`);
+	if (!field && fn !== "count") fail(`${path}.field`, `is required for ${fn}`);
+	const as = raw.as === void 0 ? alias(field ? `${snake(fn)}_${snake(field)}` : "row_count", `${path}.as`) : alias(raw.as, `${path}.as`);
+	return {
+		fn,
+		...field ? { field } : {},
+		as
+	};
+}
+function parseFilter(value, path) {
+	const raw = strictObject(value, path, [
+		"field",
+		"op",
+		"value"
+	]);
+	const field = fieldName(raw.field, `${path}.field`);
+	const op = oneOf(raw.op, `${path}.op`, RUNTIME_REPORT_FILTER_OPS);
+	if (op === "isNull" || op === "isNotNull") {
+		if (raw.value !== void 0) fail(`${path}.value`, `must be omitted for ${op}`);
+		return {
+			field,
+			op
+		};
+	}
+	if (raw.value === void 0) fail(`${path}.value`, `is required for ${op}`);
+	if (op === "in" || op === "notIn") return {
+		field,
+		op,
+		value: strictArray(raw.value, `${path}.value`, RUNTIME_REPORT_LIMITS.maxInValues, 1).map((entry, index) => scalar(entry, `${path}.value[${index}]`))
+	};
+	if (Array.isArray(raw.value)) fail(`${path}.value`, `must be a scalar for ${op}`);
+	const parsed = scalar(raw.value, `${path}.value`);
+	if (op === "contains" && typeof parsed !== "string") fail(`${path}.value`, "must be a string for contains");
+	return {
+		field,
+		op,
+		value: parsed
+	};
+}
+function parseHaving(value, path) {
+	const raw = strictObject(value, path, [
+		"measure",
+		"op",
+		"value"
+	]);
+	const measure = alias(raw.measure, `${path}.measure`);
+	const op = oneOf(raw.op, `${path}.op`, RUNTIME_REPORT_HAVING_OPS);
+	if (typeof raw.value !== "number" || !Number.isFinite(raw.value)) fail(`${path}.value`, "must be a finite number");
+	return {
+		measure,
+		op,
+		value: raw.value
+	};
+}
+function parseSort(value, path) {
+	const raw = strictObject(value, path, ["by", "direction"]);
+	return {
+		by: alias(raw.by, `${path}.by`),
+		direction: raw.direction === void 0 ? "asc" : oneOf(raw.direction, `${path}.direction`, ["asc", "desc"])
+	};
+}
+function parseRuntimeReportSpec(input) {
+	let candidate = input;
+	if (typeof input === "string") {
+		if (input.length > 64 * 1024) fail("", "spec JSON is too large");
+		try {
+			candidate = JSON.parse(input);
+		} catch {
+			fail("", "spec is not valid JSON");
+		}
+	}
+	const raw = strictObject(candidate, "spec", [
+		"version",
+		"title",
+		"description",
+		"source",
+		"dimensions",
+		"measures",
+		"filters",
+		"having",
+		"sort",
+		"limit",
+		"chart"
+	]);
+	if (raw.version !== void 0 && raw.version !== 1) fail("spec.version", `unsupported version (expected 1)`);
+	const title = text(raw.title, "spec.title", RUNTIME_REPORT_LIMITS.maxTitleLength);
+	const description = text(raw.description, "spec.description", RUNTIME_REPORT_LIMITS.maxDescriptionLength, { optional: true });
+	if (typeof raw.source !== "string" || raw.source.length === 0 || raw.source.length > RUNTIME_REPORT_LIMITS.maxSourceIdLength || !SOURCE_PATTERN.test(raw.source)) fail("spec.source", "must be a source id");
+	const dimensions = strictArray(raw.dimensions, "spec.dimensions", RUNTIME_REPORT_LIMITS.maxDimensions).map((entry, index) => parseDimension(entry, `spec.dimensions[${index}]`));
+	const measures = strictArray(raw.measures, "spec.measures", RUNTIME_REPORT_LIMITS.maxMeasures, 1).map((entry, index) => parseMeasure(entry, `spec.measures[${index}]`));
+	const filters = strictArray(raw.filters, "spec.filters", RUNTIME_REPORT_LIMITS.maxFilters).map((entry, index) => parseFilter(entry, `spec.filters[${index}]`));
+	const having = strictArray(raw.having, "spec.having", RUNTIME_REPORT_LIMITS.maxHaving).map((entry, index) => parseHaving(entry, `spec.having[${index}]`));
+	const sort = strictArray(raw.sort, "spec.sort", RUNTIME_REPORT_LIMITS.maxSort).map((entry, index) => parseSort(entry, `spec.sort[${index}]`));
+	const dimensionAliases = /* @__PURE__ */ new Set();
+	const measureAliases = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, dimension] of dimensions.entries()) {
+		if (seen.has(dimension.as)) fail(`spec.dimensions[${index}].as`, `duplicate alias '${dimension.as}'`);
+		seen.add(dimension.as);
+		dimensionAliases.add(dimension.as);
+	}
+	for (const [index, measure] of measures.entries()) {
+		if (seen.has(measure.as)) fail(`spec.measures[${index}].as`, `duplicate alias '${measure.as}'`);
+		seen.add(measure.as);
+		measureAliases.add(measure.as);
+	}
+	for (const [index, entry] of having.entries()) if (!measureAliases.has(entry.measure)) fail(`spec.having[${index}].measure`, "must be a declared measure alias");
+	for (const [index, entry] of sort.entries()) if (!seen.has(entry.by)) fail(`spec.sort[${index}].by`, "must be a declared dimension or measure alias");
+	let limit = RUNTIME_REPORT_LIMITS.defaultRowLimit;
+	if (raw.limit !== void 0) {
+		if (typeof raw.limit !== "number" || !Number.isSafeInteger(raw.limit) || raw.limit < 1 || raw.limit > RUNTIME_REPORT_LIMITS.maxRowLimit) fail("spec.limit", `must be an integer between 1 and ${RUNTIME_REPORT_LIMITS.maxRowLimit}`);
+		limit = raw.limit;
+	}
+	let chart = { type: "table" };
+	if (raw.chart !== void 0) {
+		const rawChart = strictObject(raw.chart, "spec.chart", [
+			"type",
+			"x",
+			"y"
+		]);
+		const type = oneOf(rawChart.type, "spec.chart.type", RUNTIME_REPORT_CHART_TYPES);
+		const x = rawChart.x === void 0 ? void 0 : alias(rawChart.x, "spec.chart.x");
+		if (x !== void 0 && !dimensionAliases.has(x)) fail("spec.chart.x", "must be a declared dimension alias");
+		const y = strictArray(rawChart.y, "spec.chart.y", RUNTIME_REPORT_LIMITS.maxMeasures).map((entry, index) => alias(entry, `spec.chart.y[${index}]`));
+		for (const [index, name] of y.entries()) if (!measureAliases.has(name)) fail(`spec.chart.y[${index}]`, "must be a declared measure alias");
+		chart = {
+			type,
+			...x ? { x } : {},
+			...y.length > 0 ? { y } : {}
+		};
+	}
+	return {
+		version: 1,
+		title,
+		...description ? { description } : {},
+		source: raw.source,
+		dimensions,
+		measures,
+		filters,
+		having,
+		sort,
+		limit,
+		chart
+	};
+}
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (isRecord(value)) return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+	return value;
+}
+function serializeRuntimeReportSpec(spec) {
+	return JSON.stringify(canonicalize(spec));
+}
+async function runtimeReportSpecDigest(spec) {
+	const subtle = globalThis.crypto?.subtle;
+	if (!subtle) throw new Error("runtimeReportSpecDigest needs Web Crypto (crypto.subtle), which browsers offer only in a secure context");
+	const bytes = new TextEncoder().encode(serializeRuntimeReportSpec(spec));
+	const digest = new Uint8Array(await subtle.digest("SHA-256", bytes));
+	return Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+//#endregion
+//#region src/runtime-plan.ts
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function humanizeRuntimeReportName(name) {
+	return name.replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/^./, (value) => value.toUpperCase());
+}
+function unknownRuntimeReportField(path, name) {
+	throw new RuntimeReportError("unknown_field", path, `'${name}' is not a field available on this source`);
+}
+function badOperation(path, message) {
+	throw new RuntimeReportError("invalid_operation", path, message);
+}
+function badValue(path, message) {
+	throw new RuntimeReportError("invalid_value", path, message);
+}
+var RUNTIME_REPORT_OPERATORS_BY_TYPE = {
+	string: [
+		"eq",
+		"ne",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"in",
+		"notIn",
+		"contains",
+		"isNull",
+		"isNotNull"
+	],
+	integer: [
+		"eq",
+		"ne",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"in",
+		"notIn",
+		"isNull",
+		"isNotNull"
+	],
+	decimal: [
+		"eq",
+		"ne",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"in",
+		"notIn",
+		"isNull",
+		"isNotNull"
+	],
+	datetime: [
+		"eq",
+		"ne",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"in",
+		"notIn",
+		"isNull",
+		"isNotNull"
+	],
+	boolean: [
+		"eq",
+		"ne",
+		"isNull",
+		"isNotNull"
+	],
+	id: [
+		"eq",
+		"ne",
+		"in",
+		"notIn",
+		"isNull",
+		"isNotNull"
+	]
+};
+function runtimeReportAggregatesFor(type) {
+	if (type === "integer" || type === "decimal") return [
+		"count",
+		"countDistinct",
+		"sum",
+		"avg",
+		"min",
+		"max"
+	];
+	if (type === "datetime") return [
+		"count",
+		"countDistinct",
+		"min",
+		"max"
+	];
+	return ["count", "countDistinct"];
+}
+function assertRuntimeReportFilterOperator(filter, type, path) {
+	if (!RUNTIME_REPORT_OPERATORS_BY_TYPE[type].includes(filter.op)) badOperation(`${path}.op`, `'${filter.op}' is not valid for ${type} fields`);
+}
+function coerceRuntimeReportValue(type, value, path) {
+	switch (type) {
+		case "string":
+			if (typeof value !== "string") badValue(path, "must be a string");
+			return value;
+		case "integer":
+			if (typeof value !== "number" || !Number.isSafeInteger(value)) badValue(path, "must be a safe integer");
+			return value;
+		case "decimal":
+			if (typeof value !== "number" || !Number.isFinite(value)) badValue(path, "must be a finite number");
+			return value;
+		case "boolean":
+			if (typeof value !== "boolean") badValue(path, "must be true or false");
+			return value;
+		case "datetime": {
+			if (typeof value !== "string") badValue(path, "must be an ISO-8601 string");
+			const parsed = new Date(value);
+			if (Number.isNaN(parsed.getTime()) || !/^\d{4}-\d{2}-\d{2}/.test(value)) badValue(path, "must be an ISO-8601 date or timestamp");
+			return parsed;
+		}
+		case "id":
+			if (typeof value !== "string" || !UUID_PATTERN.test(value)) badValue(path, "must be a UUID");
+			return value.toLowerCase();
+	}
+}
+function resolveRuntimeReportFieldPolicy(source, knownNames) {
+	const policy = (key) => {
+		const value = source[key];
+		if (value === void 0) return void 0;
+		if (!Array.isArray(value) || Array.from(value).some((name) => typeof name !== "string" || !knownNames.has(name))) throw new RuntimeReportError("unsupported_source", `source.${key}`, `${key} must contain canonical field names declared on the source`);
+		return new Set(value);
+	};
+	const included = policy("fields");
+	const excluded = policy("excludeFields");
+	policy("dimensions");
+	if (source.timeField !== void 0 && (typeof source.timeField !== "string" || !knownNames.has(source.timeField))) throw new RuntimeReportError("unsupported_source", "source.timeField", "timeField must be a canonical field name declared on the source");
+	return {
+		...included ? { included } : {},
+		...excluded ? { excluded } : {}
+	};
+}
+function measureColumnType(fn, field) {
+	if (fn === "count" || fn === "countDistinct") return "integer";
+	if (fn === "avg") return "decimal";
+	return field?.type ?? "decimal";
+}
+function planRuntimeReportColumns(spec, fields) {
+	const lookup = (name, path) => {
+		const field = fields.get(name);
+		if (!field) unknownRuntimeReportField(path, name);
+		return field;
+	};
+	const columns = [];
+	for (const [index, dimension] of spec.dimensions.entries()) {
+		const path = `spec.dimensions[${index}]`;
+		const field = lookup(dimension.field, `${path}.field`);
+		if (dimension.bucket && field.type !== "datetime") badOperation(`${path}.bucket`, "buckets are only valid on datetime fields");
+		columns.push({
+			id: dimension.as,
+			label: humanizeRuntimeReportName(dimension.as),
+			role: "dimension",
+			type: dimension.bucket ? "datetime" : field.type,
+			field: field.name,
+			...dimension.bucket ? { bucket: dimension.bucket } : {},
+			...field.format && !dimension.bucket ? { format: field.format } : {}
+		});
+	}
+	for (const [index, measure] of spec.measures.entries()) {
+		const path = `spec.measures[${index}]`;
+		const field = measure.field ? lookup(measure.field, `${path}.field`) : void 0;
+		if ((measure.fn === "sum" || measure.fn === "avg") && field?.type !== "integer" && field?.type !== "decimal") badOperation(`${path}.fn`, `${measure.fn} requires a numeric field`);
+		if ((measure.fn === "min" || measure.fn === "max") && field?.type !== "integer" && field?.type !== "decimal" && field?.type !== "datetime") badOperation(`${path}.fn`, `${measure.fn} requires a numeric or datetime field`);
+		const keepsFormat = field?.format && (measure.fn === "sum" || measure.fn === "min" || measure.fn === "max" || measure.fn === "avg");
+		columns.push({
+			id: measure.as,
+			label: humanizeRuntimeReportName(measure.as),
+			role: "measure",
+			type: measureColumnType(measure.fn, field),
+			...field ? { field: field.name } : {},
+			fn: measure.fn,
+			...keepsFormat ? { format: field?.format } : {}
+		});
+	}
+	return columns;
+}
+function normalizeRuntimeReportCell(column, value) {
+	if (value === null || value === void 0) return null;
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "bigint") {
+		const asNumber = Number(value);
+		if (!Number.isSafeInteger(asNumber)) throw new RuntimeReportError("invalid_result", column.id, "integer result exceeds the JavaScript safe range");
+		return asNumber;
+	}
+	if (column.type === "boolean") {
+		if (value === 1 || value === "1" || value === "true" || value === true) return true;
+		if (value === 0 || value === "0" || value === "false" || value === false) return false;
+	}
+	if (column.type === "integer" || column.type === "decimal") {
+		const numeric = typeof value === "number" ? value : Number(value);
+		if (!Number.isFinite(numeric)) throw new RuntimeReportError("invalid_result", column.id, "numeric result is not finite");
+		if (column.type === "integer" && !Number.isSafeInteger(numeric)) throw new RuntimeReportError("invalid_result", column.id, "integer result exceeds the JavaScript safe range");
+		return numeric;
+	}
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	return String(value);
+}
+//#endregion
+//#region src/runtime-dimensions.ts
+var INTERNAL_NAME = /^(?:id|_.*)$|(?:Hash|Json|Token|Secret|Signature|Authority|Snapshot|Checksum|Cursor|Etag)$|^(?:external|historical)[A-Z]/;
+var BOOKKEEPING_TIME = /^(?:created|updated|deleted|synced|archived)At$|^last[A-Z]\w*At$/;
+var STATUS_NAME = /^(?:status|state)$|(?:Status|State)$/;
+var KIND_NAME = /^(?:kind|type|category|method|channel|stage|priority|segment|tier|source)$|(?:Kind|Type|Category|Method|Channel|Stage|Priority|Segment|Tier)$/;
+var PARTY_RELATION = /^(?:customer|vendor|supplier|client|member|employee|owner|assignee|product|location|project|account|contact)Id$/;
+var MAX_CATEGORY_VALUES = 50;
+function kindOf(field) {
+	if (field.type === "datetime") return field.name === "deletedAt" ? void 0 : "time";
+	if (INTERNAL_NAME.test(field.name)) return void 0;
+	if (field.type === "boolean") return "category";
+	if (field.type === "string" && field.enum && field.enum.length > 0 && field.enum.length <= MAX_CATEGORY_VALUES) return "category";
+	if (field.type === "id" && /Id$/.test(field.name)) return "relation";
+}
+function rank(field) {
+	if (field.type === "boolean") return 10;
+	if (field.type === "id") return PARTY_RELATION.test(field.name) ? 70 : 30;
+	if (STATUS_NAME.test(field.name)) return 100;
+	if (KIND_NAME.test(field.name)) return 80;
+	return 50;
+}
+function planRuntimeReportDimensions(fields, hints = {}) {
+	const all = [...fields.values()];
+	const kinds = /* @__PURE__ */ new Map();
+	for (const field of all) {
+		const kind = kindOf(field);
+		if (kind) kinds.set(field.name, kind);
+	}
+	const times = all.filter((field) => kinds.get(field.name) === "time");
+	const defaultTimeField = (hints.timeField && fields.get(hints.timeField)?.type === "datetime" ? hints.timeField : void 0) ?? times.find((field) => field.businessDate)?.name ?? times.find((field) => !BOOKKEEPING_TIME.test(field.name))?.name ?? times.find((field) => field.name === "createdAt")?.name ?? times[0]?.name;
+	const timeFields = [...defaultTimeField ? [defaultTimeField] : [], ...times.map((f) => f.name).filter((name) => name !== defaultTimeField)];
+	let dimensions;
+	if (hints.dimensions) {
+		dimensions = hints.dimensions.filter((name) => fields.has(name) && fields.get(name)?.type !== "datetime");
+		for (const name of dimensions) if (!kinds.has(name)) kinds.set(name, fields.get(name)?.type === "id" ? "relation" : "category");
+		for (const [name, kind] of [...kinds]) if (kind !== "time" && !dimensions.includes(name)) kinds.delete(name);
+	} else dimensions = all.filter((field) => {
+		const kind = kinds.get(field.name);
+		return kind === "category" || kind === "relation";
+	}).map((field, index) => ({
+		field,
+		index
+	})).sort((a, b) => rank(b.field) - rank(a.field) || a.index - b.index).map(({ field }) => field.name);
+	return {
+		kinds,
+		timeFields,
+		...defaultTimeField ? { defaultTimeField } : {},
+		dimensions
+	};
+}
+function describeRuntimeReportSourceFields(fields, hints = {}) {
+	const plan = planRuntimeReportDimensions(fields, hints);
+	return {
+		fields: [...fields.values()].map((field) => {
+			const dimension = plan.kinds.get(field.name);
+			return {
+				name: field.name,
+				label: field.label,
+				type: field.type,
+				...field.format ? { format: field.format } : {},
+				...field.enum ? { enum: field.enum } : {},
+				...dimension ? { dimension } : {},
+				filterOperators: RUNTIME_REPORT_OPERATORS_BY_TYPE[field.type],
+				aggregates: runtimeReportAggregatesFor(field.type)
+			};
+		}),
+		timeFields: plan.timeFields,
+		...plan.defaultTimeField ? { defaultTimeField: plan.defaultTimeField } : {},
+		dimensions: plan.dimensions
+	};
+}
+//#endregion
+//#region src/runtime-memory.ts
+var NON_NAMEABLE = /* @__PURE__ */ new Set(["tenantId", "tenant_id"]);
+function resolveMemorySource(sources, id) {
+	const source = sources.find((candidate) => candidate.id === id);
+	if (!source) throw new RuntimeReportError("unknown_source", "spec.source", `'${id}' is not an available report source`);
+	return source;
+}
+function memoryFields(source) {
+	const { included, excluded } = resolveRuntimeReportFieldPolicy(source, new Set(source.schema.map((field) => field.name)));
+	const fields = /* @__PURE__ */ new Map();
+	for (const field of source.schema) {
+		if (field.name.startsWith("_") || NON_NAMEABLE.has(field.name) || excluded?.has(field.name) || included && !included.has(field.name) || fields.has(field.name)) continue;
+		fields.set(field.name, {
+			name: field.name,
+			type: field.type,
+			...field.format ? { format: field.format } : {},
+			...field.type === "string" && field.enum?.length ? { enum: field.enum } : {},
+			...field.type === "datetime" && field.format === "date" ? { businessDate: true } : {},
+			label: field.label ?? humanizeRuntimeReportName(field.name)
+		});
+	}
+	return fields;
+}
+function describeRuntimeReportMemorySource(sources, sourceId) {
+	const source = resolveMemorySource(sources, sourceId);
+	return {
+		id: source.id,
+		label: source.label ?? humanizeRuntimeReportName(source.id),
+		...source.description ? { description: source.description } : {},
+		...describeRuntimeReportSourceFields(memoryFields(source), source)
+	};
+}
+function toDate(value) {
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+	if (typeof value === "string" || typeof value === "number") {
+		const parsed = new Date(value);
+		return Number.isNaN(parsed.getTime()) ? null : parsed;
+	}
+	return null;
+}
+function readCell(row, field) {
+	const value = row[field.name];
+	if (value === null || value === void 0) return null;
+	switch (field.type) {
+		case "integer":
+		case "decimal": {
+			if (typeof value === "bigint") {
+				if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER)) throw new RuntimeReportError("invalid_result", field.name, "integer value exceeds the JavaScript safe range");
+				return Number(value);
+			}
+			const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+			return Number.isFinite(numeric) ? numeric : null;
+		}
+		case "boolean":
+			if (value === true || value === 1 || value === "1" || value === "true") return true;
+			if (value === false || value === 0 || value === "0" || value === "false") return false;
+			return null;
+		case "datetime": return toDate(value);
+		default: return typeof value === "string" ? value : String(value);
+	}
+}
+function compareCells(a, b) {
+	const left = a instanceof Date ? a.getTime() : a;
+	const right = b instanceof Date ? b.getTime() : b;
+	if (typeof left === "boolean" || typeof right === "boolean") return Number(left) - Number(right);
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+function filterPredicate(filter, field, path) {
+	assertRuntimeReportFilterOperator(filter, field.type, path);
+	const read = (row) => readCell(row, field);
+	switch (filter.op) {
+		case "isNull": return (row) => read(row) === null;
+		case "isNotNull": return (row) => read(row) !== null;
+		case "in":
+		case "notIn": {
+			const values = filter.value.map((entry, index) => coerceRuntimeReportValue(field.type, entry, `${path}.value[${index}]`));
+			const member = (cell) => values.some((value) => compareCells(cell, value) === 0);
+			return filter.op === "in" ? (row) => {
+				const cell = read(row);
+				return cell !== null && member(cell);
+			} : (row) => {
+				const cell = read(row);
+				return cell !== null && !member(cell);
+			};
+		}
+		case "contains": {
+			const needle = coerceRuntimeReportValue(field.type, filter.value, `${path}.value`);
+			return (row) => {
+				const cell = read(row);
+				return typeof cell === "string" && cell.includes(needle);
+			};
+		}
+		default: {
+			const target = coerceRuntimeReportValue(field.type, filter.value, `${path}.value`);
+			const test = {
+				eq: (order) => order === 0,
+				ne: (order) => order !== 0,
+				gt: (order) => order > 0,
+				gte: (order) => order >= 0,
+				lt: (order) => order < 0,
+				lte: (order) => order <= 0
+			}[filter.op];
+			return (row) => {
+				const cell = read(row);
+				return cell !== null && test(compareCells(cell, target));
+			};
+		}
+	}
+}
+function bucketStart(date, bucket) {
+	const y = date.getUTCFullYear();
+	const m = date.getUTCMonth();
+	const d = date.getUTCDate();
+	switch (bucket) {
+		case "minute": return new Date(Date.UTC(y, m, d, date.getUTCHours(), date.getUTCMinutes()));
+		case "hour": return new Date(Date.UTC(y, m, d, date.getUTCHours()));
+		case "day": return new Date(Date.UTC(y, m, d));
+		case "week": {
+			const daysSinceMonday = (date.getUTCDay() + 6) % 7;
+			return new Date(Date.UTC(y, m, d - daysSinceMonday));
+		}
+		case "month": return new Date(Date.UTC(y, m, 1));
+		case "quarter": return new Date(Date.UTC(y, Math.floor(m / 3) * 3, 1));
+		case "year": return new Date(Date.UTC(y, 0, 1));
+	}
+}
+function cellKey(cell) {
+	if (cell === null) return "n";
+	if (cell instanceof Date) return `d${cell.getTime()}`;
+	return `${typeof cell}:${String(cell)}`;
+}
+function aggregate(fn, cells, rowCount) {
+	if (cells === null) return rowCount;
+	const present = cells.filter((cell) => cell !== null);
+	switch (fn) {
+		case "count": return present.length;
+		case "countDistinct": return new Set(present.map(cellKey)).size;
+		case "sum":
+			if (present.length === 0) return null;
+			return present.reduce((total, value) => total + value, 0);
+		case "avg":
+			if (present.length === 0) return null;
+			return present.reduce((sum, value) => sum + value, 0) / present.length;
+		case "min":
+		case "max": {
+			if (present.length === 0) return null;
+			let best = present[0];
+			for (const cell of present.slice(1)) {
+				const order = compareCells(cell, best);
+				if (fn === "min" ? order < 0 : order > 0) best = cell;
+			}
+			return best;
+		}
+		default: return null;
+	}
+}
+function havingHolds(entry, value) {
+	if (typeof value !== "number") return false;
+	switch (entry.op) {
+		case "eq": return value === entry.value;
+		case "ne": return value !== entry.value;
+		case "gt": return value > entry.value;
+		case "gte": return value >= entry.value;
+		case "lt": return value < entry.value;
+		case "lte": return value <= entry.value;
+	}
+}
+function compareForSort(a, b, direction) {
+	let order;
+	if (a === null && b === null) order = 0;
+	else if (a === null) order = -1;
+	else if (b === null) order = 1;
+	else order = compareCells(a, b);
+	return direction === "desc" ? -order : order;
+}
+async function runRuntimeReportInMemory(input, rows, options) {
+	const spec = parseRuntimeReportSpec(input);
+	const source = resolveMemorySource(options.sources, spec.source);
+	const fields = memoryFields(source);
+	const columns = planRuntimeReportColumns(spec, fields);
+	const lookup = (name, path) => {
+		const field = fields.get(name);
+		if (!field) unknownRuntimeReportField(path, name);
+		return field;
+	};
+	const predicates = [];
+	if (source.schema.some((field) => field.name === "deletedAt")) predicates.push((row) => row.deletedAt === null || row.deletedAt === void 0);
+	for (const [index, filter] of spec.filters.entries()) {
+		const path = `spec.filters[${index}]`;
+		predicates.push(filterPredicate(filter, lookup(filter.field, `${path}.field`), path));
+	}
+	const kept = rows.filter((row) => predicates.every((test) => test(row)));
+	const dimensionReaders = spec.dimensions.map((dimension) => {
+		const field = fields.get(dimension.field);
+		return (row) => {
+			const cell = readCell(row, field);
+			if (dimension.bucket && cell instanceof Date) return bucketStart(cell, dimension.bucket);
+			return cell;
+		};
+	});
+	const groups = /* @__PURE__ */ new Map();
+	if (spec.dimensions.length === 0) groups.set("", {
+		key: [],
+		rows: kept
+	});
+	else for (const row of kept) {
+		const key = dimensionReaders.map((read) => read(row));
+		const id = JSON.stringify(key.map(cellKey));
+		const group = groups.get(id);
+		if (group) group.rows.push(row);
+		else groups.set(id, {
+			key,
+			rows: [row]
+		});
+	}
+	const measureFields = spec.measures.map((measure) => measure.field ? fields.get(measure.field) : null);
+	let results = [...groups.values()].map((group) => {
+		const values = {};
+		spec.dimensions.forEach((dimension, index) => {
+			values[dimension.as] = group.key[index];
+		});
+		spec.measures.forEach((measure, index) => {
+			const field = measureFields[index];
+			values[measure.as] = aggregate(measure.fn, field ? group.rows.map((row) => readCell(row, field)) : null, group.rows.length);
+		});
+		return values;
+	});
+	if (spec.having.length > 0) results = results.filter((values) => spec.having.every((entry) => havingHolds(entry, values[entry.measure])));
+	const sort = spec.sort.length > 0 ? spec.sort : spec.dimensions.length > 0 ? [{
+		by: spec.dimensions[0].as,
+		direction: "asc"
+	}] : [];
+	if (sort.length > 0) results = results.map((values, index) => ({
+		values,
+		index
+	})).sort((left, right) => {
+		for (const entry of sort) {
+			const order = compareForSort(left.values[entry.by], right.values[entry.by], entry.direction);
+			if (order !== 0) return order;
+		}
+		return left.index - right.index;
+	}).map(({ values }) => values);
+	const limit = Math.min(spec.limit, options.maxRows ?? RUNTIME_REPORT_LIMITS.maxRowLimit);
+	const truncated = results.length > limit;
+	const outRows = results.slice(0, limit).map((values) => {
+		const out = {};
+		for (const column of columns) out[column.id] = normalizeRuntimeReportCell(column, values[column.id]);
+		return out;
+	});
+	return {
+		version: 1,
+		specHash: await runtimeReportSpecDigest(spec),
+		title: spec.title,
+		columns,
+		rows: outRows,
+		rowCount: outRows.length,
+		truncated,
+		ranAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+		chart: spec.chart
+	};
+}
+//#endregion
+//#region src/runtime-time.ts
+var DAY = 864e5;
+var ymd = (time) => new Date(time).toISOString().slice(0, 10);
+var MONTHS = [
+	"january",
+	"february",
+	"march",
+	"april",
+	"may",
+	"june",
+	"july",
+	"august",
+	"september",
+	"october",
+	"november",
+	"december"
+];
+var ORDINAL_QUARTERS = {
+	first: 1,
+	second: 2,
+	third: 3,
+	fourth: 4
+};
+var BUCKET_WORDS = [
+	["minute", /\b(?:minutely|(?:per|by|each|every|a) minute|minute by minute)\b/],
+	["hour", /\b(?:hourly|(?:per|by|each|every|an?) hour|hour by hour)\b/],
+	["day", /\b(?:daily|(?:per|by|each|every|a) day|day by day)\b/],
+	["week", /\b(?:weekly|(?:per|by|each|every|a) week|week by week|week over week)\b/],
+	["month", /\b(?:monthly|(?:per|by|each|every|a) month|month by month|month over month)\b/],
+	["quarter", /\b(?:quarterly|(?:per|by|each|every|a) quarter|quarter by quarter|quarter over quarter)\b/],
+	["year", /\b(?:yearly|annually|annual|(?:per|by|each|every|a) year|year by year|year over year)\b/]
+];
+var TREND_WORDS = /\b(?:over time|trends?|trending|timeline|history)\b/;
+function runtimeReportBucketForSpan(days) {
+	if (days === null) return "month";
+	if (days <= 31) return "day";
+	if (days <= 92) return "week";
+	if (days <= 3 * 366) return "month";
+	return "quarter";
+}
+function span(range) {
+	return Math.round((Date.parse(`${range.to}T00:00:00Z`) - Date.parse(`${range.from}T00:00:00Z`)) / DAY);
+}
+function resolveRuntimeReportTimeRange(phrase, now) {
+	const text = phrase.toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ");
+	const y = now.getUTCFullYear();
+	const m = now.getUTCMonth();
+	const today = Date.UTC(y, m, now.getUTCDate());
+	const tomorrow = today + DAY;
+	const monday = today - (now.getUTCDay() + 6) % 7 * DAY;
+	const quarter = Math.floor(m / 3) * 3;
+	const range = (from, to, label) => ({
+		from: ymd(from),
+		to: ymd(to),
+		label
+	});
+	const recent = /\b(?:last|past|previous|trailing)\s+(\d{1,4})\s+(day|week|month|year)s?\b/.exec(text);
+	if (recent) {
+		const n = Number(recent[1]);
+		const unit = recent[2];
+		if (n > 0) return range(unit === "day" ? tomorrow - n * DAY : unit === "week" ? tomorrow - n * 7 * DAY : unit === "month" ? Date.UTC(y, m - n, now.getUTCDate() + 1) : Date.UTC(y - n, m, now.getUTCDate() + 1), tomorrow, `last ${n} ${unit}${n === 1 ? "" : "s"}`);
+	}
+	const q = /\bq([1-4])(?:\s*(?:of\s*)?((?:19|20)\d{2}))?\b/.exec(text) ?? /\b(first|second|third|fourth) quarter(?: (?:of )?((?:19|20)\d{2}))?\b/.exec(text);
+	if (q) {
+		const n = /^\d$/.test(q[1]) ? Number(q[1]) : ORDINAL_QUARTERS[q[1]];
+		const startMonth = (n - 1) * 3;
+		const year2 = q[2] ? Number(q[2]) : Date.UTC(y, startMonth, 1) <= today ? y : y - 1;
+		return range(Date.UTC(year2, startMonth, 1), Date.UTC(year2, startMonth + 3, 1), `Q${n} ${year2}`);
+	}
+	if (/\b(?:year to date|ytd)\b/.test(text)) return range(Date.UTC(y, 0, 1), tomorrow, "year to date");
+	if (/\b(?:month to date|mtd)\b/.test(text)) return range(Date.UTC(y, m, 1), tomorrow, "month to date");
+	if (/\btoday\b/.test(text)) return range(today, tomorrow, "today");
+	if (/\byesterday\b/.test(text)) return range(today - DAY, today, "yesterday");
+	const relative = /\b(this|current|last|previous|past) (week|month|quarter|year)\b/.exec(text);
+	if (relative) {
+		const last = relative[1] !== "this" && relative[1] !== "current";
+		const unit = relative[2];
+		const label = `${last ? "last" : "this"} ${unit}`;
+		switch (unit) {
+			case "week": return last ? range(monday - 7 * DAY, monday, label) : range(monday, monday + 7 * DAY, label);
+			case "month": return last ? range(Date.UTC(y, m - 1, 1), Date.UTC(y, m, 1), label) : range(Date.UTC(y, m, 1), Date.UTC(y, m + 1, 1), label);
+			case "quarter": return last ? range(Date.UTC(y, quarter - 3, 1), Date.UTC(y, quarter, 1), label) : range(Date.UTC(y, quarter, 1), Date.UTC(y, quarter + 3, 1), label);
+			default: return last ? range(Date.UTC(y - 1, 0, 1), Date.UTC(y, 0, 1), label) : range(Date.UTC(y, 0, 1), Date.UTC(y + 1, 0, 1), label);
+		}
+	}
+	const month = new RegExp(`\\b(${MONTHS.join("|")})(?: ((?:19|20)\\d{2}))?\\b`).exec(text);
+	if (month && (month[1] !== "may" || month[2])) {
+		const match = month;
+		const index = MONTHS.indexOf(match[1]);
+		const year2 = match[2] ? Number(match[2]) : Date.UTC(y, index, 1) <= today ? y : y - 1;
+		const name = match[1].charAt(0).toUpperCase() + match[1].slice(1);
+		return range(Date.UTC(year2, index, 1), Date.UTC(year2, index + 1, 1), `${name} ${year2}`);
+	}
+	const year = /\b(?:in|for|during)\s+((?:19|20)\d{2})\b/.exec(text) ?? /^\s*((?:19|20)\d{2})\s*$/.exec(text);
+	if (year) {
+		const n = Number(year[1]);
+		return range(Date.UTC(n, 0, 1), Date.UTC(n + 1, 0, 1), String(n));
+	}
+	return null;
+}
+function parseRuntimeReportTime(text, now) {
+	const words = text.toLowerCase();
+	const range = resolveRuntimeReportTimeRange(words, now) ?? void 0;
+	let bucket = BUCKET_WORDS.find(([, pattern]) => pattern.test(words))?.[0];
+	const trend = TREND_WORDS.test(words);
+	if (!bucket && trend) bucket = runtimeReportBucketForSpan(range ? span(range) : null);
+	const mentionsTime = Boolean(bucket || range || trend) || /\b(?:date|dates|time|when|minute|hour|day|week|month|quarter|year)s?\b/.test(words);
+	return {
+		...bucket ? { bucket } : {},
+		...range ? { range } : {},
+		mentionsTime
+	};
+}
+//#endregion
+export { runtimeReportSpecDigest as C, parseRuntimeReportSpec as S, RUNTIME_REPORT_HAVING_OPS as _, runRuntimeReportInMemory as a, RUNTIME_REPORT_SPEC_VERSION as b, coerceRuntimeReportValue as c, planRuntimeReportColumns as d, resolveRuntimeReportFieldPolicy as f, RUNTIME_REPORT_FILTER_OPS as g, RUNTIME_REPORT_CHART_TYPES as h, describeRuntimeReportMemorySource as i, humanizeRuntimeReportName as l, RUNTIME_REPORT_BUCKETS as m, resolveRuntimeReportTimeRange as n, describeRuntimeReportSourceFields as o, unknownRuntimeReportField as p, runtimeReportBucketForSpan as r, assertRuntimeReportFilterOperator as s, parseRuntimeReportTime as t, normalizeRuntimeReportCell as u, RUNTIME_REPORT_LIMITS as v, serializeRuntimeReportSpec as w, RuntimeReportError as x, RUNTIME_REPORT_MEASURE_FNS as y };
+
+//# sourceMappingURL=runtime-time-D7JZ1e4J.js.map