nuxt-observe 0.0.2

package/dist/schema.mjs

@@ -0,0 +1,629 @@
+import { z } from 'zod';
+import { createHash } from 'node:crypto';
+
+const CANONICAL_LEVELS = {
+  0: "error",
+  1: "warn",
+  2: "notice",
+  // frogger alias: 'log'
+  3: "info",
+  4: "debug",
+  5: "trace"
+};
+const zLevel = z.number().int().min(0).max(5);
+const FROGGER_LEVEL_MAP = {
+  0: 0,
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  5: 5
+};
+const NAME_TO_LEVEL = {
+  fatal: 0,
+  error: 0,
+  warn: 1,
+  log: 2,
+  notice: 2,
+  info: 3,
+  success: 3,
+  fail: 3,
+  ready: 3,
+  start: 3,
+  debug: 4,
+  trace: 5
+};
+const SYSLOG_TO_CANONICAL = {
+  0: 0,
+  // Emergency
+  1: 0,
+  // Alert
+  2: 0,
+  // Critical
+  3: 0,
+  // Error
+  4: 1,
+  // Warning
+  5: 2,
+  // Notice
+  6: 3,
+  // Informational
+  7: 4
+  // Debug
+};
+function otelSeverityToCanonical(severityNumber) {
+  if (severityNumber >= 21) return 0;
+  if (severityNumber >= 17) return 0;
+  if (severityNumber >= 13) return 1;
+  if (severityNumber >= 9) return 3;
+  if (severityNumber >= 5) return 4;
+  return 5;
+}
+function levelName(n) {
+  return CANONICAL_LEVELS[n] ?? "unknown";
+}
+function parseLevel(input) {
+  if (typeof input === "string") {
+    const byName = NAME_TO_LEVEL[input.toLowerCase()];
+    return byName ?? null;
+  }
+  if (input === 999) return 5;
+  if (input === -999) return null;
+  if (Number.isInteger(input) && input >= 0 && input <= 5) return input;
+  return null;
+}
+
+const TRACE_ID_RE$1 = /^[0-9a-f]{32}$/;
+const SPAN_ID_RE = /^[0-9a-f]{16}$/;
+const zErrorInfo = z.object({
+  name: z.string(),
+  message: z.string(),
+  stack: z.string().optional(),
+  code: z.union([z.string(), z.number()]).optional()
+  // frogger statusCode is number; app codes may be string
+});
+const zTraceContext = z.object({
+  traceId: z.string().regex(TRACE_ID_RE$1),
+  spanId: z.string().regex(SPAN_ID_RE),
+  parentId: z.string().regex(SPAN_ID_RE).optional()
+  // frogger's trace.flags is intentionally dropped here; see frogger-map.ts.
+});
+const zSource = z.object({
+  app: z.string().min(1),
+  // required WHEN source is present
+  version: z.string().optional(),
+  env: z.string().optional()
+  // frogger execution context (ssr/csr/client/server); see caveat in frogger-map.ts
+});
+const zCanonicalEvent = z.object({
+  time: z.number().int().positive(),
+  // ms epoch
+  level: zLevel,
+  message: z.string().min(1),
+  error: zErrorInfo.optional(),
+  trace: zTraceContext.optional(),
+  source: zSource.optional(),
+  // optional so the minimal stream tier ({time,level,message}) parses
+  session: z.string().optional(),
+  user: z.string().optional(),
+  route: z.string().optional(),
+  feature: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  ctx: z.record(z.string(), z.unknown()).optional()
+  // zod v4: record REQUIRES (keyType, valueType)
+});
+
+const MAX_BATCH_EVENTS = 500;
+const zCanonicalBatch = z.object({
+  events: z.array(zCanonicalEvent).max(MAX_BATCH_EVENTS),
+  // empty allowed: a valid no-op batch
+  meta: z.record(z.string(), z.unknown()).optional()
+  // frogger meta.{processed,processChain,source,time} passes through
+});
+
+const PROGRESSIVE_TIERS = ["stream", "grouping", "journey", "activity", "rollout"];
+function classifyTiers(event) {
+  const tiers = ["stream"];
+  if (event.error) tiers.push("grouping");
+  if (event.trace?.traceId) tiers.push("journey");
+  if (event.session || event.route || event.feature) tiers.push("activity");
+  if (event.source?.version) tiers.push("rollout");
+  return tiers;
+}
+
+const FROGGER_FIELD_MAP = {
+  log: {
+    "time": "time",
+    "lvl": "level",
+    "type": "(dropped: redundant with lvl)",
+    "msg": "message",
+    "ctx": "ctx (+ derived: error/session/user/route/feature)",
+    "tags": "tags",
+    "env": "source.env",
+    "source.name": "source.app",
+    "source.version": "source.version",
+    "trace.traceId": "trace.traceId",
+    "trace.spanId": "trace.spanId",
+    "trace.parentId": "trace.parentId",
+    "trace.flags": "(dropped: canonical omits flags)"
+  },
+  batch: {
+    "logs": "events",
+    "app.name": "source.app",
+    "app.version": "source.version",
+    "meta": "meta (passthrough)"
+  },
+  ctxDerived: {
+    "ctx.error": "error",
+    "ctx.session": "session",
+    "ctx.user": "user",
+    "ctx.route": "route",
+    "ctx.feature": "feature"
+  }
+};
+
+const zFroggerLog = z.object({
+  time: z.number(),
+  lvl: z.number(),
+  type: z.string().optional(),
+  msg: z.string(),
+  ctx: z.record(z.string(), z.unknown()).optional(),
+  tags: z.array(z.string()).optional(),
+  env: z.string().optional(),
+  source: z.object({ name: z.string().optional(), version: z.string().optional() }).partial().optional(),
+  trace: z.object({ traceId: z.string(), spanId: z.string(), parentId: z.string().optional() }).partial().optional()
+}).passthrough();
+const zFroggerBatch = z.object({
+  logs: z.array(zFroggerLog).min(1),
+  app: z.object({ name: z.string(), version: z.string() }).partial().optional(),
+  meta: z.object({}).passthrough().optional()
+}).passthrough();
+
+const SERVICE_TYPES = ["website", "webapp", "api", "service", "worker", "mobile", "other"];
+const serviceTypeSchema = z.enum(SERVICE_TYPES);
+const SERVICE_KINDS = ["server", "browser"];
+const serviceKindSchema = z.enum(SERVICE_KINDS);
+const SERVICE_TYPE_META = {
+  website: { label: "Website", icon: "i-lucide-globe" },
+  webapp: { label: "Web app", icon: "i-lucide-app-window" },
+  api: { label: "API", icon: "i-lucide-webhook" },
+  service: { label: "Service", icon: "i-lucide-server" },
+  worker: { label: "Worker", icon: "i-lucide-cog" },
+  mobile: { label: "Mobile", icon: "i-lucide-smartphone" },
+  other: { label: "Other", icon: "i-lucide-box" }
+};
+function serviceTypeMeta(type) {
+  return SERVICE_TYPE_META[type] ?? SERVICE_TYPE_META.other;
+}
+const originSchema = z.string().refine(
+  (v) => v === "*" || /^https?:\/\/[^/\s]+$/.test(v),
+  { message: 'must be an http(s) origin (e.g. https://app.example.com) or "*"' }
+);
+const serviceCreateSchema = z.object({
+  name: z.string().min(1).max(80),
+  type: serviceTypeSchema.default("service"),
+  kind: serviceKindSchema.default("server"),
+  appNames: z.array(z.string().min(1)).min(1),
+  allowedOrigins: z.array(originSchema).default([]),
+  env: z.string().max(40).optional(),
+  versionTracking: z.boolean().optional()
+}).refine((s) => !(s.allowedOrigins.length && s.kind === "server"), {
+  path: ["allowedOrigins"],
+  message: 'allowedOrigins requires kind="browser"'
+});
+const serviceUpdateSchema = z.object({
+  name: z.string().min(1).max(80).optional(),
+  type: serviceTypeSchema.optional(),
+  kind: serviceKindSchema.optional(),
+  appNames: z.array(z.string().min(1)).min(1).optional(),
+  allowedOrigins: z.array(originSchema).optional(),
+  env: z.string().max(40).nullable().optional(),
+  groupId: z.string().nullable().optional(),
+  versionTracking: z.boolean().optional(),
+  currentVersion: z.string().nullable().optional()
+});
+const keyCreateSchema = z.object({ label: z.string().min(1).max(60) });
+const groupCreateSchema = z.object({ name: z.string().min(1).max(80) });
+const groupUpdateSchema = z.object({ name: z.string().min(1).max(80) });
+const groupMembershipSchema = z.object({ serviceIds: z.array(z.string().min(1)) });
+const assignmentSchema = z.object({ userIds: z.array(z.string().min(1)) });
+const serviceIdParams = z.object({ id: z.string().min(1) });
+const keyIdParams = z.object({ id: z.string().min(1), keyId: z.string().min(1) });
+const groupIdParams = z.object({ id: z.string().min(1) });
+
+const zServiceSeed = z.object({
+  slug: z.string().min(1),
+  name: z.string().min(1),
+  type: serviceTypeSchema.default("service"),
+  kind: z.enum(["server", "browser"]).default("server"),
+  appNames: z.array(z.string().min(1)).default([]),
+  allowedOrigins: z.array(z.string().min(1)).default([]),
+  // browser origins, or the literal '*'
+  env: z.string().optional(),
+  versionTracking: z.boolean().optional(),
+  currentVersion: z.string().optional(),
+  group: z.string().optional(),
+  // group slug
+  key: z.string().optional()
+  // raw ingest key (from env); hashed at seed time, never stored raw
+  // Declaring allowedOrigins implies a browser source: coerce rather than hard-error for friendlier config.
+}).transform((s) => s.allowedOrigins.length && s.kind === "server" ? { ...s, kind: "browser" } : s);
+const zGroupSeed = z.object({
+  slug: z.string().min(1),
+  name: z.string().min(1)
+});
+const zObserveSeedConfig = z.object({
+  services: z.array(zServiceSeed).optional(),
+  groups: z.array(zGroupSeed).optional()
+});
+
+const PERIODS = ["15m", "1h", "24h", "7d", "30d"];
+
+const overviewQuerySchema = z.object({
+  period: z.enum(PERIODS).default("24h"),
+  /** service slug; resolved to an id and intersected with the caller's scope */
+  service: z.string().optional(),
+  /** group slug; expanded to member service ids and intersected with the caller's scope */
+  group: z.string().optional()
+});
+
+const statsQuerySchema = z.object({
+  period: z.enum(PERIODS).default("24h"),
+  /** service slug; resolved to an id and intersected with the caller's scope */
+  service: z.string().optional(),
+  /** group slug; expanded to member service ids and intersected with the caller's scope */
+  group: z.string().optional(),
+  /** exact version filter (rides idx_logs_version) */
+  version: z.string().optional(),
+  /** exact-level filter, 0..5 */
+  level: z.coerce.number().int().min(0).max(5).optional(),
+  /** advanced bucket-size override in ms; rejected with 400 when it yields > 500 buckets */
+  bucketMs: z.coerce.number().int().positive().optional()
+});
+
+const csvLevels = z.string().transform((s) => s.split(",").map((v) => v.trim()).filter((v) => v.length > 0).map(Number)).pipe(z.array(z.number().int().min(0).max(5)).min(1).max(6)).optional();
+const csvStrings = z.string().transform((s) => s.split(",").map((v) => v.trim()).filter((v) => v.length > 0)).pipe(z.array(z.string().min(1).max(100)).min(1).max(20)).optional();
+const logsQuerySchema = z.object({
+  period: z.enum(PERIODS).default("24h"),
+  /** service slug; resolved to an id and intersected with the caller's scope */
+  service: z.string().optional(),
+  /** group slug; expanded to member service ids and intersected with the caller's scope */
+  group: z.string().optional(),
+  /** CSV of exact levels, e.g. "0,1" -> level IN (0,1) */
+  levels: csvLevels,
+  /** CSV of exact versions -> version IN (...) */
+  versions: csvStrings,
+  /** exact route filter, e.g. from the activity drill-through (CP10) */
+  route: z.string().min(1).max(200).optional(),
+  /** exact feature filter, e.g. from the activity drill-through (CP10) */
+  feature: z.string().min(1).max(200).optional(),
+  /** free-text message search; message LIKE %q% ESCAPE '\' */
+  q: z.string().trim().min(1).max(200).optional(),
+  /** exact trace id; when present the period window is NOT applied (see handler §3.3) */
+  traceId: z.string().min(1).max(64).optional(),
+  limit: z.coerce.number().int().min(1).max(200).default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+const logsFacetsQuerySchema = z.object({
+  service: z.string().optional(),
+  group: z.string().optional()
+});
+function parseJson(raw, guard) {
+  if (raw == null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return guard(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+const isStringArray = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function rowToDetail(row) {
+  const error = row.error_name || row.error_message || row.error_stack || row.error_code ? {
+    ...row.error_name ? { name: row.error_name } : {},
+    ...row.error_message ? { message: row.error_message } : {},
+    ...row.error_stack ? { stack: row.error_stack } : {},
+    ...row.error_code ? { code: row.error_code } : {}
+  } : null;
+  const trace = row.trace_id || row.span_id || row.parent_id ? {
+    ...row.trace_id ? { traceId: row.trace_id } : {},
+    ...row.span_id ? { spanId: row.span_id } : {},
+    ...row.parent_id ? { parentId: row.parent_id } : {}
+  } : null;
+  return {
+    id: row.id,
+    time: row.time,
+    received_at: row.received_at,
+    level: row.level,
+    message: row.message,
+    app: row.app,
+    version: row.version ?? null,
+    env: row.env ?? null,
+    service_id: row.service_id ?? null,
+    session: row.session ?? null,
+    user: row.user ?? null,
+    route: row.route ?? null,
+    feature: row.feature ?? null,
+    error,
+    trace,
+    tags: parseJson(row.tags, isStringArray),
+    ctx: parseJson(row.ctx, isObject)
+  };
+}
+
+const ACTIVITY_DIMENSIONS = ["auto", "route", "feature"];
+const ACTIVITY_SORTS = ["count", "errors", "errorRate", "lastSeen"];
+const activityQuerySchema = z.object({
+  period: z.enum(PERIODS).default("24h"),
+  /** service slug; resolved to an id and intersected with the caller's scope */
+  service: z.string().optional(),
+  /** group slug; expanded to member service ids and intersected with the caller's scope */
+  group: z.string().optional(),
+  /** grouping dimension; auto = COALESCE(route, feature) */
+  dimension: z.enum(ACTIVITY_DIMENSIONS).default("auto"),
+  /** exact env filter */
+  env: z.string().optional(),
+  /** exact-level filter, 0..5 (mirrors statsQuerySchema, CP8 D3) */
+  level: z.coerce.number().int().min(0).max(5).optional(),
+  /** substring match on the key; escaped LIKE (shared escapeLike) */
+  q: z.string().trim().min(1).max(200).optional(),
+  sort: z.enum(ACTIVITY_SORTS).default("count"),
+  /** rejected with 400 past the ceiling, never silently clamped */
+  limit: z.coerce.number().int().min(1).max(200).default(50)
+});
+
+const TRACE_ID_RE = /^[0-9a-f]{32}$/;
+const ALL_ZERO_TRACE = "00000000000000000000000000000000";
+function isValidTraceId(traceId) {
+  return typeof traceId === "string" && TRACE_ID_RE.test(traceId) && traceId !== ALL_ZERO_TRACE;
+}
+const journeyQuerySchema = z.object({
+  traceId: z.string().optional(),
+  session: z.string().min(1).max(200).optional(),
+  user: z.string().min(1).max(200).optional(),
+  from: z.coerce.number().int().positive().optional(),
+  to: z.coerce.number().int().positive().optional(),
+  limit: z.coerce.number().int().min(1).max(5e3).default(2e3)
+}).superRefine((v, ctx) => {
+  const present = [v.traceId, v.session, v.user].filter((x) => x !== void 0);
+  if (present.length !== 1) {
+    ctx.addIssue({ code: "custom", message: "Provide exactly one of traceId, session, or user" });
+    return;
+  }
+  if (v.traceId !== void 0 && !isValidTraceId(v.traceId)) {
+    ctx.addIssue({ code: "custom", path: ["traceId"], message: "traceId must be 32 lowercase hex, non-zero" });
+  }
+});
+function journeyMode(q) {
+  if (q.traceId !== void 0) return { mode: "trace", key: q.traceId };
+  if (q.session !== void 0) return { mode: "session", key: q.session };
+  return { mode: "user", key: q.user };
+}
+const MODE_PARAM = {
+  trace: "traceId",
+  session: "session",
+  user: "user"
+};
+function computeJourneyStats(events) {
+  if (events.length === 0) {
+    return { count: 0, start: null, end: null, durationMs: 0, services: [], levels: {} };
+  }
+  let start = events[0].time;
+  let end = events[0].time;
+  const services = [];
+  const seen = /* @__PURE__ */ new Set();
+  const levels = {};
+  for (const e of events) {
+    if (e.time < start) start = e.time;
+    if (e.time > end) end = e.time;
+    if (e.app && !seen.has(e.app)) {
+      seen.add(e.app);
+      services.push(e.app);
+    }
+    const name = levelName(e.level);
+    levels[name] = (levels[name] ?? 0) + 1;
+  }
+  return { count: events.length, start, end, durationMs: end - start, services, levels };
+}
+function detectPartial(events, hitLimit) {
+  const reasons = /* @__PURE__ */ new Set();
+  if (events.length === 0) reasons.add("empty");
+  const spans = new Set(events.map((e) => e.spanId).filter(Boolean));
+  for (const e of events) {
+    if (!e.hasTrace) reasons.add("missing-correlation");
+    if (e.parentId && !spans.has(e.parentId)) reasons.add("dangling-parent");
+  }
+  if (hitLimit) reasons.add("truncated");
+  return { partial: reasons.size > 0, reasons: [...reasons] };
+}
+function buildSpanTree(events) {
+  const bySpan = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.spanId) bySpan.set(e.spanId, { event: e, children: [], depth: 0 });
+  }
+  const roots = [];
+  for (const e of events) {
+    const node = e.spanId ? bySpan.get(e.spanId) : { event: e, children: [], depth: 0 };
+    const parent = e.parentId ? bySpan.get(e.parentId) : void 0;
+    if (parent && parent !== node) parent.children.push(node);
+    else roots.push(node);
+  }
+  const walk = (n, d) => {
+    n.depth = d;
+    n.children.sort((a, b) => a.event.time - b.event.time);
+    n.children.forEach((c) => walk(c, d + 1));
+  };
+  roots.sort((a, b) => a.event.time - b.event.time);
+  roots.forEach((r) => walk(r, 0));
+  return roots;
+}
+function flattenSpanTree(roots) {
+  const out = [];
+  const walk = (n) => {
+    out.push({ event: n.event, depth: n.depth });
+    n.children.forEach(walk);
+  };
+  roots.forEach(walk);
+  return out;
+}
+
+const UNVERSIONED = "(unversioned)";
+const rolloutQuerySchema = z.object({
+  period: z.enum(PERIODS).default("24h"),
+  /** service slug; resolved to an id and intersected with the caller's scope */
+  service: z.string().optional(),
+  /** group slug; expanded to member ids and intersected with the caller's scope */
+  group: z.string().optional(),
+  /** exact env filter on the log row (matches stats' row-level env) */
+  env: z.string().optional(),
+  /** compare-only bucket-size override in ms; rejected with 400 when it yields > 500 buckets */
+  bucketMs: z.coerce.number().int().positive().optional()
+});
+function pivotVersionSeries(rows, from, to, bucketMs) {
+  const bFrom = Math.floor(from / bucketMs);
+  const bTo = Math.floor(to / bucketMs);
+  const len = Math.max(0, bTo - bFrom + 1);
+  const buckets = [];
+  for (let i = 0; i < len; i++) buckets.push((bFrom + i) * bucketMs);
+  const byVersion = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const idx = row.b - bFrom;
+    if (idx < 0 || idx >= len) continue;
+    let acc = byVersion.get(row.version);
+    if (!acc) {
+      acc = { volume: Array(len).fill(0), errors: Array(len).fill(0), total: 0 };
+      byVersion.set(row.version, acc);
+    }
+    const errors = row.errors ?? 0;
+    acc.volume[idx] = (acc.volume[idx] ?? 0) + row.total;
+    acc.errors[idx] = (acc.errors[idx] ?? 0) + errors;
+    acc.total += row.total;
+  }
+  const series = [...byVersion.entries()].sort((a, b) => b[1].total - a[1].total || a[0].localeCompare(b[0])).map(([version, acc]) => ({
+    version,
+    volume: acc.volume,
+    errorRate: acc.volume.map((v, i) => v ? acc.errors[i] / v : 0)
+  }));
+  return { buckets, series };
+}
+function detectRegressions(stats, config, now) {
+  const { minEvents, errorRateDelta, errorRateMultiplier, baselineWindowMs } = config;
+  const eligible = stats.filter((s) => s.version !== UNVERSIONED && s.total >= minEvents);
+  if (eligible.length < 2) return [];
+  const sorted = [...eligible].sort((a, b) => a.firstSeen - b.firstSeen);
+  const candidate = sorted[sorted.length - 1];
+  if (baselineWindowMs != null && candidate.firstSeen < now - baselineWindowMs) return [];
+  const earlier = sorted.filter((s) => s.firstSeen < candidate.firstSeen);
+  if (earlier.length === 0) return [];
+  const baseline = earlier.reduce((best, s) => s.total > best.total ? s : best);
+  const delta = candidate.errorRate - baseline.errorRate;
+  const ratio = baseline.errorRate === 0 ? Infinity : candidate.errorRate / baseline.errorRate;
+  const passesMultiplier = baseline.errorRate === 0 || candidate.errorRate >= baseline.errorRate * errorRateMultiplier;
+  if (delta < errorRateDelta || !passesMultiplier) return [];
+  return [{
+    version: candidate.version,
+    errorRate: candidate.errorRate,
+    baselineVersion: baseline.version,
+    baselineErrorRate: baseline.errorRate,
+    delta,
+    ratio,
+    sampleSize: candidate.total,
+    severity: delta >= 2 * errorRateDelta ? "critical" : "warn"
+  }];
+}
+
+const VERSION = "v1";
+const DEFAULT_TOP_FRAMES = 3;
+function normalizeMessage(message) {
+  return message.replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g, "<ts>").replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "<uuid>").replace(/\b[0-9a-f]{8,}\b/gi, "<hex>").replace(/\b[a-z][a-z0-9+.-]*:\/\/[^\s'"]+/gi, "<path>").replace(/(?:[a-z]:\\|\.{0,2}\/)[^\s'"]*[^\s'".,;:]/gi, "<path>").replace(/'[^']*'/g, "<str>").replace(/"[^"]*"/g, "<str>").replace(/-?\d+(?:\.\d+)?/g, "<n>").trim();
+}
+const ANON_RE = /<anonymous>|\beval\b|\[native code\]/i;
+function normalizeFrame(line) {
+  const trimmed = line.trim().replace(/^at\s+/, "").replace(/^async\s+/, "");
+  if (!trimmed) return null;
+  const open = trimmed.lastIndexOf(" (");
+  let fn = "";
+  let loc = trimmed;
+  if (open > 0 && trimmed.endsWith(")")) {
+    fn = trimmed.slice(0, open).trim();
+    loc = trimmed.slice(open + 2, -1).trim();
+  }
+  if (loc.startsWith("node:") || /^(?:internal|native)\b/.test(loc)) return null;
+  if (ANON_RE.test(fn) || ANON_RE.test(loc)) return null;
+  loc = loc.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]+/i, "");
+  loc = loc.replace(/(?::\d+)+$/, "");
+  const base = loc.split(/[\\/]/).pop() ?? loc;
+  const cleaned = base.replace(/\.[0-9a-f]{6,}(?=\.[a-z0-9]+$)/i, "");
+  if (!cleaned) return fn || null;
+  return fn ? `${fn} (${cleaned})` : cleaned;
+}
+function normalizeStack(stack, topFrames) {
+  if (!stack) return [];
+  const out = [];
+  for (const line of stack.split("\n")) {
+    if (!/^\s*at\s+/.test(line)) continue;
+    const frame = normalizeFrame(line);
+    if (frame) out.push(frame);
+    if (out.length >= topFrames) break;
+  }
+  return out;
+}
+function fingerprintError(err, opts = {}) {
+  const topFrames = opts.topFrames ?? DEFAULT_TOP_FRAMES;
+  const name = err.name ?? "";
+  const code = String(err.code ?? "");
+  const normalizedMessage = normalizeMessage(err.message ?? "");
+  const frames = normalizeStack(err.stack, topFrames);
+  const input = [name, code, normalizedMessage, frames.join("\n")].join("|");
+  const hash = createHash("sha1").update(input).digest("hex").slice(0, 16);
+  return { fingerprint: `${VERSION}:${hash}`, version: VERSION, normalizedMessage, frames };
+}
+
+const NULL_VERSION = "(unversioned)";
+const ERROR_SORTS = ["recent", "count", "first"];
+const errorsQuerySchema = z.object({
+  period: z.enum(PERIODS).default("24h"),
+  /** service slug; resolved to an id and intersected with the caller's scope */
+  service: z.string().optional(),
+  /** group slug; expanded to member service ids and intersected with the caller's scope */
+  group: z.string().optional(),
+  /** exact source-app filter */
+  app: z.string().min(1).max(200).optional(),
+  /** exact version filter */
+  version: z.string().min(1).max(200).optional(),
+  /** exact env filter */
+  env: z.string().min(1).max(200).optional(),
+  /** exact level filter, 0..5 */
+  level: z.coerce.number().int().min(0).max(5).optional(),
+  /** free-text search over the representative error message; LIKE %q% ESCAPE '\' */
+  q: z.string().trim().min(1).max(200).optional(),
+  sort: z.enum(ERROR_SORTS).default("recent"),
+  limit: z.coerce.number().int().min(1).max(200).default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+const errorDetailQuerySchema = z.object({
+  period: z.enum(PERIODS).default("24h"),
+  service: z.string().optional(),
+  group: z.string().optional(),
+  /** advanced bucket-size override in ms for the occurrences chart; > 500 buckets is a 400 */
+  bucketMs: z.coerce.number().int().positive().optional(),
+  limit: z.coerce.number().int().min(1).max(200).default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+const DEFAULT_REGRESSION_THRESHOLDS = {
+  activeWindowMs: 864e5,
+  // 24h
+  regressionGapMs: 2592e5
+  // 72h
+};
+function isRegressed(row, thresholds, now) {
+  const activeStart = now - thresholds.activeWindowMs;
+  return row.lastSeen >= activeStart && row.firstInActive != null && row.prevBeforeActive != null && row.firstInActive - row.prevBeforeActive >= thresholds.regressionGapMs;
+}
+function splitConcat(value) {
+  if (!value) return [];
+  return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+
+export { ACTIVITY_DIMENSIONS, ACTIVITY_SORTS, CANONICAL_LEVELS, DEFAULT_REGRESSION_THRESHOLDS, ERROR_SORTS, FROGGER_FIELD_MAP, FROGGER_LEVEL_MAP, MAX_BATCH_EVENTS, MODE_PARAM, NAME_TO_LEVEL, NULL_VERSION, PROGRESSIVE_TIERS, SERVICE_KINDS, SERVICE_TYPES, SERVICE_TYPE_META, SYSLOG_TO_CANONICAL, UNVERSIONED, activityQuerySchema, assignmentSchema, buildSpanTree, classifyTiers, computeJourneyStats, detectPartial, detectRegressions, errorDetailQuerySchema, errorsQuerySchema, fingerprintError, flattenSpanTree, groupCreateSchema, groupIdParams, groupMembershipSchema, groupUpdateSchema, isRegressed, isValidTraceId, journeyMode, journeyQuerySchema, keyCreateSchema, keyIdParams, levelName, logsFacetsQuerySchema, logsQuerySchema, normalizeFrame, normalizeMessage, normalizeStack, otelSeverityToCanonical, overviewQuerySchema, parseLevel, pivotVersionSeries, rolloutQuerySchema, rowToDetail, serviceCreateSchema, serviceIdParams, serviceKindSchema, serviceTypeMeta, serviceTypeSchema, serviceUpdateSchema, splitConcat, statsQuerySchema, zCanonicalBatch, zCanonicalEvent, zErrorInfo, zFroggerBatch, zFroggerLog, zGroupSeed, zLevel, zObserveSeedConfig, zServiceSeed, zSource, zTraceContext };

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { type ModuleOptions } from '../dist/runtime/shared/types/module-options.js'
+
+export { default } from './module.mjs'