@flowdular/sdk 0.2.4 → 0.3.0

package/modules/metering/src/services/migration.ts

@@ -0,0 +1,183 @@
+import type {
+	DatabaseMigration,
+	DatabaseSession,
+	ExistingMigrationState,
+} from '@flowdular/sdk/database';
+import {
+	migrationObjectState,
+	postgresTenantTableState,
+} from '@flowdular/sdk/database';
+
+/* Mirrors migrations/0001_metering_core.up.sql byte for byte;
+   tests/migrations.test.ts fails on drift. */
+export const METERING_MIGRATION_001 = `-- Meters as one workspace recorded them. The declaration itself lives in the
+-- composed process; a row appears the first time a module reports a fact for
+-- this workspace, which is what makes the registry readable under the tenant
+-- policy like every other row metering.core owns.
+CREATE TABLE IF NOT EXISTS metering_meters (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  meter_key TEXT NOT NULL CHECK (length(meter_key) BETWEEN 1 AND 96),
+  module_id TEXT NOT NULL CHECK (length(module_id) BETWEEN 1 AND 64),
+  label TEXT NOT NULL CHECK (length(label) BETWEEN 1 AND 120),
+  unit TEXT NOT NULL CHECK (length(unit) BETWEEN 1 AND 32),
+  kind TEXT NOT NULL CHECK (kind IN ('cumulative', 'gauge')),
+  created_at BIGINT NOT NULL,
+  UNIQUE (tenant_id, meter_key)
+);
+ALTER TABLE metering_meters ENABLE ROW LEVEL SECURITY;
+ALTER TABLE metering_meters FORCE ROW LEVEL SECURITY;
+CREATE POLICY metering_meters_tenant_policy ON metering_meters
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+
+-- One row per meter per UTC day. The unique key is also the index every read
+-- and every accumulating write uses, so a fact costs one upsert and a month
+-- total is a range scan over ordered days.
+CREATE TABLE IF NOT EXISTS metering_buckets (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  meter_key TEXT NOT NULL CHECK (length(meter_key) BETWEEN 1 AND 96),
+  day TEXT NOT NULL CHECK (length(day) = 10),
+  amount BIGINT NOT NULL CHECK (amount >= 0),
+  events BIGINT NOT NULL CHECK (events >= 0),
+  updated_at BIGINT NOT NULL,
+  UNIQUE (tenant_id, meter_key, day)
+);
+CREATE INDEX IF NOT EXISTS metering_buckets_tenant_day_idx
+  ON metering_buckets (tenant_id, day, meter_key);
+ALTER TABLE metering_buckets ENABLE ROW LEVEL SECURITY;
+ALTER TABLE metering_buckets FORCE ROW LEVEL SECURITY;
+CREATE POLICY metering_buckets_tenant_policy ON metering_buckets
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+
+-- What makes a fact idempotent. The unique key is the whole mechanism: a
+-- repeat of a source reference inserts nothing and the bucket is left alone.
+-- The day column is carried so a retention sweep of the bucket class removes
+-- these rows on the same cutoff and the same index.
+CREATE TABLE IF NOT EXISTS metering_records (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  meter_key TEXT NOT NULL CHECK (length(meter_key) BETWEEN 1 AND 96),
+  source_ref TEXT NOT NULL CHECK (length(source_ref) BETWEEN 1 AND 200),
+  day TEXT NOT NULL CHECK (length(day) = 10),
+  amount BIGINT NOT NULL CHECK (amount >= 0),
+  recorded_at BIGINT NOT NULL,
+  UNIQUE (tenant_id, meter_key, source_ref)
+);
+CREATE INDEX IF NOT EXISTS metering_records_tenant_day_idx
+  ON metering_records (tenant_id, day, id);
+ALTER TABLE metering_records ENABLE ROW LEVEL SECURITY;
+ALTER TABLE metering_records FORCE ROW LEVEL SECURITY;
+CREATE POLICY metering_records_tenant_policy ON metering_records
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+
+-- The operator's ceiling. No foreign key to metering_meters: a limit is set
+-- before the workspace has reported its first fact for that meter, which is
+-- the point of setting one.
+CREATE TABLE IF NOT EXISTS metering_limits (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  meter_key TEXT NOT NULL CHECK (length(meter_key) BETWEEN 1 AND 96),
+  monthly_limit BIGINT NOT NULL CHECK (monthly_limit >= 0),
+  set_by TEXT NOT NULL CHECK (length(set_by) BETWEEN 1 AND 128),
+  updated_at BIGINT NOT NULL,
+  UNIQUE (tenant_id, meter_key)
+);
+ALTER TABLE metering_limits ENABLE ROW LEVEL SECURITY;
+ALTER TABLE metering_limits FORCE ROW LEVEL SECURITY;
+CREATE POLICY metering_limits_tenant_policy ON metering_limits
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+
+-- Every limit the operator set, in order, with the label the CLI derived. The
+-- limit row carries the current value; this is the evidence of how it got
+-- there and it is never rewritten.
+CREATE TABLE IF NOT EXISTS metering_limit_events (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  meter_key TEXT NOT NULL CHECK (length(meter_key) BETWEEN 1 AND 96),
+  monthly_limit BIGINT NOT NULL CHECK (monthly_limit >= 0),
+  previous_limit BIGINT CHECK (previous_limit IS NULL OR previous_limit >= 0),
+  set_by TEXT NOT NULL CHECK (length(set_by) BETWEEN 1 AND 128),
+  occurred_at BIGINT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS metering_limit_events_tenant_occurred_idx
+  ON metering_limit_events (tenant_id, occurred_at DESC, id);
+ALTER TABLE metering_limit_events ENABLE ROW LEVEL SECURITY;
+ALTER TABLE metering_limit_events FORCE ROW LEVEL SECURITY;
+CREATE POLICY metering_limit_events_tenant_policy ON metering_limit_events
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+
+-- One row per meter per month per threshold. The unique key is what makes a
+-- threshold notification happen once: the row is claimed inside the recording
+-- transaction and only a claim that inserted publishes.
+CREATE TABLE IF NOT EXISTS metering_threshold_notices (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  meter_key TEXT NOT NULL CHECK (length(meter_key) BETWEEN 1 AND 96),
+  month TEXT NOT NULL CHECK (length(month) = 7),
+  threshold TEXT NOT NULL CHECK (threshold IN ('warning', 'exhausted')),
+  sent_at BIGINT NOT NULL,
+  UNIQUE (tenant_id, meter_key, month, threshold)
+);
+ALTER TABLE metering_threshold_notices ENABLE ROW LEVEL SECURITY;
+ALTER TABLE metering_threshold_notices FORCE ROW LEVEL SECURITY;
+CREATE POLICY metering_threshold_notices_tenant_policy ON metering_threshold_notices
+  USING (tenant_id = current_setting('coreloom.tenant_id', true))
+  WITH CHECK (tenant_id = current_setting('coreloom.tenant_id', true));
+`;
+
+/* Mirrors migrations/0002_metering_bucket_export.up.sql byte for byte. */
+export const METERING_MIGRATION_002 = `-- The data class export walks a workspace's buckets by id, ascending. The
+-- retention index leads with the day, so it cannot serve that walk and a large
+-- workspace paged through a sequential scan per page.
+CREATE INDEX IF NOT EXISTS metering_buckets_tenant_export_idx
+  ON metering_buckets (tenant_id, id);
+`;
+
+/** Every tenant table of this module, with the policy each one must carry. */
+export const METERING_TENANT_TABLES = [
+	'metering_meters',
+	'metering_buckets',
+	'metering_records',
+	'metering_limits',
+	'metering_limit_events',
+	'metering_threshold_notices',
+] as const;
+
+/* One migration creates every table, so adoption is the conjunction: a schema
+   carrying only some of them is partial and the runner refuses it rather than
+   trusting a half-built one. */
+async function tenantTablesState(
+	database: DatabaseSession,
+): Promise<ExistingMigrationState> {
+	const states: ExistingMigrationState[] = [];
+	for (const table of METERING_TENANT_TABLES) {
+		states.push(
+			await postgresTenantTableState(database, table, `${table}_tenant_policy`),
+		);
+	}
+	if (states.every((state) => state === 'complete')) return 'complete';
+	if (states.every((state) => state === 'absent')) return 'absent';
+	return 'partial';
+}
+
+export const databaseMigrations: readonly DatabaseMigration[] = [
+	{
+		id: '0001_metering_core',
+		sql: { postgresql: METERING_MIGRATION_001 },
+		inspectExisting: (database) => tenantTablesState(database),
+	},
+	{
+		id: '0002_metering_bucket_export',
+		sql: { postgresql: METERING_MIGRATION_002 },
+		inspectExisting: (database) =>
+			migrationObjectState([
+				() => database.schema.hasIndex('metering_buckets_tenant_export_idx'),
+			]),
+	},
+];

package/modules/metering/src/services/notifications.ts

@@ -0,0 +1,75 @@
+/* The notifications.core publish contract, declared here rather than imported.
+   notifications.core is optional: metering.core composes, records and refuses
+   with that module absent, so it may not be a package dependency. This mirror
+   is the contract notifications.core owns and must not drift from it.
+   modules/agents/src/services/notifications.ts holds the same mirror. */
+export const NOTIFICATIONS_PUBLISH_CAPABILITY = 'notifications.publish.v1';
+
+export interface NotificationPublishInput {
+	readonly tenantId: string;
+	readonly kind: 'meter-threshold';
+	readonly sourceModule: string;
+	readonly sourceRef: string;
+	readonly title: string;
+	readonly body?: string;
+	readonly recipients: readonly string[];
+}
+
+export interface NotificationPublishResult {
+	readonly inboxItemIds: readonly string[];
+	readonly deliveryIds: readonly string[];
+}
+
+export interface NotificationPublisher {
+	publish(input: NotificationPublishInput): Promise<NotificationPublishResult>;
+}
+
+/* Read at the point of use, never at composition time: the platform may
+   register notifications.core after metering.core, or never. */
+export type NotificationPublisherResolver = () => NotificationPublisher | null;
+
+const LIMITS = {
+	sourceModule: 64,
+	sourceRef: 200,
+	title: 200,
+	body: 4_000,
+	recipients: 64,
+	recipientId: 128,
+} as const;
+
+function clamp(value: string, limit: number): string {
+	return value.length > limit ? value.slice(0, limit) : value;
+}
+
+/* Advisory and post-commit. An absent notifications module, nobody to notify,
+   or a publisher that throws never changes a recorded fact, so this never
+   rejects. The threshold row was already claimed, which is what keeps a
+   published notification to one per meter per month per threshold. */
+export async function publishThresholdNotice(
+	resolve: NotificationPublisherResolver | undefined,
+	input: NotificationPublishInput,
+): Promise<void> {
+	if (input.recipients.length === 0) return;
+	try {
+		const publisher = resolve?.();
+		if (!publisher) return;
+		await publisher.publish({
+			tenantId: input.tenantId,
+			kind: input.kind,
+			sourceModule: clamp(input.sourceModule, LIMITS.sourceModule),
+			sourceRef: clamp(input.sourceRef, LIMITS.sourceRef),
+			title: clamp(input.title, LIMITS.title),
+			...(input.body === undefined
+				? {}
+				: { body: clamp(input.body, LIMITS.body) }),
+			recipients: input.recipients
+				.slice(0, LIMITS.recipients)
+				.map((recipient) => clamp(recipient, LIMITS.recipientId)),
+		});
+	} catch (error) {
+		console.warn(
+			`[metering] threshold notification for ${input.sourceRef} failed:`,
+			error instanceof Error ? error.message : error,
+		);
+	}
+}

package/modules/metering/src/services/reports.ts

@@ -0,0 +1,105 @@
+import {
+	REPORT_PROVIDER_LIMITS,
+	type ReportProvider,
+	type ReportProviderAnswer,
+	type ReportRange,
+	type ReportTile,
+} from '@flowdular/sdk/modules/reports';
+import { METERING_PERMISSIONS } from '../acl/permissions.ts';
+import type { MeterUsage } from '../domain/types.ts';
+import type { MeteringService } from './metering-service.ts';
+
+export const METERING_REPORT_PROVIDER_KEY = 'metering.usage';
+
+/**
+ * The label states the period because the tiles are this calendar month's
+ * rollup whatever range the reader picked: metering counts per month against
+ * the operator's monthly limit, and a slice of a month would not compare with
+ * that limit.
+ */
+export const METERING_REPORT_PROVIDER_LABEL = 'Usage this month';
+
+/** This module's own bundle names the period; the literal above is the fallback. */
+export const METERING_REPORT_PROVIDER_LABEL_KEY = 'metering.report.usage.label';
+
+/**
+ * The calendar month a `YYYY-MM` rollup covers, both days included. Day zero of
+ * the next month is the last day of this one, so February and a 30 day month
+ * are captioned with the day they actually end on.
+ */
+export function monthPeriod(month: string): ReportRange {
+	const year = Number(month.slice(0, 4));
+	const ordinal = Number(month.slice(5, 7));
+	return {
+		from: `${month}-01`,
+		to: new Date(Date.UTC(year, ordinal, 0)).toISOString().slice(0, 10),
+	};
+}
+
+/**
+ * The limit carried as the unit's context, so a tile reads "412 requests of
+ * 1000" without the contract growing a field only this provider would use. A
+ * composed unit past the contract's bound would make the whole provider
+ * unavailable, so an unusually long meter unit keeps its bare form instead.
+ */
+export function unitWithLimit(unit: string, limit: number | null): string {
+	if (limit === null) return unit.slice(0, REPORT_PROVIDER_LIMITS.unit);
+	const composed = `${unit} of ${limit}`;
+	return composed.length > REPORT_PROVIDER_LIMITS.unit
+		? unit.slice(0, REPORT_PROVIDER_LIMITS.unit)
+		: composed;
+}
+
+/**
+ * One tile per meter, busiest first, bounded to what a provider answer carries.
+ * A workspace with more meters than that shows the ones it spends on; the Usage
+ * screen still lists every one.
+ */
+export function usageTiles(
+	usage: readonly MeterUsage[],
+): readonly ReportTile[] {
+	return [...usage]
+		.sort(
+			(left, right) =>
+				right.used - left.used || left.meter.key.localeCompare(right.meter.key),
+		)
+		.slice(0, REPORT_PROVIDER_LIMITS.tiles)
+		.map((entry) => ({
+			key: entry.meter.key,
+			label: entry.meter.label,
+			value: entry.used,
+			unit: unitWithLimit(entry.meter.unit, entry.limit),
+		}));
+}
+
+function aborted(signal: AbortSignal | undefined): boolean {
+	return signal?.aborted === true;
+}
+
+/**
+ * This workspace's metered usage as a report provider. The read goes through
+ * this module's own service under its own tenant transaction, with the tenant
+ * reports.core resolved from the principal, so no table crosses a module line.
+ */
+export function createUsageReportProvider(
+	service: () => Promise<MeteringService>,
+): ReportProvider {
+	return {
+		key: METERING_REPORT_PROVIDER_KEY,
+		label: METERING_REPORT_PROVIDER_LABEL,
+		labelKey: METERING_REPORT_PROVIDER_LABEL_KEY,
+		permission: METERING_PERMISSIONS.read,
+		async read({ tenantId, signal }): Promise<ReportProviderAnswer> {
+			if (aborted(signal)) return { tiles: [] };
+			const metering = await service();
+			const usage = await metering.usage(tenantId, { signal });
+			if (aborted(signal)) return { tiles: [] };
+			/* The tiles are one calendar month whatever range was asked for, so
+			   the answer names that month. It is taken from the rows, which carry
+			   the month the read itself used, so a read that crosses a month
+			   boundary still captions the numbers it actually got. */
+			const month = usage[0]?.month ?? metering.currentMonth();
+			return { tiles: usageTiles(usage), period: monthPeriod(month) };
+		},
+	};
+}

package/modules/metering/src/services/repository.ts

@@ -0,0 +1,132 @@
+import type {
+	MeterKind,
+	MeterLimit,
+	MeterLimitEvent,
+	MeterThreshold,
+	MeterUsage,
+	UsageBucket,
+} from '../domain/types.ts';
+
+/** The declaration a fact is recorded under, as the registry resolved it. */
+export interface RecordedMeter {
+	/** The full key, `<moduleId>.<key>`. */
+	readonly key: string;
+	readonly moduleId: string;
+	readonly label: string;
+	readonly unit: string;
+	readonly kind: MeterKind;
+}
+
+/** Everything one fact needs, already validated and resolved by the service. */
+export interface RecordFactInput {
+	readonly tenantId: string;
+	readonly meter: RecordedMeter;
+	readonly day: string;
+	readonly month: string;
+	readonly amount: number;
+	readonly sourceRef: string | null;
+	readonly at: number;
+}
+
+export interface RecordFactResult {
+	/** False when this source reference had already been counted. */
+	readonly recorded: boolean;
+	/** This month's usage after the fact landed; zero when nothing was. */
+	readonly used: number;
+	readonly limit: number | null;
+}
+
+export interface BucketQuery {
+	readonly meter: string;
+	readonly from: string;
+	readonly to: string;
+}
+
+export interface SetLimitInput {
+	readonly tenantId: string;
+	readonly meter: string;
+	readonly monthlyLimit: number;
+	readonly setBy: string;
+	readonly at: number;
+}
+
+export interface SetLimitResult {
+	readonly limit: MeterLimit;
+	readonly previousLimit: number | null;
+	readonly event: MeterLimitEvent;
+}
+
+export interface UsageAgainstLimit {
+	readonly used: number;
+	readonly limit: number | null;
+}
+
+/**
+ * What a caller that may be abandoned hands down to the statement. A read on a
+ * request path passes the signal the caller is bounded by, so the statement is
+ * cancelled with the work nobody is waiting for any more.
+ */
+export interface MeteringReadOptions {
+	readonly signal?: AbortSignal | undefined;
+}
+
+/** The database-agnostic business port. No driver type crosses it. */
+export interface MeteringRepository {
+	/**
+	 * The whole fact in one tenant-scoped write transaction: the meter as this
+	 * workspace recorded it, the idempotency claim, the day bucket, and the
+	 * threshold rows this fact is the first to reach.
+	 */
+	recordFact(input: RecordFactInput): Promise<RecordFactResult>;
+	/**
+	 * Claims the thresholds of one meter and month that have not been claimed
+	 * yet and answers the ones this call won. A claim that never reaches a
+	 * published notification is the price of publishing at most once; a claim
+	 * lost to a crash before the insert is re-evaluated by the next fact.
+	 */
+	claimThresholds(
+		tenantId: string,
+		meter: string,
+		month: string,
+		thresholds: readonly MeterThreshold[],
+		at: number,
+	): Promise<readonly MeterThreshold[]>;
+	/** This month's usage and the limit of one meter, in one read. */
+	usageAgainstLimit(
+		tenantId: string,
+		meter: string,
+		month: string,
+	): Promise<UsageAgainstLimit>;
+	/** Every meter this workspace recorded, with the month's usage and limit. */
+	listMeterUsage(
+		tenantId: string,
+		month: string,
+		options?: MeteringReadOptions,
+	): Promise<readonly MeterUsage[]>;
+	listBuckets(
+		tenantId: string,
+		query: BucketQuery,
+	): Promise<readonly UsageBucket[]>;
+	listLimits(tenantId: string): Promise<readonly MeterLimit[]>;
+	setLimit(input: SetLimitInput): Promise<SetLimitResult>;
+	listLimitEvents(
+		tenantId: string,
+		limit: number,
+	): Promise<readonly MeterLimitEvent[]>;
+	/**
+	 * Removes at most `limit` buckets older than the UTC day `beforeDay`, and
+	 * the idempotency claims of the same days with them: a claim outliving its
+	 * bucket would suppress a fact whose usage is already gone.
+	 */
+	sweepBuckets(
+		tenantId: string,
+		beforeDay: string,
+		limit: number,
+	): Promise<{ readonly removed: number }>;
+	/** One keyset page of buckets, ordered by id, for the export walk. */
+	exportBucketsPage(
+		tenantId: string,
+		afterId: string,
+		limit: number,
+	): Promise<readonly UsageBucket[]>;
+}

package/modules/metering/src/services/service-error.ts

@@ -0,0 +1,46 @@
+export class MeteringServiceError extends Error {
+	constructor(
+		readonly code: string,
+		message: string,
+		readonly status = 400,
+	) {
+		super(message);
+		this.name = 'MeteringServiceError';
+	}
+}
+
+export function bounded(
+	value: string,
+	field: string,
+	minimum: number,
+	maximum: number,
+): string {
+	const normalized = typeof value === 'string' ? value.trim() : '';
+	if (normalized.length < minimum || normalized.length > maximum) {
+		throw new MeteringServiceError(
+			'INVALID_INPUT',
+			`${field} must contain between ${minimum} and ${maximum} characters.`,
+		);
+	}
+	if (normalized.includes('\u0000')) {
+		throw new MeteringServiceError(
+			'INVALID_INPUT',
+			`${field} contains an unsupported character.`,
+		);
+	}
+	return normalized;
+}
+
+export function wholeNumber(
+	value: number,
+	field: string,
+	maximum: number,
+): number {
+	if (!Number.isSafeInteger(value) || value < 0 || value > maximum) {
+		throw new MeteringServiceError(
+			'INVALID_INPUT',
+			`${field} must be a whole number between 0 and ${maximum}.`,
+		);
+	}
+	return value;
+}

package/modules/metering/src/settings.ts

@@ -0,0 +1,47 @@
+import {
+	defineModuleSettings,
+	PLATFORM_SETTINGS_TENANT,
+	type ModuleSettingsRuntime,
+} from '@flowdular/sdk/kernel';
+import { WARNING_PERCENT_RANGE } from './services/metering-service.ts';
+
+export const METERING_MODULE_ID = 'metering.core';
+
+/** The share of a limit the owners are notified at, before it refuses. */
+export const DEFAULT_WARNING_PERCENT = 80;
+
+export const METERING_MODULE_SETTINGS = defineModuleSettings({
+	moduleId: METERING_MODULE_ID,
+	settings: {
+		warningPercent: {
+			type: 'number',
+			defaultValue: DEFAULT_WARNING_PERCENT,
+			min: WARNING_PERCENT_RANGE.minimum,
+			max: WARNING_PERCENT_RANGE.maximum,
+			visibility: 'shared',
+			client: false,
+			scope: 'platform',
+			labelKey: 'metering.settings.warningPercent.label',
+			label: 'Warning share of a limit (percent)',
+			descriptionKey: 'metering.settings.warningPercent.description',
+			description:
+				'Share of a monthly limit at which the workspace owners are notified, before the limit itself refuses.',
+		},
+	},
+});
+
+/* A setting read must never take a recording path down, so the accessor falls
+   back to the declared default when the runtime has not registered it yet. */
+export function meteringWarningPercent(
+	settings: ModuleSettingsRuntime,
+): number {
+	try {
+		return settings.get<number>(
+			PLATFORM_SETTINGS_TENANT,
+			METERING_MODULE_ID,
+			'warningPercent',
+		);
+	} catch {
+		return DEFAULT_WARNING_PERCENT;
+	}
+}

package/modules/metering/translations/en.json

@@ -0,0 +1,68 @@
+{
+	"navigation.usage": "Usage",
+	"navigation.usageDescription": "What this workspace consumed this month, meter by meter.",
+	"navigation.limits": "Limits",
+	"navigation.limitsDescription": "The monthly ceilings the deployment operator set for this workspace.",
+	"common.administration": "Administration",
+	"common.refresh": "Refresh",
+	"common.refreshing": "Refreshing…",
+	"common.filters": "Filters",
+	"common.accessDenied": "Access denied",
+	"common.notYet": "Not yet",
+	"kind.cumulative": "Cumulative",
+	"kind.gauge": "Gauge",
+	"usage.title": "Usage",
+	"usage.description": "Every meter a module reported for this workspace, with this month's total in UTC.",
+	"usage.denied": "You need the usage permission to see what this workspace consumed.",
+	"usage.note": "Owners are notified at {percent} percent of a limit and again when it is reached. Limits are set by the deployment operator.",
+	"usage.unlimited": "{used} used",
+	"usage.ofLimit": "{used} of {limit}",
+	"usage.column.key": "Meter",
+	"usage.column.label": "Name",
+	"usage.column.unit": "Unit",
+	"usage.column.kind": "Kind",
+	"usage.column.used": "This month",
+	"usage.table.title": "Meters",
+	"usage.table.count": "{count} meters",
+	"usage.table.caption": "Meters of this workspace",
+	"usage.table.loading": "Loading meters…",
+	"usage.search.label": "Search meters",
+	"usage.search.placeholder": "Meter key or name",
+	"usage.filter.module": "Module",
+	"usage.filter.allModules": "All modules",
+	"usage.empty.title": "Nothing metered yet",
+	"usage.empty.hint": "A meter appears here the first time a module reports usage for this workspace.",
+	"usage.emptyFiltered.title": "No meter matches",
+	"usage.emptyFiltered.hint": "Change the search or the module to widen the list.",
+	"usage.error.load": "The meters could not be loaded.",
+	"limits.title": "Limits",
+	"limits.description": "Monthly ceilings per meter. They are set by the deployment operator and refuse the operation once exhausted.",
+	"limits.denied": "You need the usage permission to see the limits of this workspace.",
+	"limits.note": "A workspace cannot change its own limit. The deployment operator sets one with metering limits set.",
+	"limits.column.meter": "Meter",
+	"limits.column.monthlyLimit": "Monthly limit",
+	"limits.column.used": "This month",
+	"limits.column.setBy": "Set by",
+	"limits.column.updatedAt": "Updated",
+	"limits.table.title": "Monthly limits",
+	"limits.table.count": "{count} limits",
+	"limits.table.caption": "Monthly meter limits of this workspace",
+	"limits.table.loading": "Loading limits…",
+	"limits.search.label": "Search limits",
+	"limits.search.placeholder": "Meter key",
+	"limits.empty.title": "No limit set",
+	"limits.empty.hint": "Every meter of this workspace is unlimited until the deployment operator sets a ceiling.",
+	"limits.emptyFiltered.title": "No limit matches",
+	"limits.emptyFiltered.hint": "Change the search to widen the list.",
+	"limits.error.load": "The limits could not be loaded.",
+	"widget.unlimited": "No limit set",
+	"widget.share": "{percent}% of the limit, {usage}",
+	"widget.attention": "Attention",
+	"widget.link": "Open usage",
+	"error.request": "The request failed.",
+	"error.code.INVALID_INPUT": "The request was not accepted. Check the meter and the date range.",
+	"error.code.METER_NOT_DECLARED": "No composed module declares this meter.",
+	"settings.warningPercent.label": "Warning share of a limit (percent)",
+	"settings.warningPercent.description": "Share of a monthly limit at which the workspace owners are notified, before the limit itself refuses.",
+	"report.usage.label": "Usage this month"
+}