@contractspec/lib.metering 3.7.16 → 3.7.18

package/dist/node/index.js

@@ -1,1180 +1,7 @@
-// src/aggregation/index.ts
-function getPeriodStart(date, periodType) {
-  const d = new Date(date);
-  switch (periodType) {
-    case "HOURLY":
-      d.setMinutes(0, 0, 0);
-      return d;
-    case "DAILY":
-      d.setHours(0, 0, 0, 0);
-      return d;
-    case "WEEKLY": {
-      d.setHours(0, 0, 0, 0);
-      const day = d.getDay();
-      d.setDate(d.getDate() - day);
-      return d;
-    }
-    case "MONTHLY":
-      d.setHours(0, 0, 0, 0);
-      d.setDate(1);
-      return d;
-    case "YEARLY":
-      d.setHours(0, 0, 0, 0);
-      d.setMonth(0, 1);
-      return d;
-  }
-}
-function getPeriodEnd(date, periodType) {
-  const start = getPeriodStart(date, periodType);
-  switch (periodType) {
-    case "HOURLY":
-      return new Date(start.getTime() + 60 * 60 * 1000);
-    case "DAILY":
-      return new Date(start.getTime() + 24 * 60 * 60 * 1000);
-    case "WEEKLY":
-      return new Date(start.getTime() + 7 * 24 * 60 * 60 * 1000);
-    case "MONTHLY": {
-      const end = new Date(start);
-      end.setMonth(end.getMonth() + 1);
-      return end;
-    }
-    case "YEARLY": {
-      const end = new Date(start);
-      end.setFullYear(end.getFullYear() + 1);
-      return end;
-    }
-  }
-}
-function formatPeriodKey(date, periodType) {
-  const start = getPeriodStart(date, periodType);
-  const year = start.getFullYear();
-  const month = String(start.getMonth() + 1).padStart(2, "0");
-  const day = String(start.getDate()).padStart(2, "0");
-  const hour = String(start.getHours()).padStart(2, "0");
-  switch (periodType) {
-    case "HOURLY":
-      return `${year}-${month}-${day}T${hour}`;
-    case "DAILY":
-      return `${year}-${month}-${day}`;
-    case "WEEKLY":
-      return `${year}-W${getWeekNumber(start)}`;
-    case "MONTHLY":
-      return `${year}-${month}`;
-    case "YEARLY":
-      return `${year}`;
-  }
-}
-function getWeekNumber(date) {
-  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
-  const dayNum = d.getUTCDay() || 7;
-  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
-  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
-  const weekNum = Math.ceil(((d.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
-  return String(weekNum).padStart(2, "0");
-}
-
-class UsageAggregator {
-  storage;
-  batchSize;
-  constructor(options) {
-    this.storage = options.storage;
-    this.batchSize = options.batchSize || 1000;
-  }
-  async aggregate(params) {
-    const { periodType, periodStart, metricKey } = params;
-    const periodEnd = params.periodEnd || getPeriodEnd(periodStart, periodType);
-    const result = {
-      periodType,
-      periodStart,
-      periodEnd,
-      recordsProcessed: 0,
-      summariesCreated: 0,
-      summariesUpdated: 0,
-      errors: []
-    };
-    const records = await this.storage.getUnaggregatedRecords({
-      metricKey,
-      periodStart,
-      periodEnd,
-      limit: this.batchSize
-    });
-    if (records.length === 0) {
-      return result;
-    }
-    const groups = this.groupRecords(records, periodType);
-    for (const [groupKey, groupRecords] of groups.entries()) {
-      try {
-        await this.aggregateGroup(groupKey, groupRecords, periodType, result);
-      } catch (error) {
-        const [metricKey2, subjectType, subjectId] = groupKey.split("::");
-        result.errors.push({
-          metricKey: metricKey2 ?? "unknown",
-          subjectType: subjectType ?? "unknown",
-          subjectId: subjectId ?? "unknown",
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-    const recordIds = records.map((r) => r.id);
-    await this.storage.markRecordsAggregated(recordIds, new Date);
-    result.recordsProcessed = records.length;
-    return result;
-  }
-  groupRecords(records, periodType) {
-    const groups = new Map;
-    for (const record of records) {
-      const periodKey = formatPeriodKey(record.timestamp, periodType);
-      const groupKey = `${record.metricKey}::${record.subjectType}::${record.subjectId}::${periodKey}`;
-      const existing = groups.get(groupKey) || [];
-      existing.push(record);
-      groups.set(groupKey, existing);
-    }
-    return groups;
-  }
-  async aggregateGroup(groupKey, records, periodType, result) {
-    const [metricKey, subjectType, subjectId] = groupKey.split("::");
-    if (!metricKey || !subjectType || !subjectId || records.length === 0) {
-      return;
-    }
-    const firstRecord = records[0];
-    if (!firstRecord)
-      return;
-    const periodStart = getPeriodStart(firstRecord.timestamp, periodType);
-    const periodEnd = getPeriodEnd(firstRecord.timestamp, periodType);
-    const metric = await this.storage.getMetric(metricKey);
-    const aggregationType = metric?.aggregationType || "SUM";
-    const quantities = records.map((r) => r.quantity);
-    const aggregated = this.calculateAggregation(quantities, aggregationType);
-    await this.storage.upsertSummary({
-      metricKey,
-      subjectType,
-      subjectId,
-      periodType,
-      periodStart,
-      periodEnd,
-      totalQuantity: aggregated.total,
-      recordCount: records.length,
-      minQuantity: aggregated.min,
-      maxQuantity: aggregated.max,
-      avgQuantity: aggregated.avg
-    });
-    result.summariesCreated++;
-  }
-  calculateAggregation(quantities, aggregationType) {
-    if (quantities.length === 0) {
-      return { total: 0, min: 0, max: 0, avg: 0 };
-    }
-    const min = Math.min(...quantities);
-    const max = Math.max(...quantities);
-    const sum = quantities.reduce((a, b) => a + b, 0);
-    const avg = sum / quantities.length;
-    const count = quantities.length;
-    let total;
-    switch (aggregationType) {
-      case "COUNT":
-        total = count;
-        break;
-      case "SUM":
-        total = sum;
-        break;
-      case "AVG":
-        total = avg;
-        break;
-      case "MAX":
-        total = max;
-        break;
-      case "MIN":
-        total = min;
-        break;
-      case "LAST":
-        total = quantities[quantities.length - 1] ?? 0;
-        break;
-      default:
-        total = sum;
-    }
-    return { total, min, max, avg };
-  }
-}
-
-class InMemoryUsageStorage {
-  records = [];
-  summaries = new Map;
-  metrics = new Map;
-  addRecord(record) {
-    this.records.push(record);
-  }
-  addMetric(metric) {
-    this.metrics.set(metric.key, metric);
-  }
-  async getUnaggregatedRecords(options) {
-    let records = this.records.filter((r) => {
-      const inPeriod = r.timestamp >= options.periodStart && r.timestamp < options.periodEnd;
-      const matchesMetric = !options.metricKey || r.metricKey === options.metricKey;
-      return inPeriod && matchesMetric;
-    });
-    if (options.limit) {
-      records = records.slice(0, options.limit);
-    }
-    return records;
-  }
-  async markRecordsAggregated(recordIds) {
-    this.records = this.records.filter((r) => !recordIds.includes(r.id));
-  }
-  async upsertSummary(summary) {
-    const key = `${summary.metricKey}::${summary.subjectType}::${summary.subjectId}::${summary.periodType}::${summary.periodStart.toISOString()}`;
-    const existing = this.summaries.get(key);
-    if (existing) {
-      existing.totalQuantity += summary.totalQuantity;
-      existing.recordCount += summary.recordCount;
-      if (summary.minQuantity !== undefined) {
-        existing.minQuantity = Math.min(existing.minQuantity ?? Infinity, summary.minQuantity);
-      }
-      if (summary.maxQuantity !== undefined) {
-        existing.maxQuantity = Math.max(existing.maxQuantity ?? -Infinity, summary.maxQuantity);
-      }
-      return existing;
-    }
-    const newSummary = {
-      id: `summary-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-      ...summary
-    };
-    this.summaries.set(key, newSummary);
-    return newSummary;
-  }
-  async getMetric(key) {
-    return this.metrics.get(key) || null;
-  }
-  async listMetrics() {
-    return Array.from(this.metrics.values());
-  }
-  getSummaries() {
-    return Array.from(this.summaries.values());
-  }
-  clear() {
-    this.records = [];
-    this.summaries.clear();
-    this.metrics.clear();
-  }
-}
-
-// src/analytics/posthog-metering-reader.ts
-class PosthogMeteringReader {
-  reader;
-  eventPrefix;
-  constructor(reader, options = {}) {
-    this.reader = reader;
-    this.eventPrefix = options.eventPrefix ?? "metering";
-  }
-  async getUsageByMetric(input) {
-    const result = await this.queryHogQL({
-      query: [
-        "select",
-        "  properties.recordId as recordId,",
-        "  properties.metricKey as metricKey,",
-        "  properties.subjectType as subjectType,",
-        "  distinct_id as subjectId,",
-        "  properties.quantity as quantity,",
-        "  properties.source as source,",
-        "  timestamp as timestamp",
-        "from events",
-        `where ${buildUsageWhereClause(this.eventPrefix, input)}`,
-        "order by timestamp desc",
-        `limit ${input.limit ?? 200}`
-      ].join(`
-`),
-      values: buildUsageValues(input)
-    });
-    return mapUsageRecords(result);
-  }
-  async getUsageSummary(input) {
-    const result = await this.queryHogQL({
-      query: [
-        "select",
-        "  properties.summaryId as summaryId,",
-        "  properties.metricKey as metricKey,",
-        "  properties.subjectType as subjectType,",
-        "  distinct_id as subjectId,",
-        "  properties.periodType as periodType,",
-        "  properties.periodStart as periodStart,",
-        "  properties.periodEnd as periodEnd,",
-        "  properties.totalQuantity as totalQuantity,",
-        "  properties.recordCount as recordCount,",
-        "  timestamp as aggregatedAt",
-        "from events",
-        `where ${buildSummaryWhereClause(this.eventPrefix, input)}`,
-        "order by timestamp desc",
-        `limit ${input.limit ?? 200}`
-      ].join(`
-`),
-      values: buildSummaryValues(input)
-    });
-    return mapUsageSummaries(result);
-  }
-  async getUsageTrend(input) {
-    const result = await this.queryHogQL({
-      query: [
-        "select",
-        `  ${bucketExpression(input.bucket)} as bucketStart,`,
-        "  sum(properties.quantity) as totalQuantity,",
-        "  count() as recordCount",
-        "from events",
-        `where ${buildUsageWhereClause(this.eventPrefix, input)}`,
-        "group by bucketStart",
-        "order by bucketStart asc"
-      ].join(`
-`),
-      values: buildUsageValues(input)
-    });
-    return mapUsageTrend(result);
-  }
-  async queryHogQL(input) {
-    if (!this.reader.queryHogQL) {
-      throw new Error("Analytics reader does not support HogQL queries.");
-    }
-    return this.reader.queryHogQL(input);
-  }
-}
-function buildUsageWhereClause(eventPrefix, input) {
-  const clauses = [
-    `event = '${eventPrefix}.usage_recorded'`,
-    `properties.metricKey = {metricKey}`
-  ];
-  if (input.subjectId) {
-    clauses.push("distinct_id = {subjectId}");
-  }
-  if (input.dateRange?.from) {
-    clauses.push("timestamp >= {dateFrom}");
-  }
-  if (input.dateRange?.to) {
-    clauses.push("timestamp < {dateTo}");
-  }
-  return clauses.join(" and ");
-}
-function buildSummaryWhereClause(eventPrefix, input) {
-  const clauses = [
-    `event = '${eventPrefix}.usage_aggregated'`,
-    `properties.metricKey = {metricKey}`
-  ];
-  if (input.subjectId) {
-    clauses.push("distinct_id = {subjectId}");
-  }
-  if (input.periodType) {
-    clauses.push("properties.periodType = {periodType}");
-  }
-  if (input.dateRange?.from) {
-    clauses.push("timestamp >= {dateFrom}");
-  }
-  if (input.dateRange?.to) {
-    clauses.push("timestamp < {dateTo}");
-  }
-  return clauses.join(" and ");
-}
-function buildUsageValues(input) {
-  return {
-    metricKey: input.metricKey,
-    subjectId: input.subjectId,
-    dateFrom: toIsoString(input.dateRange?.from),
-    dateTo: toIsoString(input.dateRange?.to)
-  };
-}
-function buildSummaryValues(input) {
-  return {
-    metricKey: input.metricKey,
-    subjectId: input.subjectId,
-    periodType: input.periodType,
-    dateFrom: toIsoString(input.dateRange?.from),
-    dateTo: toIsoString(input.dateRange?.to)
-  };
-}
-function bucketExpression(bucket) {
-  switch (bucket) {
-    case "hour":
-      return "toStartOfHour(timestamp)";
-    case "week":
-      return "toStartOfWeek(timestamp)";
-    case "month":
-      return "toStartOfMonth(timestamp)";
-    case "day":
-    default:
-      return "toStartOfDay(timestamp)";
-  }
-}
-function mapUsageRecords(result) {
-  const rows = mapRows(result);
-  return rows.flatMap((row) => {
-    const metricKey = asString(row.metricKey);
-    const subjectType = asString(row.subjectType);
-    const subjectId = asString(row.subjectId);
-    const timestamp = asDate(row.timestamp);
-    if (!metricKey || !subjectType || !subjectId || !timestamp) {
-      return [];
-    }
-    return [
-      {
-        recordId: asOptionalString(row.recordId),
-        metricKey,
-        subjectType,
-        subjectId,
-        quantity: asNumber(row.quantity),
-        source: asOptionalString(row.source),
-        timestamp
-      }
-    ];
-  });
-}
-function mapUsageSummaries(result) {
-  const rows = mapRows(result);
-  return rows.flatMap((row) => {
-    const metricKey = asString(row.metricKey);
-    const subjectType = asString(row.subjectType);
-    const subjectId = asString(row.subjectId);
-    const periodType = asString(row.periodType);
-    const periodStart = asDate(row.periodStart);
-    const periodEnd = asDate(row.periodEnd);
-    const aggregatedAt = asDate(row.aggregatedAt);
-    if (!metricKey || !subjectType || !subjectId || !periodType || !periodStart || !periodEnd || !aggregatedAt) {
-      return [];
-    }
-    return [
-      {
-        summaryId: asOptionalString(row.summaryId),
-        metricKey,
-        subjectType,
-        subjectId,
-        periodType,
-        periodStart,
-        periodEnd,
-        totalQuantity: asNumber(row.totalQuantity),
-        recordCount: asNumber(row.recordCount),
-        aggregatedAt
-      }
-    ];
-  });
-}
-function mapUsageTrend(result) {
-  const rows = mapRows(result);
-  return rows.flatMap((row) => {
-    const bucketStart = asString(row.bucketStart);
-    if (!bucketStart)
-      return [];
-    return [
-      {
-        bucketStart,
-        totalQuantity: asNumber(row.totalQuantity),
-        recordCount: asNumber(row.recordCount)
-      }
-    ];
-  });
-}
-function mapRows(result) {
-  if (!Array.isArray(result.results) || !Array.isArray(result.columns)) {
-    return [];
-  }
-  const columns = result.columns;
-  return result.results.flatMap((row) => {
-    if (!Array.isArray(row))
-      return [];
-    const record = {};
-    columns.forEach((column, index) => {
-      record[column] = row[index];
-    });
-    return [record];
-  });
-}
-function asString(value) {
-  if (typeof value === "string" && value.trim())
-    return value;
-  if (typeof value === "number")
-    return String(value);
-  return null;
-}
-function asOptionalString(value) {
-  if (typeof value === "string")
-    return value;
-  if (typeof value === "number")
-    return String(value);
-  return;
-}
-function asNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value))
-    return value;
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed))
-      return parsed;
-  }
-  return 0;
-}
-function asDate(value) {
-  if (value instanceof Date)
-    return value;
-  if (typeof value === "string" || typeof value === "number") {
-    const date = new Date(value);
-    if (!Number.isNaN(date.getTime()))
-      return date;
-  }
-  return null;
-}
-function toIsoString(value) {
-  if (!value)
-    return;
-  return typeof value === "string" ? value : value.toISOString();
-}
-
-// src/analytics/posthog-metering.ts
-class PosthogMeteringReporter {
-  provider;
-  eventPrefix;
-  includeSource;
-  constructor(provider, options = {}) {
-    this.provider = provider;
-    this.eventPrefix = options.eventPrefix ?? "metering";
-    this.includeSource = options.includeSource ?? true;
-  }
-  async captureUsageRecorded(record) {
-    await this.provider.capture({
-      distinctId: record.subjectId,
-      event: `${this.eventPrefix}.usage_recorded`,
-      timestamp: record.timestamp,
-      properties: {
-        recordId: record.recordId ?? null,
-        metricKey: record.metricKey,
-        subjectType: record.subjectType,
-        quantity: record.quantity,
-        ...this.includeSource && record.source ? { source: record.source } : {}
-      }
-    });
-  }
-  async captureUsageAggregated(summary) {
-    await this.provider.capture({
-      distinctId: summary.subjectId,
-      event: `${this.eventPrefix}.usage_aggregated`,
-      timestamp: summary.aggregatedAt,
-      properties: {
-        summaryId: summary.summaryId ?? null,
-        metricKey: summary.metricKey,
-        subjectType: summary.subjectType,
-        periodType: summary.periodType,
-        periodStart: summary.periodStart.toISOString(),
-        periodEnd: summary.periodEnd.toISOString(),
-        totalQuantity: summary.totalQuantity,
-        recordCount: summary.recordCount
-      }
-    });
-  }
-}
-
-// src/contracts/index.ts
-import { defineCommand, defineQuery } from "@contractspec/lib.contracts-spec";
-import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
-var OWNERS = ["platform.metering"];
-var MetricDefinitionModel = defineSchemaModel({
-  name: "MetricDefinition",
-  description: "Represents a metric definition",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    key: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    unit: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    aggregationType: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false
-    },
-    resetPeriod: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    category: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    isActive: { type: ScalarTypeEnum.Boolean(), isOptional: false },
-    orgId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var UsageRecordModel = defineSchemaModel({
-  name: "UsageRecord",
-  description: "Represents a usage record",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    metricKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    quantity: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
-    source: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    resourceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    resourceType: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    metadata: { type: ScalarTypeEnum.JSON(), isOptional: true },
-    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var UsageSummaryModel = defineSchemaModel({
-  name: "UsageSummary",
-  description: "Represents aggregated usage",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    metricKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    periodType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    periodStart: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-    periodEnd: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-    totalQuantity: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
-    recordCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    minQuantity: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
-    maxQuantity: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
-    avgQuantity: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true }
-  }
-});
-var UsageThresholdModel = defineSchemaModel({
-  name: "UsageThreshold",
-  description: "Represents a usage threshold",
-  fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    metricKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    subjectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    threshold: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
-    warnThreshold: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
-    periodType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    action: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    currentValue: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
-    isActive: { type: ScalarTypeEnum.Boolean(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
-  }
-});
-var DefineMetricInput = defineSchemaModel({
-  name: "DefineMetricInput",
-  description: "Input for defining a metric",
-  fields: {
-    key: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    unit: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    aggregationType: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    resetPeriod: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    category: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    orgId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    metadata: { type: ScalarTypeEnum.JSON(), isOptional: true }
-  }
-});
-var UpdateMetricInput = defineSchemaModel({
-  name: "UpdateMetricInput",
-  description: "Input for updating a metric",
-  fields: {
-    metricId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    category: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    isActive: { type: ScalarTypeEnum.Boolean(), isOptional: true },
-    metadata: { type: ScalarTypeEnum.JSON(), isOptional: true }
-  }
-});
-var DeleteMetricInput = defineSchemaModel({
-  name: "DeleteMetricInput",
-  description: "Input for deleting a metric",
-  fields: {
-    metricId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false }
-  }
-});
-var GetMetricInput = defineSchemaModel({
-  name: "GetMetricInput",
-  description: "Input for getting a metric",
-  fields: {
-    key: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    orgId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
-  }
-});
-var ListMetricsInput = defineSchemaModel({
-  name: "ListMetricsInput",
-  description: "Input for listing metrics",
-  fields: {
-    orgId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    category: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    isActive: { type: ScalarTypeEnum.Boolean(), isOptional: true },
-    limit: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
-    offset: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true }
-  }
-});
-var ListMetricsOutput = defineSchemaModel({
-  name: "ListMetricsOutput",
-  description: "Output for listing metrics",
-  fields: {
-    metrics: { type: MetricDefinitionModel, isArray: true, isOptional: false },
-    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
-  }
-});
-var RecordUsageInput = defineSchemaModel({
-  name: "RecordUsageInput",
-  description: "Input for recording usage",
-  fields: {
-    metricKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    quantity: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: true },
-    source: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    resourceId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    resourceType: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    metadata: { type: ScalarTypeEnum.JSON(), isOptional: true },
-    idempotencyKey: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    }
-  }
-});
-var RecordBatchUsageInput = defineSchemaModel({
-  name: "RecordBatchUsageInput",
-  description: "Input for recording batch usage",
-  fields: {
-    records: { type: RecordUsageInput, isArray: true, isOptional: false }
-  }
-});
-var RecordBatchUsageOutput = defineSchemaModel({
-  name: "RecordBatchUsageOutput",
-  description: "Output for recording batch usage",
-  fields: {
-    recordedCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    skippedCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    recordIds: { type: ScalarTypeEnum.JSON(), isOptional: false }
-  }
-});
-var GetUsageInput = defineSchemaModel({
-  name: "GetUsageInput",
-  description: "Input for getting usage",
-  fields: {
-    metricKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    startDate: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-    endDate: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-    limit: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
-    offset: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true }
-  }
-});
-var GetUsageOutput = defineSchemaModel({
-  name: "GetUsageOutput",
-  description: "Output for getting usage",
-  fields: {
-    records: { type: UsageRecordModel, isArray: true, isOptional: false },
-    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    totalQuantity: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false }
-  }
-});
-var GetUsageSummaryInput = defineSchemaModel({
-  name: "GetUsageSummaryInput",
-  description: "Input for getting usage summary",
-  fields: {
-    metricKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    periodType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    startDate: { type: ScalarTypeEnum.DateTime(), isOptional: false },
-    endDate: { type: ScalarTypeEnum.DateTime(), isOptional: true }
-  }
-});
-var GetUsageSummaryOutput = defineSchemaModel({
-  name: "GetUsageSummaryOutput",
-  description: "Output for getting usage summary",
-  fields: {
-    summaries: { type: UsageSummaryModel, isArray: true, isOptional: false },
-    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
-  }
-});
-var CreateThresholdInput = defineSchemaModel({
-  name: "CreateThresholdInput",
-  description: "Input for creating a threshold",
-  fields: {
-    metricKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    subjectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    threshold: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
-    warnThreshold: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
-    periodType: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    action: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    notifyEmails: { type: ScalarTypeEnum.JSON(), isOptional: true },
-    notifyWebhook: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
-  }
-});
-var UpdateThresholdInput = defineSchemaModel({
-  name: "UpdateThresholdInput",
-  description: "Input for updating a threshold",
-  fields: {
-    thresholdId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    threshold: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
-    warnThreshold: { type: ScalarTypeEnum.Float_unsecure(), isOptional: true },
-    action: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    notifyEmails: { type: ScalarTypeEnum.JSON(), isOptional: true },
-    notifyWebhook: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    isActive: { type: ScalarTypeEnum.Boolean(), isOptional: true }
-  }
-});
-var DeleteThresholdInput = defineSchemaModel({
-  name: "DeleteThresholdInput",
-  description: "Input for deleting a threshold",
-  fields: {
-    thresholdId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false }
-  }
-});
-var ListThresholdsInput = defineSchemaModel({
-  name: "ListThresholdsInput",
-  description: "Input for listing thresholds",
-  fields: {
-    metricKey: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    subjectType: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    subjectId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    isActive: { type: ScalarTypeEnum.Boolean(), isOptional: true }
-  }
-});
-var ListThresholdsOutput = defineSchemaModel({
-  name: "ListThresholdsOutput",
-  description: "Output for listing thresholds",
-  fields: {
-    thresholds: { type: UsageThresholdModel, isArray: true, isOptional: false },
-    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
-  }
-});
-var SuccessOutput = defineSchemaModel({
-  name: "SuccessOutput",
-  description: "Generic success output",
-  fields: {
-    success: { type: ScalarTypeEnum.Boolean(), isOptional: false }
-  }
-});
-var DefineMetricContract = defineCommand({
-  meta: {
-    key: "metric.define",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "metric", "define"],
-    description: "Define a new usage metric.",
-    goal: "Create a new metric for tracking usage.",
-    context: "Called when setting up metering."
-  },
-  io: {
-    input: DefineMetricInput,
-    output: MetricDefinitionModel,
-    errors: {
-      METRIC_KEY_EXISTS: {
-        description: "Metric key already exists",
-        http: 409,
-        gqlCode: "METRIC_KEY_EXISTS",
-        when: "A metric with this key already exists"
-      }
-    }
-  },
-  policy: {
-    auth: "admin"
-  }
-});
-var UpdateMetricContract = defineCommand({
-  meta: {
-    key: "metric.update",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "metric", "update"],
-    description: "Update a metric definition.",
-    goal: "Modify metric configuration.",
-    context: "Called when updating metric settings."
-  },
-  io: {
-    input: UpdateMetricInput,
-    output: MetricDefinitionModel,
-    errors: {
-      METRIC_NOT_FOUND: {
-        description: "Metric does not exist",
-        http: 404,
-        gqlCode: "METRIC_NOT_FOUND",
-        when: "Metric ID is invalid"
-      }
-    }
-  },
-  policy: {
-    auth: "admin"
-  }
-});
-var DeleteMetricContract = defineCommand({
-  meta: {
-    key: "metric.delete",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "metric", "delete"],
-    description: "Delete a metric definition.",
-    goal: "Remove a metric and its data.",
-    context: "Called when removing a metric."
-  },
-  io: {
-    input: DeleteMetricInput,
-    output: SuccessOutput,
-    errors: {
-      METRIC_NOT_FOUND: {
-        description: "Metric does not exist",
-        http: 404,
-        gqlCode: "METRIC_NOT_FOUND",
-        when: "Metric ID is invalid"
-      }
-    }
-  },
-  policy: {
-    auth: "admin"
-  }
-});
-var GetMetricContract = defineQuery({
-  meta: {
-    key: "metric.get",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "metric", "get"],
-    description: "Get a metric by key.",
-    goal: "Retrieve metric definition.",
-    context: "Called to inspect metric details."
-  },
-  io: {
-    input: GetMetricInput,
-    output: MetricDefinitionModel,
-    errors: {
-      METRIC_NOT_FOUND: {
-        description: "Metric does not exist",
-        http: 404,
-        gqlCode: "METRIC_NOT_FOUND",
-        when: "Metric key is invalid"
-      }
-    }
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var ListMetricsContract = defineQuery({
-  meta: {
-    key: "metric.list",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "metric", "list"],
-    description: "List all metrics.",
-    goal: "View configured metrics.",
-    context: "Called to browse metrics."
-  },
-  io: {
-    input: ListMetricsInput,
-    output: ListMetricsOutput
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var RecordUsageContract = defineCommand({
-  meta: {
-    key: "usage.record",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "usage", "record"],
-    description: "Record a usage event.",
-    goal: "Track usage for billing and monitoring.",
-    context: "Called when usage occurs."
-  },
-  io: {
-    input: RecordUsageInput,
-    output: UsageRecordModel,
-    errors: {
-      METRIC_NOT_FOUND: {
-        description: "Metric does not exist",
-        http: 404,
-        gqlCode: "METRIC_NOT_FOUND",
-        when: "Metric key is invalid"
-      },
-      DUPLICATE_RECORD: {
-        description: "Record already exists",
-        http: 409,
-        gqlCode: "DUPLICATE_RECORD",
-        when: "Idempotency key already used"
-      }
-    }
-  },
-  policy: {
-    auth: "admin"
-  }
-});
-var RecordBatchUsageContract = defineCommand({
-  meta: {
-    key: "usage.recordBatch",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "usage", "batch"],
-    description: "Record multiple usage events.",
-    goal: "Efficiently track bulk usage.",
-    context: "Called for batch processing."
-  },
-  io: {
-    input: RecordBatchUsageInput,
-    output: RecordBatchUsageOutput
-  },
-  policy: {
-    auth: "admin"
-  }
-});
-var GetUsageContract = defineQuery({
-  meta: {
-    key: "usage.get",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "usage", "get"],
-    description: "Get usage records for a subject.",
-    goal: "View detailed usage history.",
-    context: "Called to analyze usage."
-  },
-  io: {
-    input: GetUsageInput,
-    output: GetUsageOutput
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var GetUsageSummaryContract = defineQuery({
-  meta: {
-    key: "usage.getSummary",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "usage", "summary"],
-    description: "Get aggregated usage summary.",
-    goal: "View usage totals for billing.",
-    context: "Called for billing and reporting."
-  },
-  io: {
-    input: GetUsageSummaryInput,
-    output: GetUsageSummaryOutput
-  },
-  policy: {
-    auth: "user"
-  }
-});
-var CreateThresholdContract = defineCommand({
-  meta: {
-    key: "threshold.create",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "threshold", "create"],
-    description: "Create a usage threshold.",
-    goal: "Set up usage limits and alerts.",
-    context: "Called when configuring limits."
-  },
-  io: {
-    input: CreateThresholdInput,
-    output: UsageThresholdModel,
-    errors: {
-      METRIC_NOT_FOUND: {
-        description: "Metric does not exist",
-        http: 404,
-        gqlCode: "METRIC_NOT_FOUND",
-        when: "Metric key is invalid"
-      }
-    }
-  },
-  policy: {
-    auth: "admin"
-  }
-});
-var UpdateThresholdContract = defineCommand({
-  meta: {
-    key: "threshold.update",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "threshold", "update"],
-    description: "Update a threshold.",
-    goal: "Modify threshold configuration.",
-    context: "Called when adjusting limits."
-  },
-  io: {
-    input: UpdateThresholdInput,
-    output: UsageThresholdModel,
-    errors: {
-      THRESHOLD_NOT_FOUND: {
-        description: "Threshold does not exist",
-        http: 404,
-        gqlCode: "THRESHOLD_NOT_FOUND",
-        when: "Threshold ID is invalid"
-      }
-    }
-  },
-  policy: {
-    auth: "admin"
-  }
-});
-var DeleteThresholdContract = defineCommand({
-  meta: {
-    key: "threshold.delete",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "threshold", "delete"],
-    description: "Delete a threshold.",
-    goal: "Remove a usage threshold.",
-    context: "Called when removing limits."
-  },
-  io: {
-    input: DeleteThresholdInput,
-    output: SuccessOutput,
-    errors: {
-      THRESHOLD_NOT_FOUND: {
-        description: "Threshold does not exist",
-        http: 404,
-        gqlCode: "THRESHOLD_NOT_FOUND",
-        when: "Threshold ID is invalid"
-      }
-    }
-  },
-  policy: {
-    auth: "admin"
-  }
-});
-var ListThresholdsContract = defineQuery({
-  meta: {
-    key: "threshold.list",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["metering", "threshold", "list"],
-    description: "List usage thresholds.",
-    goal: "View configured limits.",
-    context: "Called to browse thresholds."
-  },
-  io: {
-    input: ListThresholdsInput,
-    output: ListThresholdsOutput
-  },
-  policy: {
-    auth: "user"
-  }
-});
-
-// src/docs/metering.docblock.ts
-import { registerDocBlocks } from "@contractspec/lib.contracts-spec/docs";
-var meteringDocBlocks = [
-  {
-    id: "docs.metering.usage",
-    title: "Usage Metering & Billing Core",
-    summary: "Reusable usage/metering layer with metric definitions, usage ingestion, aggregation, thresholds, and alerts for billing or quotas.",
-    kind: "reference",
-    visibility: "public",
-    route: "/docs/metering/usage",
-    tags: ["metering", "usage", "billing", "quotas"],
-    body: `## Capabilities
+function Z(t,I){let g=new Date(t);switch(I){case"HOURLY":return g.setMinutes(0,0,0),g;case"DAILY":return g.setHours(0,0,0,0),g;case"WEEKLY":{g.setHours(0,0,0,0);let r=g.getDay();return g.setDate(g.getDate()-r),g}case"MONTHLY":return g.setHours(0,0,0,0),g.setDate(1),g;case"YEARLY":return g.setHours(0,0,0,0),g.setMonth(0,1),g}}function N(t,I){let g=Z(t,I);switch(I){case"HOURLY":return new Date(g.getTime()+3600000);case"DAILY":return new Date(g.getTime()+86400000);case"WEEKLY":return new Date(g.getTime()+604800000);case"MONTHLY":{let r=new Date(g);return r.setMonth(r.getMonth()+1),r}case"YEARLY":{let r=new Date(g);return r.setFullYear(r.getFullYear()+1),r}}}function e(t,I){let g=Z(t,I),r=g.getFullYear(),o=String(g.getMonth()+1).padStart(2,"0"),A=String(g.getDate()).padStart(2,"0"),Q=String(g.getHours()).padStart(2,"0");switch(I){case"HOURLY":return`${r}-${o}-${A}T${Q}`;case"DAILY":return`${r}-${o}-${A}`;case"WEEKLY":return`${r}-W${d(g)}`;case"MONTHLY":return`${r}-${o}`;case"YEARLY":return`${r}`}}function d(t){let I=new Date(Date.UTC(t.getFullYear(),t.getMonth(),t.getDate())),g=I.getUTCDay()||7;I.setUTCDate(I.getUTCDate()+4-g);let r=new Date(Date.UTC(I.getUTCFullYear(),0,1)),o=Math.ceil(((I.getTime()-r.getTime())/86400000+1)/7);return String(o).padStart(2,"0")}class T{storage;batchSize;constructor(t){this.storage=t.storage,this.batchSize=t.batchSize||1000}async aggregate(t){let{periodType:I,periodStart:g,metricKey:r}=t,o=t.periodEnd||N(g,I),A={periodType:I,periodStart:g,periodEnd:o,recordsProcessed:0,summariesCreated:0,summariesUpdated:0,errors:[]},Q=await this.storage.getUnaggregatedRecords({metricKey:r,periodStart:g,periodEnd:o,limit:this.batchSize});if(Q.length===0)return A;let k=this.groupRecords(Q,I);for(let[$,O]of k.entries())try{await this.aggregateGroup($,O,I,A)}catch(U){let[X,L,Y]=$.split("::");A.errors.push({metricKey:X??"unknown",subjectType:L??"unknown",subjectId:Y??"unknown",error:U instanceof Error?U.message:String(U)})}let _=Q.map(($)=>$.id);return await this.storage.markRecordsAggregated(_,new Date),A.recordsProcessed=Q.length,A}groupRecords(t,I){let g=new Map;for(let r of t){let o=e(r.timestamp,I),A=`${r.metricKey}::${r.subjectType}::${r.subjectId}::${o}`,Q=g.get(A)||[];Q.push(r),g.set(A,Q)}return g}async aggregateGroup(t,I,g,r){let[o,A,Q]=t.split("::");if(!o||!A||!Q||I.length===0)return;let k=I[0];if(!k)return;let _=Z(k.timestamp,g),$=N(k.timestamp,g),U=(await this.storage.getMetric(o))?.aggregationType||"SUM",X=I.map((Y)=>Y.quantity),L=this.calculateAggregation(X,U);await this.storage.upsertSummary({metricKey:o,subjectType:A,subjectId:Q,periodType:g,periodStart:_,periodEnd:$,totalQuantity:L.total,recordCount:I.length,minQuantity:L.min,maxQuantity:L.max,avgQuantity:L.avg}),r.summariesCreated++}calculateAggregation(t,I){if(t.length===0)return{total:0,min:0,max:0,avg:0};let g=Math.min(...t),r=Math.max(...t),o=t.reduce((_,$)=>_+$,0),A=o/t.length,Q=t.length,k;switch(I){case"COUNT":k=Q;break;case"SUM":k=o;break;case"AVG":k=A;break;case"MAX":k=r;break;case"MIN":k=g;break;case"LAST":k=t[t.length-1]??0;break;default:k=o}return{total:k,min:g,max:r,avg:A}}}class S{records=[];summaries=new Map;metrics=new Map;addRecord(t){this.records.push(t)}addMetric(t){this.metrics.set(t.key,t)}async getUnaggregatedRecords(t){let I=this.records.filter((g)=>{let r=g.timestamp>=t.periodStart&&g.timestamp<t.periodEnd,o=!t.metricKey||g.metricKey===t.metricKey;return r&&o});if(t.limit)I=I.slice(0,t.limit);return I}async markRecordsAggregated(t){this.records=this.records.filter((I)=>!t.includes(I.id))}async upsertSummary(t){let I=`${t.metricKey}::${t.subjectType}::${t.subjectId}::${t.periodType}::${t.periodStart.toISOString()}`,g=this.summaries.get(I);if(g){if(g.totalQuantity+=t.totalQuantity,g.recordCount+=t.recordCount,t.minQuantity!==void 0)g.minQuantity=Math.min(g.minQuantity??1/0,t.minQuantity);if(t.maxQuantity!==void 0)g.maxQuantity=Math.max(g.maxQuantity??-1/0,t.maxQuantity);return g}let r={id:`summary-${Date.now()}-${Math.random().toString(36).slice(2)}`,...t};return this.summaries.set(I,r),r}async getMetric(t){return this.metrics.get(t)||null}async listMetrics(){return Array.from(this.metrics.values())}getSummaries(){return Array.from(this.summaries.values())}clear(){this.records=[],this.summaries.clear(),this.metrics.clear()}}class m{reader;eventPrefix;constructor(t,I={}){this.reader=t,this.eventPrefix=I.eventPrefix??"metering"}async getUsageByMetric(t){let I=await this.queryHogQL({query:["select","  properties.recordId as recordId,","  properties.metricKey as metricKey,","  properties.subjectType as subjectType,","  distinct_id as subjectId,","  properties.quantity as quantity,","  properties.source as source,","  timestamp as timestamp","from events",`where ${W(this.eventPrefix,t)}`,"order by timestamp desc",`limit ${t.limit??200}`].join(`
+`),values:M(t)});return tt(I)}async getUsageSummary(t){let I=await this.queryHogQL({query:["select","  properties.summaryId as summaryId,","  properties.metricKey as metricKey,","  properties.subjectType as subjectType,","  distinct_id as subjectId,","  properties.periodType as periodType,","  properties.periodStart as periodStart,","  properties.periodEnd as periodEnd,","  properties.totalQuantity as totalQuantity,","  properties.recordCount as recordCount,","  timestamp as aggregatedAt","from events",`where ${E(this.eventPrefix,t)}`,"order by timestamp desc",`limit ${t.limit??200}`].join(`
+`),values:l(t)});return st(I)}async getUsageTrend(t){let I=await this.queryHogQL({query:["select",`  ${a(t.bucket)} as bucketStart,`,"  sum(properties.quantity) as totalQuantity,","  count() as recordCount","from events",`where ${W(this.eventPrefix,t)}`,"group by bucketStart","order by bucketStart asc"].join(`
+`),values:M(t)});return gt(I)}async queryHogQL(t){if(!this.reader.queryHogQL)throw Error("Analytics reader does not support HogQL queries.");return this.reader.queryHogQL(t)}}function W(t,I){let g=[`event = '${t}.usage_recorded'`,"properties.metricKey = {metricKey}"];if(I.subjectId)g.push("distinct_id = {subjectId}");if(I.dateRange?.from)g.push("timestamp >= {dateFrom}");if(I.dateRange?.to)g.push("timestamp < {dateTo}");return g.join(" and ")}function E(t,I){let g=[`event = '${t}.usage_aggregated'`,"properties.metricKey = {metricKey}"];if(I.subjectId)g.push("distinct_id = {subjectId}");if(I.periodType)g.push("properties.periodType = {periodType}");if(I.dateRange?.from)g.push("timestamp >= {dateFrom}");if(I.dateRange?.to)g.push("timestamp < {dateTo}");return g.join(" and ")}function M(t){return{metricKey:t.metricKey,subjectId:t.subjectId,dateFrom:z(t.dateRange?.from),dateTo:z(t.dateRange?.to)}}function l(t){return{metricKey:t.metricKey,subjectId:t.subjectId,periodType:t.periodType,dateFrom:z(t.dateRange?.from),dateTo:z(t.dateRange?.to)}}function a(t){switch(t){case"hour":return"toStartOfHour(timestamp)";case"week":return"toStartOfWeek(timestamp)";case"month":return"toStartOfMonth(timestamp)";case"day":default:return"toStartOfDay(timestamp)"}}function tt(t){return G(t).flatMap((g)=>{let r=D(g.metricKey),o=D(g.subjectType),A=D(g.subjectId),Q=i(g.timestamp);if(!r||!o||!A||!Q)return[];return[{recordId:v(g.recordId),metricKey:r,subjectType:o,subjectId:A,quantity:q(g.quantity),source:v(g.source),timestamp:Q}]})}function st(t){return G(t).flatMap((g)=>{let r=D(g.metricKey),o=D(g.subjectType),A=D(g.subjectId),Q=D(g.periodType),k=i(g.periodStart),_=i(g.periodEnd),$=i(g.aggregatedAt);if(!r||!o||!A||!Q||!k||!_||!$)return[];return[{summaryId:v(g.summaryId),metricKey:r,subjectType:o,subjectId:A,periodType:Q,periodStart:k,periodEnd:_,totalQuantity:q(g.totalQuantity),recordCount:q(g.recordCount),aggregatedAt:$}]})}function gt(t){return G(t).flatMap((g)=>{let r=D(g.bucketStart);if(!r)return[];return[{bucketStart:r,totalQuantity:q(g.totalQuantity),recordCount:q(g.recordCount)}]})}function G(t){if(!Array.isArray(t.results)||!Array.isArray(t.columns))return[];let I=t.columns;return t.results.flatMap((g)=>{if(!Array.isArray(g))return[];let r={};return I.forEach((o,A)=>{r[o]=g[A]}),[r]})}function D(t){if(typeof t==="string"&&t.trim())return t;if(typeof t==="number")return String(t);return null}function v(t){if(typeof t==="string")return t;if(typeof t==="number")return String(t);return}function q(t){if(typeof t==="number"&&Number.isFinite(t))return t;if(typeof t==="string"&&t.trim()){let I=Number(t);if(Number.isFinite(I))return I}return 0}function i(t){if(t instanceof Date)return t;if(typeof t==="string"||typeof t==="number"){let I=new Date(t);if(!Number.isNaN(I.getTime()))return I}return null}function z(t){if(!t)return;return typeof t==="string"?t:t.toISOString()}class bt{provider;eventPrefix;includeSource;constructor(t,I={}){this.provider=t,this.eventPrefix=I.eventPrefix??"metering",this.includeSource=I.includeSource??!0}async captureUsageRecorded(t){await this.provider.capture({distinctId:t.subjectId,event:`${this.eventPrefix}.usage_recorded`,timestamp:t.timestamp,properties:{recordId:t.recordId??null,metricKey:t.metricKey,subjectType:t.subjectType,quantity:t.quantity,...this.includeSource&&t.source?{source:t.source}:{}}})}async captureUsageAggregated(t){await this.provider.capture({distinctId:t.subjectId,event:`${this.eventPrefix}.usage_aggregated`,timestamp:t.aggregatedAt,properties:{summaryId:t.summaryId??null,metricKey:t.metricKey,subjectType:t.subjectType,periodType:t.periodType,periodStart:t.periodStart.toISOString(),periodEnd:t.periodEnd.toISOString(),totalQuantity:t.totalQuantity,recordCount:t.recordCount}})}}import{defineCommand as F,defineQuery as V}from"@contractspec/lib.contracts-spec";import{defineSchemaModel as R,ScalarTypeEnum as s}from"@contractspec/lib.schema";var P=["platform.metering"],B=R({name:"MetricDefinition",description:"Represents a metric definition",fields:{id:{type:s.String_unsecure(),isOptional:!1},key:{type:s.String_unsecure(),isOptional:!1},name:{type:s.String_unsecure(),isOptional:!1},description:{type:s.String_unsecure(),isOptional:!0},unit:{type:s.String_unsecure(),isOptional:!1},aggregationType:{type:s.String_unsecure(),isOptional:!1},resetPeriod:{type:s.String_unsecure(),isOptional:!1},category:{type:s.String_unsecure(),isOptional:!0},isActive:{type:s.Boolean(),isOptional:!1},orgId:{type:s.String_unsecure(),isOptional:!0},createdAt:{type:s.DateTime(),isOptional:!1},updatedAt:{type:s.DateTime(),isOptional:!1}}}),h=R({name:"UsageRecord",description:"Represents a usage record",fields:{id:{type:s.String_unsecure(),isOptional:!1},metricKey:{type:s.String_unsecure(),isOptional:!1},subjectType:{type:s.String_unsecure(),isOptional:!1},subjectId:{type:s.String_unsecure(),isOptional:!1},quantity:{type:s.Float_unsecure(),isOptional:!1},source:{type:s.String_unsecure(),isOptional:!0},resourceId:{type:s.String_unsecure(),isOptional:!0},resourceType:{type:s.String_unsecure(),isOptional:!0},metadata:{type:s.JSON(),isOptional:!0},timestamp:{type:s.DateTime(),isOptional:!1},createdAt:{type:s.DateTime(),isOptional:!1}}}),jt=R({name:"UsageSummary",description:"Represents aggregated usage",fields:{id:{type:s.String_unsecure(),isOptional:!1},metricKey:{type:s.String_unsecure(),isOptional:!1},subjectType:{type:s.String_unsecure(),isOptional:!1},subjectId:{type:s.String_unsecure(),isOptional:!1},periodType:{type:s.String_unsecure(),isOptional:!1},periodStart:{type:s.DateTime(),isOptional:!1},periodEnd:{type:s.DateTime(),isOptional:!1},totalQuantity:{type:s.Float_unsecure(),isOptional:!1},recordCount:{type:s.Int_unsecure(),isOptional:!1},minQuantity:{type:s.Float_unsecure(),isOptional:!0},maxQuantity:{type:s.Float_unsecure(),isOptional:!0},avgQuantity:{type:s.Float_unsecure(),isOptional:!0}}}),x=R({name:"UsageThreshold",description:"Represents a usage threshold",fields:{id:{type:s.String_unsecure(),isOptional:!1},metricKey:{type:s.String_unsecure(),isOptional:!1},subjectType:{type:s.String_unsecure(),isOptional:!0},subjectId:{type:s.String_unsecure(),isOptional:!0},name:{type:s.String_unsecure(),isOptional:!1},threshold:{type:s.Float_unsecure(),isOptional:!1},warnThreshold:{type:s.Float_unsecure(),isOptional:!0},periodType:{type:s.String_unsecure(),isOptional:!1},action:{type:s.String_unsecure(),isOptional:!1},currentValue:{type:s.Float_unsecure(),isOptional:!1},isActive:{type:s.Boolean(),isOptional:!1},createdAt:{type:s.DateTime(),isOptional:!1}}}),It=R({name:"DefineMetricInput",description:"Input for defining a metric",fields:{key:{type:s.String_unsecure(),isOptional:!1},name:{type:s.String_unsecure(),isOptional:!1},description:{type:s.String_unsecure(),isOptional:!0},unit:{type:s.String_unsecure(),isOptional:!1},aggregationType:{type:s.String_unsecure(),isOptional:!0},resetPeriod:{type:s.String_unsecure(),isOptional:!0},category:{type:s.String_unsecure(),isOptional:!0},orgId:{type:s.String_unsecure(),isOptional:!0},metadata:{type:s.JSON(),isOptional:!0}}}),rt=R({name:"UpdateMetricInput",description:"Input for updating a metric",fields:{metricId:{type:s.String_unsecure(),isOptional:!1},name:{type:s.String_unsecure(),isOptional:!0},description:{type:s.String_unsecure(),isOptional:!0},category:{type:s.String_unsecure(),isOptional:!0},isActive:{type:s.Boolean(),isOptional:!0},metadata:{type:s.JSON(),isOptional:!0}}}),ot=R({name:"DeleteMetricInput",description:"Input for deleting a metric",fields:{metricId:{type:s.String_unsecure(),isOptional:!1}}}),At=R({name:"GetMetricInput",description:"Input for getting a metric",fields:{key:{type:s.String_unsecure(),isOptional:!1},orgId:{type:s.String_unsecure(),isOptional:!0}}}),Rt=R({name:"ListMetricsInput",description:"Input for listing metrics",fields:{orgId:{type:s.String_unsecure(),isOptional:!0},category:{type:s.String_unsecure(),isOptional:!0},isActive:{type:s.Boolean(),isOptional:!0},limit:{type:s.Int_unsecure(),isOptional:!0},offset:{type:s.Int_unsecure(),isOptional:!0}}}),Qt=R({name:"ListMetricsOutput",description:"Output for listing metrics",fields:{metrics:{type:B,isArray:!0,isOptional:!1},total:{type:s.Int_unsecure(),isOptional:!1}}}),n=R({name:"RecordUsageInput",description:"Input for recording usage",fields:{metricKey:{type:s.String_unsecure(),isOptional:!1},subjectType:{type:s.String_unsecure(),isOptional:!1},subjectId:{type:s.String_unsecure(),isOptional:!1},quantity:{type:s.Float_unsecure(),isOptional:!1},timestamp:{type:s.DateTime(),isOptional:!0},source:{type:s.String_unsecure(),isOptional:!0},resourceId:{type:s.String_unsecure(),isOptional:!0},resourceType:{type:s.String_unsecure(),isOptional:!0},metadata:{type:s.JSON(),isOptional:!0},idempotencyKey:{type:s.String_unsecure(),isOptional:!0}}}),kt=R({name:"RecordBatchUsageInput",description:"Input for recording batch usage",fields:{records:{type:n,isArray:!0,isOptional:!1}}}),Kt=R({name:"RecordBatchUsageOutput",description:"Output for recording batch usage",fields:{recordedCount:{type:s.Int_unsecure(),isOptional:!1},skippedCount:{type:s.Int_unsecure(),isOptional:!1},recordIds:{type:s.JSON(),isOptional:!1}}}),Pt=R({name:"GetUsageInput",description:"Input for getting usage",fields:{metricKey:{type:s.String_unsecure(),isOptional:!1},subjectType:{type:s.String_unsecure(),isOptional:!1},subjectId:{type:s.String_unsecure(),isOptional:!1},startDate:{type:s.DateTime(),isOptional:!1},endDate:{type:s.DateTime(),isOptional:!1},limit:{type:s.Int_unsecure(),isOptional:!0},offset:{type:s.Int_unsecure(),isOptional:!0}}}),$t=R({name:"GetUsageOutput",description:"Output for getting usage",fields:{records:{type:h,isArray:!0,isOptional:!1},total:{type:s.Int_unsecure(),isOptional:!1},totalQuantity:{type:s.Float_unsecure(),isOptional:!1}}}),wt=R({name:"GetUsageSummaryInput",description:"Input for getting usage summary",fields:{metricKey:{type:s.String_unsecure(),isOptional:!1},subjectType:{type:s.String_unsecure(),isOptional:!1},subjectId:{type:s.String_unsecure(),isOptional:!1},periodType:{type:s.String_unsecure(),isOptional:!1},startDate:{type:s.DateTime(),isOptional:!1},endDate:{type:s.DateTime(),isOptional:!0}}}),Ht=R({name:"GetUsageSummaryOutput",description:"Output for getting usage summary",fields:{summaries:{type:jt,isArray:!0,isOptional:!1},total:{type:s.Int_unsecure(),isOptional:!1}}}),_t=R({name:"CreateThresholdInput",description:"Input for creating a threshold",fields:{metricKey:{type:s.String_unsecure(),isOptional:!1},subjectType:{type:s.String_unsecure(),isOptional:!0},subjectId:{type:s.String_unsecure(),isOptional:!0},name:{type:s.String_unsecure(),isOptional:!1},threshold:{type:s.Float_unsecure(),isOptional:!1},warnThreshold:{type:s.Float_unsecure(),isOptional:!0},periodType:{type:s.String_unsecure(),isOptional:!0},action:{type:s.String_unsecure(),isOptional:!0},notifyEmails:{type:s.JSON(),isOptional:!0},notifyWebhook:{type:s.String_unsecure(),isOptional:!0}}}),Dt=R({name:"UpdateThresholdInput",description:"Input for updating a threshold",fields:{thresholdId:{type:s.String_unsecure(),isOptional:!1},name:{type:s.String_unsecure(),isOptional:!0},threshold:{type:s.Float_unsecure(),isOptional:!0},warnThreshold:{type:s.Float_unsecure(),isOptional:!0},action:{type:s.String_unsecure(),isOptional:!0},notifyEmails:{type:s.JSON(),isOptional:!0},notifyWebhook:{type:s.String_unsecure(),isOptional:!0},isActive:{type:s.Boolean(),isOptional:!0}}}),Ft=R({name:"DeleteThresholdInput",description:"Input for deleting a threshold",fields:{thresholdId:{type:s.String_unsecure(),isOptional:!1}}}),Lt=R({name:"ListThresholdsInput",description:"Input for listing thresholds",fields:{metricKey:{type:s.String_unsecure(),isOptional:!0},subjectType:{type:s.String_unsecure(),isOptional:!0},subjectId:{type:s.String_unsecure(),isOptional:!0},isActive:{type:s.Boolean(),isOptional:!0}}}),Ut=R({name:"ListThresholdsOutput",description:"Output for listing thresholds",fields:{thresholds:{type:x,isArray:!0,isOptional:!1},total:{type:s.Int_unsecure(),isOptional:!1}}}),f=R({name:"SuccessOutput",description:"Generic success output",fields:{success:{type:s.Boolean(),isOptional:!1}}}),ts=F({meta:{key:"metric.define",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","metric","define"],description:"Define a new usage metric.",goal:"Create a new metric for tracking usage.",context:"Called when setting up metering."},io:{input:It,output:B,errors:{METRIC_KEY_EXISTS:{description:"Metric key already exists",http:409,gqlCode:"METRIC_KEY_EXISTS",when:"A metric with this key already exists"}}},policy:{auth:"admin"}}),ss=F({meta:{key:"metric.update",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","metric","update"],description:"Update a metric definition.",goal:"Modify metric configuration.",context:"Called when updating metric settings."},io:{input:rt,output:B,errors:{METRIC_NOT_FOUND:{description:"Metric does not exist",http:404,gqlCode:"METRIC_NOT_FOUND",when:"Metric ID is invalid"}}},policy:{auth:"admin"}}),gs=F({meta:{key:"metric.delete",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","metric","delete"],description:"Delete a metric definition.",goal:"Remove a metric and its data.",context:"Called when removing a metric."},io:{input:ot,output:f,errors:{METRIC_NOT_FOUND:{description:"Metric does not exist",http:404,gqlCode:"METRIC_NOT_FOUND",when:"Metric ID is invalid"}}},policy:{auth:"admin"}}),bs=V({meta:{key:"metric.get",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","metric","get"],description:"Get a metric by key.",goal:"Retrieve metric definition.",context:"Called to inspect metric details."},io:{input:At,output:B,errors:{METRIC_NOT_FOUND:{description:"Metric does not exist",http:404,gqlCode:"METRIC_NOT_FOUND",when:"Metric key is invalid"}}},policy:{auth:"user"}}),js=V({meta:{key:"metric.list",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","metric","list"],description:"List all metrics.",goal:"View configured metrics.",context:"Called to browse metrics."},io:{input:Rt,output:Qt},policy:{auth:"user"}}),Is=F({meta:{key:"usage.record",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","usage","record"],description:"Record a usage event.",goal:"Track usage for billing and monitoring.",context:"Called when usage occurs."},io:{input:n,output:h,errors:{METRIC_NOT_FOUND:{description:"Metric does not exist",http:404,gqlCode:"METRIC_NOT_FOUND",when:"Metric key is invalid"},DUPLICATE_RECORD:{description:"Record already exists",http:409,gqlCode:"DUPLICATE_RECORD",when:"Idempotency key already used"}}},policy:{auth:"admin"}}),rs=F({meta:{key:"usage.recordBatch",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","usage","batch"],description:"Record multiple usage events.",goal:"Efficiently track bulk usage.",context:"Called for batch processing."},io:{input:kt,output:Kt},policy:{auth:"admin"}}),os=V({meta:{key:"usage.get",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","usage","get"],description:"Get usage records for a subject.",goal:"View detailed usage history.",context:"Called to analyze usage."},io:{input:Pt,output:$t},policy:{auth:"user"}}),As=V({meta:{key:"usage.getSummary",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","usage","summary"],description:"Get aggregated usage summary.",goal:"View usage totals for billing.",context:"Called for billing and reporting."},io:{input:wt,output:Ht},policy:{auth:"user"}}),Rs=F({meta:{key:"threshold.create",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","threshold","create"],description:"Create a usage threshold.",goal:"Set up usage limits and alerts.",context:"Called when configuring limits."},io:{input:_t,output:x,errors:{METRIC_NOT_FOUND:{description:"Metric does not exist",http:404,gqlCode:"METRIC_NOT_FOUND",when:"Metric key is invalid"}}},policy:{auth:"admin"}}),Qs=F({meta:{key:"threshold.update",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","threshold","update"],description:"Update a threshold.",goal:"Modify threshold configuration.",context:"Called when adjusting limits."},io:{input:Dt,output:x,errors:{THRESHOLD_NOT_FOUND:{description:"Threshold does not exist",http:404,gqlCode:"THRESHOLD_NOT_FOUND",when:"Threshold ID is invalid"}}},policy:{auth:"admin"}}),ks=F({meta:{key:"threshold.delete",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","threshold","delete"],description:"Delete a threshold.",goal:"Remove a usage threshold.",context:"Called when removing limits."},io:{input:Ft,output:f,errors:{THRESHOLD_NOT_FOUND:{description:"Threshold does not exist",http:404,gqlCode:"THRESHOLD_NOT_FOUND",when:"Threshold ID is invalid"}}},policy:{auth:"admin"}}),Ks=V({meta:{key:"threshold.list",version:"1.0.0",stability:"stable",owners:[...P],tags:["metering","threshold","list"],description:"List usage thresholds.",goal:"View configured limits.",context:"Called to browse thresholds."},io:{input:Lt,output:Ut},policy:{auth:"user"}});import{registerDocBlocks as qt}from"@contractspec/lib.contracts-spec/docs";var Vt=[{id:"docs.metering.usage",title:"Usage Metering & Billing Core",summary:"Reusable usage/metering layer with metric definitions, usage ingestion, aggregation, thresholds, and alerts for billing or quotas.",kind:"reference",visibility:"public",route:"/docs/metering/usage",tags:["metering","usage","billing","quotas"],body:`## Capabilities
 
 - **Entities**: MetricDefinition, UsageRecord, UsageSummary, UsageThreshold, UsageAlert.
 - **Contracts**: define/list metrics; record usage (batch + idempotent); retrieve usage by subject; manage thresholds and alerts.
@@ -1199,7 +26,7 @@ var meteringDocBlocks = [
 
 ## Example
 
-${"```"}ts
+\`\`\`ts
 import { meteringSchemaContribution } from '@contractspec/lib.metering';
 import { aggregateUsage } from '@contractspec/lib.metering/aggregation';
 
@@ -1214,708 +41,11 @@ await aggregateUsage({
   usage: usageRepository,
   period: 'DAILY',
 });
-${"```"},
+\`\`\`,
 
 ## Guardrails
 
 - Keep metric keys stable; store quantities as decimals for currency/units.
 - Use idempotency keys for external ingestion; avoid PII in metric metadata.
 - Scope by org/user for multi-tenant isolation; emit audit + analytics events on changes.
-`
-  }
-];
-registerDocBlocks(meteringDocBlocks);
-// src/entities/index.ts
-import {
-  defineEntity,
-  defineEntityEnum,
-  field,
-  index
-} from "@contractspec/lib.schema";
-var AggregationTypeEnum = defineEntityEnum({
-  name: "AggregationType",
-  values: ["COUNT", "SUM", "AVG", "MAX", "MIN", "LAST"],
-  schema: "lssm_metering",
-  description: "How to aggregate metric values."
-});
-var ResetPeriodEnum = defineEntityEnum({
-  name: "ResetPeriod",
-  values: ["NEVER", "HOURLY", "DAILY", "WEEKLY", "MONTHLY", "YEARLY"],
-  schema: "lssm_metering",
-  description: "When to reset metric counters."
-});
-var PeriodTypeEnum = defineEntityEnum({
-  name: "PeriodType",
-  values: ["HOURLY", "DAILY", "WEEKLY", "MONTHLY", "YEARLY"],
-  schema: "lssm_metering",
-  description: "Time period for aggregation."
-});
-var ThresholdActionEnum = defineEntityEnum({
-  name: "ThresholdAction",
-  values: ["NONE", "ALERT", "WARN", "BLOCK", "DOWNGRADE"],
-  schema: "lssm_metering",
-  description: "Action to take when threshold is exceeded."
-});
-var MetricDefinitionEntity = defineEntity({
-  name: "MetricDefinition",
-  description: "Definition of a usage metric.",
-  schema: "lssm_metering",
-  map: "metric_definition",
-  fields: {
-    id: field.id({ description: "Unique identifier" }),
-    key: field.string({
-      isUnique: true,
-      description: "Metric key (e.g., api_calls, storage_gb)"
-    }),
-    name: field.string({ description: "Human-readable name" }),
-    description: field.string({
-      isOptional: true,
-      description: "Metric description"
-    }),
-    unit: field.string({
-      description: "Unit of measurement (calls, bytes, etc.)"
-    }),
-    aggregationType: field.enum("AggregationType", {
-      default: "SUM",
-      description: "How to aggregate values"
-    }),
-    resetPeriod: field.enum("ResetPeriod", {
-      default: "MONTHLY",
-      description: "When to reset counters"
-    }),
-    precision: field.int({ default: 2, description: "Decimal precision" }),
-    orgId: field.string({
-      isOptional: true,
-      description: "Organization scope (null = global metric)"
-    }),
-    category: field.string({
-      isOptional: true,
-      description: "Category for grouping"
-    }),
-    displayOrder: field.int({ default: 0, description: "Order for display" }),
-    metadata: field.json({
-      isOptional: true,
-      description: "Additional metadata"
-    }),
-    isActive: field.boolean({
-      default: true,
-      description: "Whether metric is active"
-    }),
-    createdAt: field.createdAt(),
-    updatedAt: field.updatedAt(),
-    usageRecords: field.hasMany("UsageRecord"),
-    usageSummaries: field.hasMany("UsageSummary"),
-    thresholds: field.hasMany("UsageThreshold")
-  },
-  indexes: [
-    index.on(["orgId", "key"]),
-    index.on(["category"]),
-    index.on(["isActive"])
-  ],
-  enums: [AggregationTypeEnum, ResetPeriodEnum]
-});
-var UsageRecordEntity = defineEntity({
-  name: "UsageRecord",
-  description: "A single usage event.",
-  schema: "lssm_metering",
-  map: "usage_record",
-  fields: {
-    id: field.id({ description: "Unique identifier" }),
-    metricKey: field.string({ description: "Metric being recorded" }),
-    metricId: field.string({
-      isOptional: true,
-      description: "Metric ID (for FK)"
-    }),
-    subjectType: field.string({
-      description: "Subject type (org, user, project)"
-    }),
-    subjectId: field.string({ description: "Subject identifier" }),
-    quantity: field.decimal({ description: "Usage quantity" }),
-    source: field.string({
-      isOptional: true,
-      description: "Source of usage (endpoint, feature, etc.)"
-    }),
-    resourceId: field.string({
-      isOptional: true,
-      description: "Related resource ID"
-    }),
-    resourceType: field.string({
-      isOptional: true,
-      description: "Related resource type"
-    }),
-    metadata: field.json({
-      isOptional: true,
-      description: "Additional context"
-    }),
-    idempotencyKey: field.string({
-      isOptional: true,
-      description: "Idempotency key for deduplication"
-    }),
-    timestamp: field.dateTime({ description: "When usage occurred" }),
-    createdAt: field.createdAt(),
-    aggregated: field.boolean({
-      default: false,
-      description: "Whether included in summary"
-    }),
-    aggregatedAt: field.dateTime({
-      isOptional: true,
-      description: "When aggregated"
-    })
-  },
-  indexes: [
-    index.on(["metricKey", "subjectType", "subjectId", "timestamp"]),
-    index.on(["subjectType", "subjectId", "timestamp"]),
-    index.on(["timestamp"]),
-    index.on(["aggregated", "timestamp"]),
-    index.unique(["idempotencyKey"], { name: "usage_record_idempotency" })
-  ]
-});
-var UsageSummaryEntity = defineEntity({
-  name: "UsageSummary",
-  description: "Pre-aggregated usage summary.",
-  schema: "lssm_metering",
-  map: "usage_summary",
-  fields: {
-    id: field.id({ description: "Unique identifier" }),
-    metricKey: field.string({ description: "Metric key" }),
-    metricId: field.string({
-      isOptional: true,
-      description: "Metric ID (for FK)"
-    }),
-    subjectType: field.string({ description: "Subject type" }),
-    subjectId: field.string({ description: "Subject identifier" }),
-    periodType: field.enum("PeriodType", { description: "Period type" }),
-    periodStart: field.dateTime({ description: "Period start time" }),
-    periodEnd: field.dateTime({ description: "Period end time" }),
-    totalQuantity: field.decimal({ description: "Total/aggregated quantity" }),
-    recordCount: field.int({
-      default: 0,
-      description: "Number of records aggregated"
-    }),
-    minQuantity: field.decimal({
-      isOptional: true,
-      description: "Minimum value"
-    }),
-    maxQuantity: field.decimal({
-      isOptional: true,
-      description: "Maximum value"
-    }),
-    avgQuantity: field.decimal({
-      isOptional: true,
-      description: "Average value"
-    }),
-    metadata: field.json({
-      isOptional: true,
-      description: "Additional metadata"
-    }),
-    createdAt: field.createdAt(),
-    updatedAt: field.updatedAt()
-  },
-  indexes: [
-    index.unique(["metricKey", "subjectType", "subjectId", "periodType", "periodStart"], { name: "usage_summary_unique" }),
-    index.on(["subjectType", "subjectId", "periodType", "periodStart"]),
-    index.on(["metricKey", "periodType", "periodStart"])
-  ],
-  enums: [PeriodTypeEnum]
-});
-var UsageThresholdEntity = defineEntity({
-  name: "UsageThreshold",
-  description: "Usage threshold configuration.",
-  schema: "lssm_metering",
-  map: "usage_threshold",
-  fields: {
-    id: field.id({ description: "Unique identifier" }),
-    metricKey: field.string({ description: "Metric to monitor" }),
-    metricId: field.string({
-      isOptional: true,
-      description: "Metric ID (for FK)"
-    }),
-    subjectType: field.string({
-      isOptional: true,
-      description: "Subject type"
-    }),
-    subjectId: field.string({
-      isOptional: true,
-      description: "Subject identifier"
-    }),
-    name: field.string({ description: "Threshold name" }),
-    threshold: field.decimal({ description: "Threshold value" }),
-    warnThreshold: field.decimal({
-      isOptional: true,
-      description: "Warning threshold (e.g., 80%)"
-    }),
-    periodType: field.enum("PeriodType", {
-      default: "MONTHLY",
-      description: "Period to evaluate"
-    }),
-    action: field.enum("ThresholdAction", {
-      default: "ALERT",
-      description: "Action when exceeded"
-    }),
-    notifyEmails: field.json({
-      isOptional: true,
-      description: "Email addresses to notify"
-    }),
-    notifyWebhook: field.string({
-      isOptional: true,
-      description: "Webhook URL to call"
-    }),
-    currentValue: field.decimal({
-      default: 0,
-      description: "Current usage value"
-    }),
-    lastCheckedAt: field.dateTime({
-      isOptional: true,
-      description: "Last threshold check"
-    }),
-    lastExceededAt: field.dateTime({
-      isOptional: true,
-      description: "Last time threshold was exceeded"
-    }),
-    isActive: field.boolean({
-      default: true,
-      description: "Whether threshold is active"
-    }),
-    metadata: field.json({
-      isOptional: true,
-      description: "Additional metadata"
-    }),
-    createdAt: field.createdAt(),
-    updatedAt: field.updatedAt()
-  },
-  indexes: [
-    index.on(["metricKey"]),
-    index.on(["subjectType", "subjectId"]),
-    index.on(["isActive", "metricKey"])
-  ],
-  enums: [ThresholdActionEnum]
-});
-var UsageAlertEntity = defineEntity({
-  name: "UsageAlert",
-  description: "Alert generated when threshold is exceeded.",
-  schema: "lssm_metering",
-  map: "usage_alert",
-  fields: {
-    id: field.id({ description: "Unique identifier" }),
-    thresholdId: field.foreignKey({
-      description: "Threshold that triggered alert"
-    }),
-    metricKey: field.string({ description: "Metric key" }),
-    subjectType: field.string({
-      isOptional: true,
-      description: "Subject type"
-    }),
-    subjectId: field.string({
-      isOptional: true,
-      description: "Subject identifier"
-    }),
-    alertType: field.string({ description: "Alert type (warn, exceed, etc.)" }),
-    threshold: field.decimal({ description: "Threshold value" }),
-    actualValue: field.decimal({ description: "Actual usage value" }),
-    percentageUsed: field.decimal({
-      description: "Percentage of threshold used"
-    }),
-    status: field.string({
-      default: '"pending"',
-      description: "Alert status (pending, acknowledged, resolved)"
-    }),
-    acknowledgedBy: field.string({
-      isOptional: true,
-      description: "User who acknowledged"
-    }),
-    acknowledgedAt: field.dateTime({
-      isOptional: true,
-      description: "When acknowledged"
-    }),
-    resolvedAt: field.dateTime({
-      isOptional: true,
-      description: "When resolved"
-    }),
-    notificationsSent: field.json({
-      isOptional: true,
-      description: "Notifications sent"
-    }),
-    triggeredAt: field.dateTime({ description: "When alert was triggered" }),
-    createdAt: field.createdAt(),
-    thresholdRelation: field.belongsTo("UsageThreshold", ["thresholdId"], ["id"], { onDelete: "Cascade" })
-  },
-  indexes: [
-    index.on(["thresholdId", "status"]),
-    index.on(["metricKey", "triggeredAt"]),
-    index.on(["status", "triggeredAt"])
-  ]
-});
-var meteringEntities = [
-  MetricDefinitionEntity,
-  UsageRecordEntity,
-  UsageSummaryEntity,
-  UsageThresholdEntity,
-  UsageAlertEntity
-];
-var meteringSchemaContribution = {
-  moduleId: "@contractspec/lib.metering",
-  entities: meteringEntities,
-  enums: [
-    AggregationTypeEnum,
-    ResetPeriodEnum,
-    PeriodTypeEnum,
-    ThresholdActionEnum
-  ]
-};
-
-// src/events.ts
-import { defineEvent } from "@contractspec/lib.contracts-spec";
-import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
-var MetricDefinedPayload = defineSchemaModel2({
-  name: "MetricDefinedEventPayload",
-  description: "Payload when a metric is defined",
-  fields: {
-    metricId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    key: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    unit: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    aggregationType: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: false
-    },
-    orgId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    createdBy: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var MetricUpdatedPayload = defineSchemaModel2({
-  name: "MetricUpdatedEventPayload",
-  description: "Payload when a metric is updated",
-  fields: {
-    metricId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    key: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    changes: { type: ScalarTypeEnum2.JSON(), isOptional: false },
-    updatedBy: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var UsageRecordedPayload = defineSchemaModel2({
-  name: "UsageRecordedEventPayload",
-  description: "Payload when usage is recorded",
-  fields: {
-    recordId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    metricKey: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    subjectId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    quantity: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    source: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    timestamp: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var UsageBatchRecordedPayload = defineSchemaModel2({
-  name: "UsageBatchRecordedEventPayload",
-  description: "Payload when a batch of usage is recorded",
-  fields: {
-    recordCount: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
-    metricKeys: { type: ScalarTypeEnum2.JSON(), isOptional: false },
-    totalQuantity: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var UsageAggregatedPayload = defineSchemaModel2({
-  name: "UsageAggregatedEventPayload",
-  description: "Payload when usage is aggregated",
-  fields: {
-    summaryId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    metricKey: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    subjectId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    periodType: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    periodStart: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    periodEnd: { type: ScalarTypeEnum2.DateTime(), isOptional: false },
-    totalQuantity: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    recordCount: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
-    aggregatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var ThresholdCreatedPayload = defineSchemaModel2({
-  name: "ThresholdCreatedEventPayload",
-  description: "Payload when a threshold is created",
-  fields: {
-    thresholdId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    metricKey: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    subjectId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    threshold: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    action: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var ThresholdExceededPayload = defineSchemaModel2({
-  name: "ThresholdExceededEventPayload",
-  description: "Payload when a threshold is exceeded",
-  fields: {
-    alertId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    thresholdId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    metricKey: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    subjectId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    threshold: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    actualValue: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    percentageUsed: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: false
-    },
-    action: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    triggeredAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var ThresholdApproachingPayload = defineSchemaModel2({
-  name: "ThresholdApproachingEventPayload",
-  description: "Payload when usage is approaching a threshold",
-  fields: {
-    thresholdId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    metricKey: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    subjectType: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    subjectId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    threshold: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    currentValue: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    percentageUsed: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: false
-    },
-    triggeredAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var MetricDefinedEvent = defineEvent({
-  meta: {
-    key: "metric.defined",
-    version: "1.0.0",
-    description: "A metric has been defined.",
-    stability: "stable",
-    owners: ["@platform.metering"],
-    tags: ["metering", "metric"]
-  },
-  payload: MetricDefinedPayload
-});
-var MetricUpdatedEvent = defineEvent({
-  meta: {
-    key: "metric.updated",
-    version: "1.0.0",
-    description: "A metric has been updated.",
-    stability: "stable",
-    owners: ["@platform.metering"],
-    tags: ["metering", "metric"]
-  },
-  payload: MetricUpdatedPayload
-});
-var UsageRecordedEvent = defineEvent({
-  meta: {
-    key: "usage.recorded",
-    version: "1.0.0",
-    description: "Usage has been recorded.",
-    stability: "stable",
-    owners: ["@platform.metering"],
-    tags: ["metering", "usage"]
-  },
-  payload: UsageRecordedPayload
-});
-var UsageBatchRecordedEvent = defineEvent({
-  meta: {
-    key: "usage.batch_recorded",
-    version: "1.0.0",
-    description: "A batch of usage has been recorded.",
-    stability: "stable",
-    owners: ["@platform.metering"],
-    tags: ["metering", "usage"]
-  },
-  payload: UsageBatchRecordedPayload
-});
-var UsageAggregatedEvent = defineEvent({
-  meta: {
-    key: "usage.aggregated",
-    version: "1.0.0",
-    description: "Usage has been aggregated into a summary.",
-    stability: "stable",
-    owners: ["@platform.metering"],
-    tags: ["metering", "usage"]
-  },
-  payload: UsageAggregatedPayload
-});
-var ThresholdCreatedEvent = defineEvent({
-  meta: {
-    key: "threshold.created",
-    version: "1.0.0",
-    description: "A usage threshold has been created.",
-    stability: "stable",
-    owners: ["@platform.metering"],
-    tags: ["metering", "threshold"]
-  },
-  payload: ThresholdCreatedPayload
-});
-var ThresholdExceededEvent = defineEvent({
-  meta: {
-    key: "threshold.exceeded",
-    version: "1.0.0",
-    description: "Usage has exceeded a threshold.",
-    stability: "stable",
-    owners: ["@platform.metering"],
-    tags: ["metering", "threshold"]
-  },
-  payload: ThresholdExceededPayload
-});
-var ThresholdApproachingEvent = defineEvent({
-  meta: {
-    key: "threshold.approaching",
-    version: "1.0.0",
-    description: "Usage is approaching a threshold.",
-    stability: "stable",
-    owners: ["@platform.metering"],
-    tags: ["metering", "threshold"]
-  },
-  payload: ThresholdApproachingPayload
-});
-var ModelSelectionPayload = defineSchemaModel2({
-  name: "ModelSelectionEventPayload",
-  description: "Payload when an AI model is selected via ranking",
-  fields: {
-    modelId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    providerKey: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    dimension: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    score: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
-    reason: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    alternativesCount: {
-      type: ScalarTypeEnum2.Int_unsecure(),
-      isOptional: false
-    },
-    costEstimateInput: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: true
-    },
-    costEstimateOutput: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: true
-    },
-    selectionDurationMs: {
-      type: ScalarTypeEnum2.Float_unsecure(),
-      isOptional: true
-    },
-    timestamp: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
-  }
-});
-var ModelSelectionEvent = defineEvent({
-  meta: {
-    key: "model.selected",
-    version: "1.0.0",
-    description: "An AI model has been selected via ranking-driven selection.",
-    stability: "experimental",
-    owners: ["@platform.metering"],
-    tags: ["metering", "ai", "model-selection"]
-  },
-  payload: ModelSelectionPayload
-});
-var MeteringEvents = {
-  MetricDefinedEvent,
-  MetricUpdatedEvent,
-  UsageRecordedEvent,
-  UsageBatchRecordedEvent,
-  UsageAggregatedEvent,
-  ThresholdCreatedEvent,
-  ThresholdExceededEvent,
-  ThresholdApproachingEvent,
-  ModelSelectionEvent
-};
-
-// src/metering.feature.ts
-import { defineFeature } from "@contractspec/lib.contracts-spec";
-var MeteringFeature = defineFeature({
-  meta: {
-    key: "metrics",
-    version: "1.0.0",
-    title: "Usage Metering",
-    description: "Usage metering, metric definitions, and threshold alerting",
-    domain: "platform",
-    owners: ["@platform.metering"],
-    tags: ["metering", "usage", "billing", "thresholds"],
-    stability: "stable"
-  },
-  operations: [
-    { key: "metric.define", version: "1.0.0" },
-    { key: "metric.update", version: "1.0.0" },
-    { key: "metric.delete", version: "1.0.0" },
-    { key: "metric.get", version: "1.0.0" },
-    { key: "metric.list", version: "1.0.0" },
-    { key: "usage.record", version: "1.0.0" },
-    { key: "usage.recordBatch", version: "1.0.0" },
-    { key: "usage.get", version: "1.0.0" },
-    { key: "usage.getSummary", version: "1.0.0" },
-    { key: "threshold.create", version: "1.0.0" },
-    { key: "threshold.update", version: "1.0.0" },
-    { key: "threshold.delete", version: "1.0.0" },
-    { key: "threshold.list", version: "1.0.0" }
-  ],
-  events: [
-    { key: "metric.defined", version: "1.0.0" },
-    { key: "metric.updated", version: "1.0.0" },
-    { key: "usage.recorded", version: "1.0.0" },
-    { key: "usage.batch_recorded", version: "1.0.0" },
-    { key: "usage.aggregated", version: "1.0.0" },
-    { key: "threshold.created", version: "1.0.0" },
-    { key: "threshold.exceeded", version: "1.0.0" },
-    { key: "threshold.approaching", version: "1.0.0" },
-    { key: "model.selected", version: "1.0.0" }
-  ],
-  presentations: [],
-  opToPresentation: [],
-  presentationsTargets: [],
-  capabilities: {
-    provides: [
-      { key: "metering", version: "1.0.0" },
-      { key: "thresholds", version: "1.0.0" }
-    ],
-    requires: []
-  }
-});
-export {
-  meteringSchemaContribution,
-  meteringEntities,
-  getPeriodStart,
-  getPeriodEnd,
-  formatPeriodKey,
-  UsageThresholdModel,
-  UsageThresholdEntity,
-  UsageSummaryModel,
-  UsageSummaryEntity,
-  UsageRecordedEvent,
-  UsageRecordModel,
-  UsageRecordEntity,
-  UsageBatchRecordedEvent,
-  UsageAlertEntity,
-  UsageAggregator,
-  UsageAggregatedEvent,
-  UpdateThresholdContract,
-  UpdateMetricContract,
-  ThresholdExceededEvent,
-  ThresholdCreatedEvent,
-  ThresholdApproachingEvent,
-  ThresholdActionEnum,
-  ResetPeriodEnum,
-  RecordUsageContract,
-  RecordBatchUsageContract,
-  PosthogMeteringReporter,
-  PosthogMeteringReader,
-  PeriodTypeEnum,
-  ModelSelectionEvent,
-  MetricUpdatedEvent,
-  MetricDefinitionModel,
-  MetricDefinitionEntity,
-  MetricDefinedEvent,
-  MeteringFeature,
-  MeteringEvents,
-  ListThresholdsContract,
-  ListMetricsContract,
-  InMemoryUsageStorage,
-  GetUsageSummaryContract,
-  GetUsageContract,
-  GetMetricContract,
-  DeleteThresholdContract,
-  DeleteMetricContract,
-  DefineMetricContract,
-  CreateThresholdContract,
-  AggregationTypeEnum
-};
+`}];qt(Vt);import{defineEntity as C,defineEntityEnum as J,field as b,index as K}from"@contractspec/lib.schema";var u=J({name:"AggregationType",values:["COUNT","SUM","AVG","MAX","MIN","LAST"],schema:"lssm_metering",description:"How to aggregate metric values."}),c=J({name:"ResetPeriod",values:["NEVER","HOURLY","DAILY","WEEKLY","MONTHLY","YEARLY"],schema:"lssm_metering",description:"When to reset metric counters."}),p=J({name:"PeriodType",values:["HOURLY","DAILY","WEEKLY","MONTHLY","YEARLY"],schema:"lssm_metering",description:"Time period for aggregation."}),y=J({name:"ThresholdAction",values:["NONE","ALERT","WARN","BLOCK","DOWNGRADE"],schema:"lssm_metering",description:"Action to take when threshold is exceeded."}),Ct=C({name:"MetricDefinition",description:"Definition of a usage metric.",schema:"lssm_metering",map:"metric_definition",fields:{id:b.id({description:"Unique identifier"}),key:b.string({isUnique:!0,description:"Metric key (e.g., api_calls, storage_gb)"}),name:b.string({description:"Human-readable name"}),description:b.string({isOptional:!0,description:"Metric description"}),unit:b.string({description:"Unit of measurement (calls, bytes, etc.)"}),aggregationType:b.enum("AggregationType",{default:"SUM",description:"How to aggregate values"}),resetPeriod:b.enum("ResetPeriod",{default:"MONTHLY",description:"When to reset counters"}),precision:b.int({default:2,description:"Decimal precision"}),orgId:b.string({isOptional:!0,description:"Organization scope (null = global metric)"}),category:b.string({isOptional:!0,description:"Category for grouping"}),displayOrder:b.int({default:0,description:"Order for display"}),metadata:b.json({isOptional:!0,description:"Additional metadata"}),isActive:b.boolean({default:!0,description:"Whether metric is active"}),createdAt:b.createdAt(),updatedAt:b.updatedAt(),usageRecords:b.hasMany("UsageRecord"),usageSummaries:b.hasMany("UsageSummary"),thresholds:b.hasMany("UsageThreshold")},indexes:[K.on(["orgId","key"]),K.on(["category"]),K.on(["isActive"])],enums:[u,c]}),it=C({name:"UsageRecord",description:"A single usage event.",schema:"lssm_metering",map:"usage_record",fields:{id:b.id({description:"Unique identifier"}),metricKey:b.string({description:"Metric being recorded"}),metricId:b.string({isOptional:!0,description:"Metric ID (for FK)"}),subjectType:b.string({description:"Subject type (org, user, project)"}),subjectId:b.string({description:"Subject identifier"}),quantity:b.decimal({description:"Usage quantity"}),source:b.string({isOptional:!0,description:"Source of usage (endpoint, feature, etc.)"}),resourceId:b.string({isOptional:!0,description:"Related resource ID"}),resourceType:b.string({isOptional:!0,description:"Related resource type"}),metadata:b.json({isOptional:!0,description:"Additional context"}),idempotencyKey:b.string({isOptional:!0,description:"Idempotency key for deduplication"}),timestamp:b.dateTime({description:"When usage occurred"}),createdAt:b.createdAt(),aggregated:b.boolean({default:!1,description:"Whether included in summary"}),aggregatedAt:b.dateTime({isOptional:!0,description:"When aggregated"})},indexes:[K.on(["metricKey","subjectType","subjectId","timestamp"]),K.on(["subjectType","subjectId","timestamp"]),K.on(["timestamp"]),K.on(["aggregated","timestamp"]),K.unique(["idempotencyKey"],{name:"usage_record_idempotency"})]}),zt=C({name:"UsageSummary",description:"Pre-aggregated usage summary.",schema:"lssm_metering",map:"usage_summary",fields:{id:b.id({description:"Unique identifier"}),metricKey:b.string({description:"Metric key"}),metricId:b.string({isOptional:!0,description:"Metric ID (for FK)"}),subjectType:b.string({description:"Subject type"}),subjectId:b.string({description:"Subject identifier"}),periodType:b.enum("PeriodType",{description:"Period type"}),periodStart:b.dateTime({description:"Period start time"}),periodEnd:b.dateTime({description:"Period end time"}),totalQuantity:b.decimal({description:"Total/aggregated quantity"}),recordCount:b.int({default:0,description:"Number of records aggregated"}),minQuantity:b.decimal({isOptional:!0,description:"Minimum value"}),maxQuantity:b.decimal({isOptional:!0,description:"Maximum value"}),avgQuantity:b.decimal({isOptional:!0,description:"Average value"}),metadata:b.json({isOptional:!0,description:"Additional metadata"}),createdAt:b.createdAt(),updatedAt:b.updatedAt()},indexes:[K.unique(["metricKey","subjectType","subjectId","periodType","periodStart"],{name:"usage_summary_unique"}),K.on(["subjectType","subjectId","periodType","periodStart"]),K.on(["metricKey","periodType","periodStart"])],enums:[p]}),Bt=C({name:"UsageThreshold",description:"Usage threshold configuration.",schema:"lssm_metering",map:"usage_threshold",fields:{id:b.id({description:"Unique identifier"}),metricKey:b.string({description:"Metric to monitor"}),metricId:b.string({isOptional:!0,description:"Metric ID (for FK)"}),subjectType:b.string({isOptional:!0,description:"Subject type"}),subjectId:b.string({isOptional:!0,description:"Subject identifier"}),name:b.string({description:"Threshold name"}),threshold:b.decimal({description:"Threshold value"}),warnThreshold:b.decimal({isOptional:!0,description:"Warning threshold (e.g., 80%)"}),periodType:b.enum("PeriodType",{default:"MONTHLY",description:"Period to evaluate"}),action:b.enum("ThresholdAction",{default:"ALERT",description:"Action when exceeded"}),notifyEmails:b.json({isOptional:!0,description:"Email addresses to notify"}),notifyWebhook:b.string({isOptional:!0,description:"Webhook URL to call"}),currentValue:b.decimal({default:0,description:"Current usage value"}),lastCheckedAt:b.dateTime({isOptional:!0,description:"Last threshold check"}),lastExceededAt:b.dateTime({isOptional:!0,description:"Last time threshold was exceeded"}),isActive:b.boolean({default:!0,description:"Whether threshold is active"}),metadata:b.json({isOptional:!0,description:"Additional metadata"}),createdAt:b.createdAt(),updatedAt:b.updatedAt()},indexes:[K.on(["metricKey"]),K.on(["subjectType","subjectId"]),K.on(["isActive","metricKey"])],enums:[y]}),Jt=C({name:"UsageAlert",description:"Alert generated when threshold is exceeded.",schema:"lssm_metering",map:"usage_alert",fields:{id:b.id({description:"Unique identifier"}),thresholdId:b.foreignKey({description:"Threshold that triggered alert"}),metricKey:b.string({description:"Metric key"}),subjectType:b.string({isOptional:!0,description:"Subject type"}),subjectId:b.string({isOptional:!0,description:"Subject identifier"}),alertType:b.string({description:"Alert type (warn, exceed, etc.)"}),threshold:b.decimal({description:"Threshold value"}),actualValue:b.decimal({description:"Actual usage value"}),percentageUsed:b.decimal({description:"Percentage of threshold used"}),status:b.string({default:'"pending"',description:"Alert status (pending, acknowledged, resolved)"}),acknowledgedBy:b.string({isOptional:!0,description:"User who acknowledged"}),acknowledgedAt:b.dateTime({isOptional:!0,description:"When acknowledged"}),resolvedAt:b.dateTime({isOptional:!0,description:"When resolved"}),notificationsSent:b.json({isOptional:!0,description:"Notifications sent"}),triggeredAt:b.dateTime({description:"When alert was triggered"}),createdAt:b.createdAt(),thresholdRelation:b.belongsTo("UsageThreshold",["thresholdId"],["id"],{onDelete:"Cascade"})},indexes:[K.on(["thresholdId","status"]),K.on(["metricKey","triggeredAt"]),K.on(["status","triggeredAt"])]}),Xt=[Ct,it,zt,Bt,Jt],_s={moduleId:"@contractspec/lib.metering",entities:Xt,enums:[u,c,p,y]};import{defineEvent as w}from"@contractspec/lib.contracts-spec";import{defineSchemaModel as H,ScalarTypeEnum as j}from"@contractspec/lib.schema";var Yt=H({name:"MetricDefinedEventPayload",description:"Payload when a metric is defined",fields:{metricId:{type:j.String_unsecure(),isOptional:!1},key:{type:j.String_unsecure(),isOptional:!1},name:{type:j.String_unsecure(),isOptional:!1},unit:{type:j.String_unsecure(),isOptional:!1},aggregationType:{type:j.String_unsecure(),isOptional:!1},orgId:{type:j.String_unsecure(),isOptional:!0},createdBy:{type:j.String_unsecure(),isOptional:!0},createdAt:{type:j.DateTime(),isOptional:!1}}}),Zt=H({name:"MetricUpdatedEventPayload",description:"Payload when a metric is updated",fields:{metricId:{type:j.String_unsecure(),isOptional:!1},key:{type:j.String_unsecure(),isOptional:!1},changes:{type:j.JSON(),isOptional:!1},updatedBy:{type:j.String_unsecure(),isOptional:!0},updatedAt:{type:j.DateTime(),isOptional:!1}}}),vt=H({name:"UsageRecordedEventPayload",description:"Payload when usage is recorded",fields:{recordId:{type:j.String_unsecure(),isOptional:!1},metricKey:{type:j.String_unsecure(),isOptional:!1},subjectType:{type:j.String_unsecure(),isOptional:!1},subjectId:{type:j.String_unsecure(),isOptional:!1},quantity:{type:j.Float_unsecure(),isOptional:!1},source:{type:j.String_unsecure(),isOptional:!0},timestamp:{type:j.DateTime(),isOptional:!1}}}),Gt=H({name:"UsageBatchRecordedEventPayload",description:"Payload when a batch of usage is recorded",fields:{recordCount:{type:j.Int_unsecure(),isOptional:!1},metricKeys:{type:j.JSON(),isOptional:!1},totalQuantity:{type:j.Float_unsecure(),isOptional:!1},timestamp:{type:j.DateTime(),isOptional:!1}}}),xt=H({name:"UsageAggregatedEventPayload",description:"Payload when usage is aggregated",fields:{summaryId:{type:j.String_unsecure(),isOptional:!1},metricKey:{type:j.String_unsecure(),isOptional:!1},subjectType:{type:j.String_unsecure(),isOptional:!1},subjectId:{type:j.String_unsecure(),isOptional:!1},periodType:{type:j.String_unsecure(),isOptional:!1},periodStart:{type:j.DateTime(),isOptional:!1},periodEnd:{type:j.DateTime(),isOptional:!1},totalQuantity:{type:j.Float_unsecure(),isOptional:!1},recordCount:{type:j.Int_unsecure(),isOptional:!1},aggregatedAt:{type:j.DateTime(),isOptional:!1}}}),Ot=H({name:"ThresholdCreatedEventPayload",description:"Payload when a threshold is created",fields:{thresholdId:{type:j.String_unsecure(),isOptional:!1},metricKey:{type:j.String_unsecure(),isOptional:!1},subjectType:{type:j.String_unsecure(),isOptional:!0},subjectId:{type:j.String_unsecure(),isOptional:!0},threshold:{type:j.Float_unsecure(),isOptional:!1},action:{type:j.String_unsecure(),isOptional:!1},createdAt:{type:j.DateTime(),isOptional:!1}}}),Nt=H({name:"ThresholdExceededEventPayload",description:"Payload when a threshold is exceeded",fields:{alertId:{type:j.String_unsecure(),isOptional:!1},thresholdId:{type:j.String_unsecure(),isOptional:!1},metricKey:{type:j.String_unsecure(),isOptional:!1},subjectType:{type:j.String_unsecure(),isOptional:!0},subjectId:{type:j.String_unsecure(),isOptional:!0},threshold:{type:j.Float_unsecure(),isOptional:!1},actualValue:{type:j.Float_unsecure(),isOptional:!1},percentageUsed:{type:j.Float_unsecure(),isOptional:!1},action:{type:j.String_unsecure(),isOptional:!1},triggeredAt:{type:j.DateTime(),isOptional:!1}}}),Wt=H({name:"ThresholdApproachingEventPayload",description:"Payload when usage is approaching a threshold",fields:{thresholdId:{type:j.String_unsecure(),isOptional:!1},metricKey:{type:j.String_unsecure(),isOptional:!1},subjectType:{type:j.String_unsecure(),isOptional:!0},subjectId:{type:j.String_unsecure(),isOptional:!0},threshold:{type:j.Float_unsecure(),isOptional:!1},currentValue:{type:j.Float_unsecure(),isOptional:!1},percentageUsed:{type:j.Float_unsecure(),isOptional:!1},triggeredAt:{type:j.DateTime(),isOptional:!1}}}),Mt=w({meta:{key:"metric.defined",version:"1.0.0",description:"A metric has been defined.",stability:"stable",owners:["@platform.metering"],tags:["metering","metric"]},payload:Yt}),ht=w({meta:{key:"metric.updated",version:"1.0.0",description:"A metric has been updated.",stability:"stable",owners:["@platform.metering"],tags:["metering","metric"]},payload:Zt}),nt=w({meta:{key:"usage.recorded",version:"1.0.0",description:"Usage has been recorded.",stability:"stable",owners:["@platform.metering"],tags:["metering","usage"]},payload:vt}),ft=w({meta:{key:"usage.batch_recorded",version:"1.0.0",description:"A batch of usage has been recorded.",stability:"stable",owners:["@platform.metering"],tags:["metering","usage"]},payload:Gt}),ut=w({meta:{key:"usage.aggregated",version:"1.0.0",description:"Usage has been aggregated into a summary.",stability:"stable",owners:["@platform.metering"],tags:["metering","usage"]},payload:xt}),ct=w({meta:{key:"threshold.created",version:"1.0.0",description:"A usage threshold has been created.",stability:"stable",owners:["@platform.metering"],tags:["metering","threshold"]},payload:Ot}),pt=w({meta:{key:"threshold.exceeded",version:"1.0.0",description:"Usage has exceeded a threshold.",stability:"stable",owners:["@platform.metering"],tags:["metering","threshold"]},payload:Nt}),yt=w({meta:{key:"threshold.approaching",version:"1.0.0",description:"Usage is approaching a threshold.",stability:"stable",owners:["@platform.metering"],tags:["metering","threshold"]},payload:Wt}),et=H({name:"ModelSelectionEventPayload",description:"Payload when an AI model is selected via ranking",fields:{modelId:{type:j.String_unsecure(),isOptional:!1},providerKey:{type:j.String_unsecure(),isOptional:!1},dimension:{type:j.String_unsecure(),isOptional:!0},score:{type:j.Float_unsecure(),isOptional:!1},reason:{type:j.String_unsecure(),isOptional:!1},alternativesCount:{type:j.Int_unsecure(),isOptional:!1},costEstimateInput:{type:j.Float_unsecure(),isOptional:!0},costEstimateOutput:{type:j.Float_unsecure(),isOptional:!0},selectionDurationMs:{type:j.Float_unsecure(),isOptional:!0},timestamp:{type:j.DateTime(),isOptional:!1}}}),dt=w({meta:{key:"model.selected",version:"1.0.0",description:"An AI model has been selected via ranking-driven selection.",stability:"experimental",owners:["@platform.metering"],tags:["metering","ai","model-selection"]},payload:et}),Us={MetricDefinedEvent:Mt,MetricUpdatedEvent:ht,UsageRecordedEvent:nt,UsageBatchRecordedEvent:ft,UsageAggregatedEvent:ut,ThresholdCreatedEvent:ct,ThresholdExceededEvent:pt,ThresholdApproachingEvent:yt,ModelSelectionEvent:dt};import{defineFeature as Tt}from"@contractspec/lib.contracts-spec";var Cs=Tt({meta:{key:"metrics",version:"1.0.0",title:"Usage Metering",description:"Usage metering, metric definitions, and threshold alerting",domain:"platform",owners:["@platform.metering"],tags:["metering","usage","billing","thresholds"],stability:"stable"},operations:[{key:"metric.define",version:"1.0.0"},{key:"metric.update",version:"1.0.0"},{key:"metric.delete",version:"1.0.0"},{key:"metric.get",version:"1.0.0"},{key:"metric.list",version:"1.0.0"},{key:"usage.record",version:"1.0.0"},{key:"usage.recordBatch",version:"1.0.0"},{key:"usage.get",version:"1.0.0"},{key:"usage.getSummary",version:"1.0.0"},{key:"threshold.create",version:"1.0.0"},{key:"threshold.update",version:"1.0.0"},{key:"threshold.delete",version:"1.0.0"},{key:"threshold.list",version:"1.0.0"}],events:[{key:"metric.defined",version:"1.0.0"},{key:"metric.updated",version:"1.0.0"},{key:"usage.recorded",version:"1.0.0"},{key:"usage.batch_recorded",version:"1.0.0"},{key:"usage.aggregated",version:"1.0.0"},{key:"threshold.created",version:"1.0.0"},{key:"threshold.exceeded",version:"1.0.0"},{key:"threshold.approaching",version:"1.0.0"},{key:"model.selected",version:"1.0.0"}],presentations:[],opToPresentation:[],presentationsTargets:[],capabilities:{provides:[{key:"metering",version:"1.0.0"},{key:"thresholds",version:"1.0.0"}],requires:[]}});export{_s as meteringSchemaContribution,Xt as meteringEntities,Z as getPeriodStart,N as getPeriodEnd,e as formatPeriodKey,x as UsageThresholdModel,Bt as UsageThresholdEntity,jt as UsageSummaryModel,zt as UsageSummaryEntity,nt as UsageRecordedEvent,h as UsageRecordModel,it as UsageRecordEntity,ft as UsageBatchRecordedEvent,Jt as UsageAlertEntity,T as UsageAggregator,ut as UsageAggregatedEvent,Qs as UpdateThresholdContract,ss as UpdateMetricContract,pt as ThresholdExceededEvent,ct as ThresholdCreatedEvent,yt as ThresholdApproachingEvent,y as ThresholdActionEnum,c as ResetPeriodEnum,Is as RecordUsageContract,rs as RecordBatchUsageContract,bt as PosthogMeteringReporter,m as PosthogMeteringReader,p as PeriodTypeEnum,dt as ModelSelectionEvent,ht as MetricUpdatedEvent,B as MetricDefinitionModel,Ct as MetricDefinitionEntity,Mt as MetricDefinedEvent,Cs as MeteringFeature,Us as MeteringEvents,Ks as ListThresholdsContract,js as ListMetricsContract,S as InMemoryUsageStorage,As as GetUsageSummaryContract,os as GetUsageContract,bs as GetMetricContract,ks as DeleteThresholdContract,gs as DeleteMetricContract,ts as DefineMetricContract,Rs as CreateThresholdContract,u as AggregationTypeEnum};