react-semaphor 0.1.498 → 0.1.499

package/dist/chunks/{validators-CvLOGzT3.js → validators-CHlnnHuS.js}

@@ -1,16 +1,16 @@
 import { z as i } from "zod";
-const jt = [
+const Ot = [
   "missing_dependency",
   "missing_relationship",
   "population_required",
   "ambiguous_relationship"
 ];
-function Wn(e) {
-  return jt.includes(
+function ea(e) {
+  return Ot.includes(
     e
   );
 }
-const Re = 200, G = [
+const De = 200, z = [
   "second",
   "minute",
   "hour",
@@ -20,44 +20,44 @@ const Re = 200, G = [
   "quarter",
   "year"
 ];
-function Xn(e) {
-  return typeof e == "string" && G.includes(e);
+function ta(e) {
+  return typeof e == "string" && z.includes(e);
 }
-const $t = [
+const Yt = [
   "week_of_short",
   "week_of_long",
   "quarter_short",
   "quarter_long",
   "fiscal_quarter_short",
   "fiscal_year"
-], Zn = {
+], ia = {
   invalidMetadata: "invalid_raw_temporal_metadata"
 };
-function Ct(e) {
+function Pt(e) {
   return e === "second" || e === "minute" || e === "hour" ? "datetime" : "date";
 }
-const Jn = {
+const na = {
   missingMetadata: "missing_temporal_bucket_metadata",
   invalidMetadata: "invalid_temporal_bucket_metadata",
   invalidValue: "invalid_temporal_bucket_value"
-}, ea = "__auto_count__";
-function Ot(e) {
+}, aa = "__auto_count__";
+function Bt(e) {
   return typeof e == "string" || typeof e == "number" && Number.isFinite(e) || typeof e == "boolean";
 }
-function Yt(e) {
-  return !Array.isArray(e) || e.length === 0 || e.length > Re || !e.every(Ot) ? {
+function qt(e) {
+  return !Array.isArray(e) || e.length === 0 || e.length > De || !e.every(Bt) ? {
     ok: !1,
-    error: `matchValues must be 1 to ${Re} string, number or boolean values.`
+    error: `matchValues must be 1 to ${De} string, number or boolean values.`
   } : { ok: !0, values: e };
 }
-function Pt(e) {
+function Lt(e) {
   try {
     return new Intl.DateTimeFormat("en-US", { timeZone: e }).format(), !0;
   } catch {
     return !1;
   }
 }
-const Bt = i.record(i.string(), i.unknown()), O = i.array(Bt), F = i.enum([
+const Ut = i.record(i.string(), i.unknown()), O = i.array(Ut), R = i.enum([
   "SUM",
   "COUNT",
   "AVG",
@@ -65,7 +65,7 @@ const Bt = i.record(i.string(), i.unknown()), O = i.array(Bt), F = i.enum([
   "MAX",
   "MEDIAN",
   "DISTINCT"
-]), z = i.enum([
+]), K = i.enum([
   "postgres",
   "mysql",
   "mssql",
@@ -76,40 +76,40 @@ const Bt = i.record(i.string(), i.unknown()), O = i.array(Bt), F = i.enum([
   "duckdb",
   "sqlite",
   "unknown"
-]), L = i.enum(G), K = i.enum([
+]), U = i.enum(z), Q = i.enum([
   "dimension",
   "measure",
   "date",
   "id",
   "unknown"
-]), Q = i.enum([
+]), W = i.enum([
   "string",
   "number",
   "boolean",
   "date",
   "datetime",
   "unknown"
-]), ee = i.union([i.number(), i.string(), i.null()]), te = i.enum([
+]), te = i.union([i.number(), i.string(), i.null()]), ie = i.enum([
   "millisecond",
   "second",
   "minute",
   "hour",
   "day"
-]), qt = i.enum($t), Lt = i.discriminatedUnion("mode", [
+]), Vt = i.enum(Yt), Ht = i.discriminatedUnion("mode", [
   i.object({ mode: i.literal("auto") }).strict(),
   i.object({
     mode: i.literal("preset"),
-    preset: qt
+    preset: Vt
   }).strict(),
   i.object({
     mode: i.literal("pattern"),
     pattern: i.string().min(1)
   }).strict()
-]), W = i.object({
+]), X = i.object({
   type: i.literal("temporal_bucket"),
-  presentation: Lt
-}).strict(), Ut = i.object({
-  tz: i.string().min(1).refine(Pt, {
+  presentation: Ht
+}).strict(), Gt = i.object({
+  tz: i.string().min(1).refine(Lt, {
     message: "tz must be a valid IANA timezone"
   }),
   weekStart: i.number().int().min(0).max(6),
@@ -117,14 +117,14 @@ const Bt = i.record(i.string(), i.unknown()), O = i.array(Bt), F = i.enum([
     kind: i.literal("month_aligned"),
     yearStartMonth: i.number().int().min(1).max(12)
   }).strict().optional()
-}).strict(), se = i.object({
+}).strict(), re = i.object({
   kind: i.literal("temporal_bucket"),
-  granularity: L,
-  calendar: Ut
-}).strict(), Vt = i.object({
+  granularity: U,
+  calendar: Gt
+}).strict(), zt = i.object({
   kind: i.literal("raw_temporal"),
   valueKind: i.enum(["date", "wall_datetime", "instant"])
-}).strict(), fe = i.union([
+}).strict(), he = i.union([
   i.object({
     type: i.enum([
       "number",
@@ -163,10 +163,10 @@ const Bt = i.record(i.string(), i.unknown()), O = i.array(Bt), F = i.enum([
   }).passthrough(),
   i.object({
     type: i.literal("duration"),
-    inputUnit: te.optional(),
+    inputUnit: ie.optional(),
     outputStyle: i.enum(["compact", "digital", "long"]).optional(),
-    largestUnit: te.optional(),
-    smallestUnit: te.optional(),
+    largestUnit: ie.optional(),
+    smallestUnit: ie.optional(),
     maxUnits: i.number().optional(),
     prefix: i.string().optional(),
     suffix: i.string().optional(),
@@ -178,7 +178,7 @@ const Bt = i.record(i.string(), i.unknown()), O = i.array(Bt), F = i.enum([
     suffix: i.string().optional()
   }).passthrough()
 ]);
-function Ht(e, t) {
+function Kt(e, t) {
   return i.object(e).passthrough().superRefine((n, o) => {
     for (const a of t)
       Object.prototype.hasOwnProperty.call(n, a) || o.addIssue({
@@ -188,14 +188,14 @@ function Ht(e, t) {
       });
   });
 }
-const ge = i.object({
+const _e = i.object({
   kind: i.literal("semantic"),
   domainId: i.string(),
   datasetName: i.string(),
   datasetId: i.string().optional(),
   label: i.string().optional(),
   connectionId: i.string().optional()
-}).passthrough(), He = i.object({
+}).passthrough(), Qe = i.object({
   kind: i.literal("physical"),
   connectionId: i.string(),
   connectionType: i.string().optional(),
@@ -203,39 +203,39 @@ const ge = i.object({
   databaseName: i.string().optional(),
   schemaName: i.string().optional(),
   label: i.string().optional(),
-  dialect: z.optional()
-}).passthrough(), Gt = i.object({
+  dialect: K.optional()
+}).passthrough(), Qt = i.object({
   kind: i.literal("sql"),
   connectionId: i.string(),
-  dialect: z.optional(),
+  dialect: K.optional(),
   label: i.string().optional()
-}).passthrough(), Ge = i.union([
-  ge,
-  He,
-  Gt
-]), ze = i.object({
+}).passthrough(), We = i.union([
+  _e,
+  Qe,
+  Qt
+]), Xe = i.object({
   name: i.string(),
   label: i.string().optional(),
-  role: K.optional(),
-  dataType: Q.optional(),
-  source: Ge.optional(),
-  aggregate: F.optional()
-}).passthrough(), Ke = ze, zt = i.object({
+  role: Q.optional(),
+  dataType: W.optional(),
+  source: We.optional(),
+  aggregate: R.optional()
+}).passthrough(), Ze = Xe, Wt = i.object({
   kind: i.literal("field"),
-  field: Ke,
-  aggregate: F.optional()
-}).passthrough(), Qe = i.object({
+  field: Ze,
+  aggregate: R.optional()
+}).passthrough(), Je = i.object({
   kind: i.literal("derived_field"),
   name: i.string(),
   label: i.string(),
   description: i.string().optional(),
-  resultRole: K,
-  dataType: Q,
+  resultRole: Q,
+  dataType: W,
   computeStage: i.enum(["row", "aggregate"]),
   expression: i.string(),
   expressionLanguage: i.literal("semaphor_sql_template").optional(),
-  inputs: i.record(zt),
-  defaultAggregate: F.optional(),
+  inputs: i.record(Wt),
+  defaultAggregate: R.optional(),
   aggregationBehavior: i.enum([
     "additive",
     "non_additive",
@@ -250,13 +250,13 @@ const ge = i.object({
     "aggregate_then_join",
     "weighted"
   ]).optional(),
-  format: fe.optional(),
+  format: he.optional(),
   tags: i.array(i.string()).optional()
-}).passthrough(), We = Qe, ta = Ke.and(
+}).passthrough(), et = Je, oa = Ze.and(
   i.object({
-    derivedField: We.optional()
+    derivedField: et.optional()
   }).passthrough()
-), Kt = ge, Qt = i.object({
+), Xt = _e, Zt = i.object({
   kind: i.literal("physical"),
   connectionId: i.string().optional(),
   connectionType: i.string().optional(),
@@ -264,36 +264,36 @@ const ge = i.object({
   databaseName: i.string().optional(),
   schemaName: i.string().optional(),
   label: i.string().optional(),
-  dialect: z.optional()
-}).passthrough(), Wt = i.object({
+  dialect: K.optional()
+}).passthrough(), Jt = i.object({
   kind: i.literal("sql"),
   connectionId: i.string().optional(),
-  dialect: z.optional(),
+  dialect: K.optional(),
   label: i.string().optional()
-}).passthrough(), Xt = i.union([
-  Kt,
-  Qt,
-  Wt
-]), ia = i.object({
+}).passthrough(), ei = i.union([
+  Xt,
+  Zt,
+  Jt
+]), sa = i.object({
   key: i.string().optional(),
   name: i.string(),
   label: i.string().optional(),
-  role: K.optional(),
-  dataType: Q.optional(),
-  source: Xt.optional(),
-  aggregate: F.optional(),
+  role: Q.optional(),
+  dataType: W.optional(),
+  source: ei.optional(),
+  aggregate: R.optional(),
   derivedField: i.never().optional()
 }).passthrough(), j = i.object({
   key: i.string(),
   name: i.string(),
   label: i.string(),
-  role: K.optional(),
-  dataType: Q.optional(),
-  aggregate: F.optional(),
-  source: Ge.optional(),
-  derivedField: We.optional(),
-  temporalBucket: se.optional(),
-  rawTemporal: Vt.optional(),
+  role: Q.optional(),
+  dataType: W.optional(),
+  aggregate: R.optional(),
+  source: We.optional(),
+  derivedField: et.optional(),
+  temporalBucket: re.optional(),
+  rawTemporal: zt.optional(),
   pivotIdentity: i.object({
     metricId: i.string().min(1),
     metricAlias: i.string().min(1),
@@ -301,7 +301,7 @@ const ge = i.object({
       i.object({
         fieldId: i.string().min(1),
         value: i.string().nullable(),
-        temporalBucket: se.optional()
+        temporalBucket: re.optional()
       }).strict()
     )
   }).strict().optional()
@@ -311,7 +311,7 @@ const ge = i.object({
     path: ["rawTemporal"],
     message: "A result column cannot carry both temporalBucket and rawTemporal metadata."
   }), e.temporalBucket) {
-    const n = Ct(
+    const n = Pt(
       e.temporalBucket.granularity
     );
     e.dataType !== n && t.addIssue({
@@ -328,13 +328,13 @@ const ge = i.object({
       message: `${e.rawTemporal.valueKind} raw temporal values require dataType ${n}.`
     });
   }
-}), na = i.object({
+}), ra = i.object({
   records: O,
   columns: i.array(j).optional()
-}).passthrough(), aa = i.object({
+}).passthrough(), la = i.object({
   records: O,
   columns: i.array(j)
-}).passthrough(), Xe = i.object({
+}).passthrough(), tt = i.object({
   code: i.string(),
   message: i.string().optional(),
   invalidField: i.string().optional(),
@@ -343,47 +343,47 @@ const ge = i.object({
   validDateCandidates: i.array(i.string()).optional(),
   validDimensionCandidates: i.array(i.string()).optional(),
   recommendedNextStep: i.string()
-}).passthrough(), Te = i.object({
+}).passthrough(), Ne = i.object({
   code: i.string(),
   message: i.string(),
   path: i.string().optional(),
   fieldRole: i.enum(["measure", "date", "dimension", "input", "source", "sql"]).optional(),
-  repairHint: Xe.optional()
-}).passthrough(), oa = i.object({
+  repairHint: tt.optional()
+}).passthrough(), da = i.object({
   ok: i.boolean(),
-  errors: i.array(Te),
-  warnings: i.array(Te),
-  repairHints: i.array(Xe)
-}).passthrough(), Zt = i.object({
+  errors: i.array(Ne),
+  warnings: i.array(Ne),
+  repairHints: i.array(tt)
+}).passthrough(), ti = i.object({
   page: i.number(),
   pageSize: i.number(),
   pageCount: i.number(),
   totalCount: i.number(),
   hasNextPage: i.boolean(),
   hasPrevPage: i.boolean()
-}).passthrough(), X = {
+}).passthrough(), Z = {
   intentId: i.string().optional(),
   queryPath: i.enum(["query_spec", "sql", "sql_python"]),
   warnings: i.array(i.string()).optional(),
   rowCount: i.number().optional(),
   rowLimitExceeded: i.boolean().optional(),
   limit: i.number().optional(),
-  pagination: Zt.optional()
-}, sa = i.object({
-  ...X,
+  pagination: ti.optional()
+}, ua = i.object({
+  ...Z,
   kind: i.literal("metric"),
-  primaryValue: ee,
-  measures: i.record(ee).optional(),
+  primaryValue: te,
+  measures: i.record(te).optional(),
   missingMeasures: i.array(i.string()).optional(),
   comparison: i.object({
     kind: i.enum(["previous_period", "previous_year", "target"]),
-    value: ee.optional(),
+    value: te.optional(),
     delta: i.union([i.number(), i.null()]).optional(),
     deltaPercent: i.union([i.number(), i.null()]).optional()
   }).passthrough().optional(),
   records: O.optional()
-}).passthrough(), ra = i.object({
-  ...X,
+}).passthrough(), ca = i.object({
+  ...Z,
   kind: i.literal("records"),
   columns: i.array(j),
   records: O,
@@ -393,7 +393,7 @@ const ge = i.object({
     row: i.record(i.string(), i.unknown()),
     columns: i.array(j).optional()
   }).passthrough().optional()
-}).passthrough(), Jt = i.object({
+}).passthrough(), ii = i.object({
   inputId: i.string().min(1),
   status: i.enum(["applied", "inactive", "skipped", "overridden", "error"]),
   reason: i.enum([
@@ -406,16 +406,16 @@ const ge = i.object({
     "unsupported_dependency",
     "override_not_eligible"
   ]).optional()
-}), ei = i.object({
+}), ni = i.object({
   complete: i.boolean(),
   reason: i.enum(["unsupported", "truncated"]).optional()
-}), la = i.object({
-  ...X,
+}), pa = i.object({
+  ...Z,
   kind: i.literal("inputOptions"),
-  dependencyOutcomes: i.array(Jt).optional(),
-  match: ei.optional(),
+  dependencyOutcomes: i.array(ii).optional(),
+  match: ni.optional(),
   options: i.array(
-    Ht(
+    Kt(
       {
         label: i.string(),
         value: i.unknown(),
@@ -425,8 +425,8 @@ const ge = i.object({
       ["value"]
     )
   )
-}).passthrough(), da = i.object({
-  ...X,
+}).passthrough(), ma = i.object({
+  ...Z,
   kind: i.literal("sql"),
   columns: i.array(j),
   records: O,
@@ -436,25 +436,25 @@ const ge = i.object({
     hasPythonCode: i.boolean().optional()
   }).passthrough().optional()
 }).passthrough();
-function s(e, t, n) {
+function r(e, t, n) {
   return n ? { code: e, message: t, path: n } : { code: e, message: t };
 }
 function p(e) {
   return typeof e == "string" && e.trim().length > 0;
 }
-function ti(e) {
+function ai(e) {
   const t = /* @__PURE__ */ new Set();
-  return ii(e, (n) => (t.add(n), `{${n}}`)), Array.from(t);
+  return oi(e, (n) => (t.add(n), `{${n}}`)), Array.from(t);
 }
-function ii(e, t) {
+function oi(e, t) {
   let n = "", o = 0, a = 0;
   for (; a < e.length; ) {
-    const r = e[a];
-    if (r === "'" || r === '"') {
-      a = ni(e, a);
+    const s = e[a];
+    if (s === "'" || s === '"') {
+      a = si(e, a);
       continue;
     }
-    if (r === "{") {
+    if (s === "{") {
       const l = e.indexOf("}", a + 1);
       if (l === -1) {
         a += 1;
@@ -468,7 +468,7 @@ function ii(e, t) {
   }
   return n + e.slice(o);
 }
-function ni(e, t) {
+function si(e, t) {
   const n = e[t];
   let o = t + 1;
   for (; o < e.length; ) {
@@ -486,7 +486,7 @@ function ni(e, t) {
 function f(e) {
   return !!(e && typeof e == "object" && !Array.isArray(e));
 }
-const ai = /* @__PURE__ */ new Set([
+const ri = /* @__PURE__ */ new Set([
   "SUM",
   "COUNT",
   "AVG",
@@ -495,22 +495,22 @@ const ai = /* @__PURE__ */ new Set([
   "MEDIAN",
   "DISTINCT"
 ]);
-function he(e, t, n) {
+function be(e, t, n) {
   if (!e || typeof e != "object") {
     n.push(
-      s("missing_source", "Analytics intent needs a source.", t)
+      r("missing_source", "Analytics intent needs a source.", t)
     );
     return;
   }
   if (e.kind === "semantic") {
     p(e.domainId) || n.push(
-      s(
+      r(
         "missing_semantic_domain",
         "Semantic source needs a domainId.",
         `${t}.domainId`
       )
     ), p(e.datasetName) || n.push(
-      s(
+      r(
         "missing_dataset_name",
         "Semantic source needs a datasetName.",
         `${t}.datasetName`
@@ -520,13 +520,13 @@ function he(e, t, n) {
   }
   if (e.kind === "physical") {
     p(e.connectionId) || n.push(
-      s(
+      r(
         "missing_connection_id",
         "Physical source needs a connectionId.",
         `${t}.connectionId`
       )
     ), p(e.tableName) || n.push(
-      s(
+      r(
         "missing_table_name",
         "Physical source needs a tableName.",
         `${t}.tableName`
@@ -536,7 +536,7 @@ function he(e, t, n) {
   }
   if (e.kind === "sql") {
     p(e.connectionId) || n.push(
-      s(
+      r(
         "missing_connection_id",
         "SQL source needs a connectionId.",
         `${t}.connectionId`
@@ -545,47 +545,47 @@ function he(e, t, n) {
     return;
   }
   n.push(
-    s("invalid_source_kind", "Source kind is not supported.", t)
+    r("invalid_source_kind", "Source kind is not supported.", t)
   );
 }
 function b(e, t, n, o = {}) {
   if (!e || !f(e)) {
     o.required && n.push(
-      s("missing_field_ref", "Field reference needs a name.", t)
+      r("missing_field_ref", "Field reference needs a name.", t)
     );
     return;
   }
   p(e.name) || n.push(
-    s(
+    r(
       "missing_field_ref",
       "Field reference needs a name.",
       `${t}.name`
     )
-  ), e.source !== void 0 && he(e.source, `${t}.source`, n), _e(e.aggregate, `${t}.aggregate`, n);
+  ), e.source !== void 0 && be(e.source, `${t}.source`, n), ye(e.aggregate, `${t}.aggregate`, n);
 }
-function _e(e, t, n) {
-  e !== void 0 && (typeof e != "string" || !ai.has(e)) && n.push(
-    s(
+function ye(e, t, n) {
+  e !== void 0 && (typeof e != "string" || !ri.has(e)) && n.push(
+    r(
       "invalid_aggregate",
       "Field aggregate must be SUM, COUNT, AVG, MIN, MAX, MEDIAN, or DISTINCT.",
       t
     )
   );
 }
-const oi = /* @__PURE__ */ new Set([
+const li = /* @__PURE__ */ new Set([
   "measure",
   "dimension",
   "date",
   "id",
   "unknown"
-]), si = /* @__PURE__ */ new Set(["row", "aggregate"]), Ze = /* @__PURE__ */ new Set([
+]), di = /* @__PURE__ */ new Set(["row", "aggregate"]), it = /* @__PURE__ */ new Set([
   "string",
   "number",
   "boolean",
   "date",
   "datetime",
   "unknown"
-]), ri = /* @__PURE__ */ new Set([
+]), ui = /* @__PURE__ */ new Set([
   "number",
   "currency",
   "percent",
@@ -596,19 +596,19 @@ const oi = /* @__PURE__ */ new Set([
   "duration",
   "string",
   "temporal_bucket"
-]), li = /* @__PURE__ */ new Set([
+]), ci = /* @__PURE__ */ new Set([
   "millisecond",
   "second",
   "minute",
   "hour",
   "day"
-]), di = /* @__PURE__ */ new Set(["compact", "digital", "long"]);
-function Je(e, t, n) {
+]), pi = /* @__PURE__ */ new Set(["compact", "digital", "long"]);
+function nt(e, t, n) {
   if (e === void 0)
     return;
   if (!f(e)) {
     n.push(
-      s(
+      r(
         "invalid_value_format",
         "Value format must be a structured object.",
         t
@@ -617,95 +617,95 @@ function Je(e, t, n) {
     return;
   }
   const o = e;
-  (typeof o.type != "string" || !ri.has(o.type)) && n.push(
-    s(
+  (typeof o.type != "string" || !ui.has(o.type)) && n.push(
+    r(
       "invalid_value_format_type",
       "Value format type must be number, currency, percent, percentage, scientific, date, datetime, duration, string, or temporal_bucket.",
       `${t}.type`
     )
-  ), o.type === "temporal_bucket" && !W.safeParse(e).success && n.push(
-    s(
+  ), o.type === "temporal_bucket" && !X.safeParse(e).success && n.push(
+    r(
       "invalid_temporal_bucket_format",
       "Temporal bucket format must contain a valid auto, preset, or pattern presentation.",
       t
     )
   ), (o.type === "number" || o.type === "currency" || o.type === "percent" || o.type === "percentage" || o.type === "scientific") && Object.prototype.hasOwnProperty.call(e, "locale") && n.push(
-    s(
+    r(
       "invalid_value_format",
       "Numeric value formats cannot define viewer locale.",
       `${t}.locale`
     )
-  ), P(
+  ), B(
     e.minimumFractionDigits,
     `${t}.minimumFractionDigits`,
     n
-  ), P(
+  ), B(
     e.maximumFractionDigits,
     `${t}.maximumFractionDigits`,
     n
-  ), P(e.scale, `${t}.scale`, n), P(e.maxUnits, `${t}.maxUnits`, n), e.useGrouping !== void 0 && typeof e.useGrouping != "boolean" && n.push(
-    s(
+  ), B(e.scale, `${t}.scale`, n), B(e.maxUnits, `${t}.maxUnits`, n), e.useGrouping !== void 0 && typeof e.useGrouping != "boolean" && n.push(
+    r(
       "invalid_value_format_use_grouping",
       "Value format useGrouping must be boolean.",
       `${t}.useGrouping`
     )
   ), e.negativeStyle !== void 0 && e.negativeStyle !== "minus" && e.negativeStyle !== "parentheses" && n.push(
-    s(
+    r(
       "invalid_value_format_negative_style",
       "Value format negativeStyle must be minus or parentheses.",
       `${t}.negativeStyle`
     )
   ), e.percentValueMode !== void 0 && e.percentValueMode !== "fraction" && e.percentValueMode !== "whole" && n.push(
-    s(
+    r(
       "invalid_value_format_percent_mode",
       "Value format percentValueMode must be fraction or whole.",
       `${t}.percentValueMode`
     )
   );
   for (const a of ["inputUnit", "largestUnit", "smallestUnit"]) {
-    const r = e[a];
-    r !== void 0 && (typeof r != "string" || !li.has(r)) && n.push(
-      s(
+    const s = e[a];
+    s !== void 0 && (typeof s != "string" || !ci.has(s)) && n.push(
+      r(
         "invalid_value_format_duration_unit",
         "Duration format units must be millisecond, second, minute, hour, or day.",
         `${t}.${a}`
       )
     );
   }
-  e.outputStyle !== void 0 && (typeof e.outputStyle != "string" || !di.has(e.outputStyle)) && n.push(
-    s(
+  e.outputStyle !== void 0 && (typeof e.outputStyle != "string" || !pi.has(e.outputStyle)) && n.push(
+    r(
       "invalid_value_format_duration_style",
       "Duration format outputStyle must be compact, digital, or long.",
       `${t}.outputStyle`
     )
   );
 }
-function P(e, t, n) {
+function B(e, t, n) {
   e !== void 0 && (typeof e != "number" || !Number.isFinite(e)) && n.push(
-    s(
+    r(
       "invalid_value_format_number",
       "Value format numeric options must be finite numbers.",
       t
     )
   );
 }
-const ui = /* @__PURE__ */ new Set([
+const mi = /* @__PURE__ */ new Set([
   "additive",
   "non_additive",
   "ratio_of_sums",
   "weighted",
   "pre_aggregated",
   "snapshot"
-]), ci = /* @__PURE__ */ new Set([
+]), fi = /* @__PURE__ */ new Set([
   "default",
   "symmetric_aggregate",
   "aggregate_then_join",
   "weighted"
 ]);
-function pi(e, t, n) {
+function gi(e, t, n) {
   if (!e || !f(e)) {
     n.push(
-      s(
+      r(
         "invalid_derived_field_input",
         "Derived field inputs must be structured input references.",
         t
@@ -714,114 +714,114 @@ function pi(e, t, n) {
     return;
   }
   if (e.kind === "field") {
-    b(e.field, `${t}.field`, n, { required: !0 }), _e(e.aggregate, `${t}.aggregate`, n);
+    b(e.field, `${t}.field`, n, { required: !0 }), ye(e.aggregate, `${t}.aggregate`, n);
     return;
   }
   n.push(
-    s(
+    r(
       "invalid_derived_field_input",
       "Derived field input kind must be field.",
       `${t}.kind`
     )
   );
 }
-function et(e) {
+function ve(e) {
   const t = [];
   if (!f(e))
     return t.push(
-      s(
+      r(
         "invalid_derived_field",
         "Derived field definition must be a structured object."
       )
     ), { ok: !1, errors: t, warnings: [] };
   if (e.kind !== "derived_field" && t.push(
-    s(
+    r(
       "invalid_derived_field_kind",
       "Derived field kind must be derived_field.",
       "kind"
     )
   ), p(e.name) || t.push(
-    s(
+    r(
       "invalid_derived_field_name",
       "Derived field needs a name.",
       "name"
     )
   ), p(e.label) || t.push(
-    s(
+    r(
       "invalid_derived_field_label",
       "Derived field needs a label.",
       "label"
     )
-  ), oi.has(e.resultRole) || t.push(
-    s(
+  ), li.has(e.resultRole) || t.push(
+    r(
       "invalid_derived_field_role",
       "Derived field resultRole must be measure, dimension, date, id, or unknown.",
       "resultRole"
     )
-  ), Ze.has(e.dataType) || t.push(
-    s(
+  ), it.has(e.dataType) || t.push(
+    r(
       "invalid_derived_field_data_type",
       "Derived field dataType must be string, number, boolean, date, datetime, or unknown.",
       "dataType"
     )
-  ), si.has(e.computeStage) || t.push(
-    s(
+  ), di.has(e.computeStage) || t.push(
+    r(
       "invalid_derived_field_compute_stage",
       "Derived field computeStage must be row or aggregate.",
       "computeStage"
     )
   ), e.computeStage === "aggregate" && e.resultRole !== "measure" && t.push(
-    s(
+    r(
       "invalid_derived_field_compute_stage",
       "Aggregate-stage derived fields must have resultRole measure.",
       "computeStage"
     )
   ), e.resultRole !== "measure" && e.defaultAggregate !== void 0 && t.push(
-    s(
+    r(
       "invalid_derived_field_aggregate",
       "Only measure derived fields may declare defaultAggregate.",
       "defaultAggregate"
     )
   ), e.computeStage === "row" && e.resultRole === "measure" && e.defaultAggregate === void 0 && t.push(
-    s(
+    r(
       "missing_derived_field_default_aggregate",
       "Row-stage measure derived fields must declare defaultAggregate so row results have explicit rollup semantics.",
       "defaultAggregate"
     )
-  ), _e(
+  ), ye(
     e.defaultAggregate,
     "defaultAggregate",
     t
-  ), e.aggregationBehavior !== void 0 && !ui.has(
+  ), e.aggregationBehavior !== void 0 && !mi.has(
     e.aggregationBehavior
   ) && t.push(
-    s(
+    r(
       "invalid_derived_field_aggregation_behavior",
       "Derived field aggregationBehavior is not supported.",
       "aggregationBehavior"
     )
-  ), e.aggregationStrategy !== void 0 && !ci.has(
+  ), e.aggregationStrategy !== void 0 && !fi.has(
     e.aggregationStrategy
   ) && t.push(
-    s(
+    r(
       "invalid_derived_field_aggregation_strategy",
       "Derived field aggregationStrategy is not supported.",
       "aggregationStrategy"
     )
   ), p(e.expression) || t.push(
-    s(
+    r(
       "invalid_derived_field_expression",
       "Derived field needs a named-token expression.",
       "expression"
     )
   ), e.expressionLanguage !== void 0 && e.expressionLanguage !== "semaphor_sql_template" && t.push(
-    s(
+    r(
       "invalid_derived_field_expression_language",
       "Derived field expressionLanguage must be semaphor_sql_template.",
       "expressionLanguage"
     )
   ), !f(e.inputs) || Object.keys(e.inputs).length === 0 ? t.push(
-    s(
+    r(
       "invalid_derived_field_inputs",
       "Derived field needs at least one typed input.",
       "inputs"
@@ -829,7 +829,7 @@ function et(e) {
   ) : Object.entries(e.inputs).forEach(([o, a]) => {
     if (!p(o)) {
       t.push(
-        s(
+        r(
           "invalid_derived_field_input_name",
           "Derived field input names must be non-empty strings.",
           "inputs"
@@ -837,28 +837,28 @@ function et(e) {
       );
       return;
     }
-    pi(
+    gi(
       a,
       `inputs.${o}`,
       t
     );
   }), p(e.expression) && f(e.inputs)) {
-    const o = ti(
+    const o = ai(
       e.expression
-    ), a = new Set(o), r = Object.keys(e.inputs).filter(
+    ), a = new Set(o), s = Object.keys(e.inputs).filter(
       (l) => p(l)
     );
     o.forEach((l) => {
       Object.prototype.hasOwnProperty.call(e.inputs, l) || t.push(
-        s(
+        r(
           "invalid_derived_field_expression_token",
           `Derived field expression token "{${l}}" needs a matching inputs.${l} entry.`,
           "expression"
         )
       );
-    }), r.forEach((l) => {
+    }), s.forEach((l) => {
       a.has(l) || t.push(
-        s(
+        r(
           "unused_derived_field_input",
           `Derived field input "${l}" is not referenced by expression.`,
           `inputs.${l}`
@@ -868,68 +868,68 @@ function et(e) {
   }
   const n = e.format;
   return f(n) && n.type === "temporal_bucket" ? t.push(
-    s(
+    r(
       "invalid_derived_field_format",
       "Derived field computation metadata cannot own temporal bucket presentation; declare grain and format on the grouped field.",
       "format"
     )
-  ) : Je(n, "format", t), e.tags !== void 0 && (!Array.isArray(e.tags) || e.tags.some((o) => !p(o))) && t.push(
-    s(
+  ) : nt(n, "format", t), e.tags !== void 0 && (!Array.isArray(e.tags) || e.tags.some((o) => !p(o))) && t.push(
+    r(
       "invalid_derived_field_tags",
       "Derived field tags must be non-empty strings.",
       "tags"
     )
   ), { ok: t.length === 0, errors: t, warnings: [] };
 }
-const M = i.string().min(1).refine((e) => e.trim().length > 0, "Must not be blank."), [mi, fi, gi, hi] = fe.options, tt = i.union([
-  mi.innerType().omit({ locale: !0 }).strict().superRefine((e, t) => {
+const M = i.string().min(1).refine((e) => e.trim().length > 0, "Must not be blank."), [hi, _i, bi, yi] = he.options, at = i.union([
+  hi.innerType().omit({ locale: !0 }).strict().superRefine((e, t) => {
     const { minimumFractionDigits: n = 0, maximumFractionDigits: o = 2 } = e;
     (![n, o].every((a) => Number.isInteger(a) && a >= 0 && a <= 20) || n > o) && t.addIssue({
       code: "custom",
       message: "Fraction digits must be integers from 0 to 20 with minimum <= maximum."
     }), e.scale !== void 0 && !Number.isFinite(e.scale) && t.addIssue({ code: "custom", message: "Scale must be finite." });
   }),
-  fi.strict(),
-  gi.strict(),
-  hi.strict()
-]), Me = i.union([
-  tt,
-  W
-]), be = i.union([
-  ge.extend({ domainId: M, datasetName: M }).strict(),
-  He.extend({ connectionId: M, tableName: M }).strict()
-]), it = ze.extend({
+  _i.strict(),
+  bi.strict(),
+  yi.strict()
+]), Ee = i.union([
+  at,
+  X
+]), Se = i.union([
+  _e.extend({ domainId: M, datasetName: M }).strict(),
+  Qe.extend({ connectionId: M, tableName: M }).strict()
+]), ot = Xe.extend({
   name: M,
-  source: be.optional()
-}).strict(), ye = Qe.extend({
-  format: tt.optional(),
+  source: Se.optional()
+}).strict(), Ie = Je.extend({
+  format: at.optional(),
   inputs: i.record(
     i.object({
       kind: i.literal("field"),
-      field: it,
-      aggregate: F.optional()
+      field: ot,
+      aggregate: R.optional()
     }).strict()
   )
 }).strict().superRefine((e, t) => {
   var n;
-  for (const o of et(e).errors)
+  for (const o of ve(e).errors)
     t.addIssue({
       code: "custom",
       path: ((n = o.path) == null ? void 0 : n.split(".")) ?? [],
       message: o.message
     });
-}), _i = it.extend({
-  derivedField: ye.optional()
+}), vi = ot.extend({
+  derivedField: Ie.optional()
 }).strict();
-function ve(e) {
+function ke(e) {
   return typeof e == "string" ? e.trim().toLowerCase() : "";
 }
-function bi(e) {
+function Si(e) {
   return String(
     e.column_name || e.name || e.qualifiedFieldName || ""
   );
 }
-function yi(e) {
+function Ii(e) {
   return Array.from(
     new Set(
       [e.column_name, e.name, e.qualifiedFieldName, e.alias].filter(
@@ -938,11 +938,11 @@ function yi(e) {
     )
   );
 }
-function nt(e) {
-  const t = ot(e);
-  return t ? Ii(t) ? "number" : t.includes("timestamp") || t.includes("datetime") || t.startsWith("time") ? "datetime" : t.includes("date") ? "date" : t.includes("bool") ? "boolean" : "string" : "unknown";
+function st(e) {
+  const t = lt(e);
+  return t ? Ai(t) ? "number" : t.includes("timestamp") || t.includes("datetime") || t.startsWith("time") ? "datetime" : t.includes("date") ? "date" : t.includes("bool") ? "boolean" : "string" : "unknown";
 }
-const ie = /* @__PURE__ */ new Map([
+const ne = /* @__PURE__ */ new Map([
   // Integer families (PostgreSQL, ClickHouse, DuckDB, MySQL).
   ["int", "integer"],
   ["uint", "integer"],
@@ -970,80 +970,80 @@ const ie = /* @__PURE__ */ new Map([
   ["money", null],
   ["currency", null],
   ["percent", null]
-]), vi = ["int", "uint", "decimal", "float"];
-function Si(e) {
+]), ki = ["int", "uint", "decimal", "float"];
+function wi(e) {
   return e.length > 0 && Array.from(e).every((t) => t >= "0" && t <= "9");
 }
-function at(e) {
+function rt(e) {
   const t = e.split(/[\s(]/, 1)[0] || "";
-  if (ie.has(t))
-    return { numeric: !0, kind: ie.get(t) ?? null };
-  const n = vi.find(
-    (o) => t.startsWith(o) && Si(t.slice(o.length))
+  if (ne.has(t))
+    return { numeric: !0, kind: ne.get(t) ?? null };
+  const n = ki.find(
+    (o) => t.startsWith(o) && wi(t.slice(o.length))
   );
-  return n ? { numeric: !0, kind: ie.get(n) ?? null } : { numeric: !1, kind: null };
+  return n ? { numeric: !0, kind: ne.get(n) ?? null } : { numeric: !1, kind: null };
 }
-function Ii(e) {
-  return at(e).numeric;
+function Ai(e) {
+  return rt(e).numeric;
 }
-function ki(e) {
-  return at(ot(e)).kind;
+function xi(e) {
+  return rt(lt(e)).kind;
 }
-function ot(e) {
-  let t = ve(e), n = "";
+function lt(e) {
+  let t = ke(e), n = "";
   for (; t && t !== n; )
-    n = t, t = De(t, "nullable"), t = De(t, "lowcardinality");
+    n = t, t = je(t, "nullable"), t = je(t, "lowcardinality");
   return t;
 }
-function De(e, t) {
+function je(e, t) {
   const n = `${t}(`;
   return !e.startsWith(n) || !e.endsWith(")") ? e : e.slice(n.length, -1).trim();
 }
-function wi(e) {
-  const t = nt(e);
+function Fi(e) {
+  const t = st(e);
   return t === "date" || t === "datetime";
 }
-function st(e) {
-  return wi(e.dataType || e.data_type);
+function dt(e) {
+  return Fi(e.dataType || e.data_type);
 }
-function rt(e) {
-  const t = lt(e);
+function ut(e) {
+  const t = ct(e);
   return t === "id" || t === "row_id";
 }
-function Ne(e) {
-  const t = lt(e);
-  return rt(e) || t.endsWith("_id") || t.endsWith("_key") || t.endsWith("_number");
+function $e(e) {
+  const t = ct(e);
+  return ut(e) || t.endsWith("_id") || t.endsWith("_key") || t.endsWith("_number");
 }
-function lt(e) {
-  return ve(
-    bi(e) || e.name || e.alias
+function ct(e) {
+  return ke(
+    Si(e) || e.name || e.alias
   ).replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
 }
-function dt(e, t = {}) {
-  const n = ve(e.role);
-  return n === "metric" || n === "measure" ? !t.excludeIdentifiers || !Ne(e) : n === "groupby" || n === "dimension" || n === "date" || n === "id" ? !1 : nt(
+function pt(e, t = {}) {
+  const n = ke(e.role);
+  return n === "metric" || n === "measure" ? !t.excludeIdentifiers || !$e(e) : n === "groupby" || n === "dimension" || n === "date" || n === "id" ? !1 : st(
     e.dataType || e.data_type
-  ) === "number" && (!t.excludeIdentifiers || !Ne(e));
+  ) === "number" && (!t.excludeIdentifiers || !$e(e));
 }
-function ua(e) {
-  return !dt(e) && !st(e);
+function fa(e) {
+  return !pt(e) && !dt(e);
 }
-function ca(e) {
+function ga(e) {
   const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set();
   for (const a of e) {
-    if (rt(a))
+    if (ut(a))
       continue;
-    const r = yi(a);
-    if (r.length !== 0) {
-      if (st(a)) {
-        r.forEach((l) => n.add(l));
+    const s = Ii(a);
+    if (s.length !== 0) {
+      if (dt(a)) {
+        s.forEach((l) => n.add(l));
         continue;
       }
-      if (dt(a, { excludeIdentifiers: !0 })) {
-        r.forEach((l) => t.add(l));
+      if (pt(a, { excludeIdentifiers: !0 })) {
+        s.forEach((l) => t.add(l));
         continue;
       }
-      r.forEach((l) => o.add(l));
+      s.forEach((l) => o.add(l));
     }
   }
   return {
@@ -1053,7 +1053,7 @@ function ca(e) {
   };
 }
 const D = 16 * 1024;
-function U(e) {
+function V(e) {
   const t = /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([+-]?\d+))?$/.exec(e);
   return t ? {
     sign: t[1],
@@ -1062,91 +1062,91 @@ function U(e) {
     exponent: Number(t[5] ?? "0")
   } : null;
 }
-function Ee(e) {
-  const { sign: t, whole: n, fraction: o = "", exponent: a } = e, r = (n + o).replace(/^0+/, ""), l = r.replace(/0+$/, ""), d = a - o.length + r.length - l.length;
+function Ce(e) {
+  const { sign: t, whole: n, fraction: o = "", exponent: a } = e, s = (n + o).replace(/^0+/, ""), l = s.replace(/0+$/, ""), d = a - o.length + s.length - l.length;
   return !Number.isSafeInteger(a) || !Number.isSafeInteger(d) ? null : l ? `${t === "-" ? "-" : ""}${l}e${d}` : "0";
 }
-function Ai(e) {
-  const t = U(e);
+function Ri(e) {
+  const t = V(e);
   if (!t) return null;
   const n = t.sign === "+" ? e.slice(1) : e, o = Number(e);
   if (!Number.isFinite(o)) return n;
-  const a = Ee(t), r = U(String(o));
-  return a !== null && r !== null && a === Ee(r) ? o : n;
+  const a = Ce(t), s = V(String(o));
+  return a !== null && s !== null && a === Ce(s) ? o : n;
 }
-function xi(e) {
+function Ti(e) {
   if (e.length > D)
     throw new RangeError("Exact numeric text exceeds 16 KiB.");
-  const t = U(e);
+  const t = V(e);
   if (!t) throw new TypeError("Expected finite decimal text.");
-  const { sign: n, whole: o, fraction: a, exponent: r } = t, l = `${n}${o || "0"}${a ? `.${a}` : ""}`;
-  return A(`${l}e${r}`);
+  const { sign: n, whole: o, fraction: a, exponent: s } = t, l = `${n}${o || "0"}${a ? `.${a}` : ""}`;
+  return x(`${l}e${s}`);
 }
-function A(e) {
+function x(e) {
   if (e.length > D)
     throw new RangeError("Exact numeric text exceeds 16 KiB.");
-  const t = U(e);
+  const t = V(e);
   if (!t || t.whole === "" || t.fraction === "")
     throw new TypeError("Expected finite decimal text.");
-  const { sign: n, whole: o, fraction: a = "", exponent: r } = t;
-  if (!Number.isSafeInteger(r) || Math.abs(r) > D)
+  const { sign: n, whole: o, fraction: a = "", exponent: s } = t;
+  if (!Number.isSafeInteger(s) || Math.abs(s) > D)
     throw new RangeError("Exact numeric exponent exceeds the text budget.");
-  const l = o + a, d = o.length + r;
+  const l = o + a, d = o.length + s;
   if (Math.max(l.length, d) + Math.max(0, -d) + 3 > D)
     throw new RangeError("Normalized exact numeric text exceeds 16 KiB.");
   let u;
   d <= 0 ? u = `0.${"0".repeat(-d)}${l}` : d >= l.length ? u = l + "0".repeat(d - l.length) : u = `${l.slice(0, d)}.${l.slice(d)}`;
-  const [m, h = ""] = u.split("."), v = m.replace(/^0+(?=\d)/, ""), R = h.replace(/0+$/, ""), _ = v + (R ? `.${R}` : "");
-  return n === "-" && _ !== "0" ? `-${_}` : _;
+  const [m, _ = ""] = u.split("."), y = m.replace(/^0+(?=\d)/, ""), w = _.replace(/0+$/, ""), h = y + (w ? `.${w}` : "");
+  return n === "-" && h !== "0" ? `-${h}` : h;
 }
-function ut(e, t) {
+function mt(e, t) {
   const n = e.startsWith("-"), o = t.startsWith("-");
   if (n !== o) return n ? -1 : 1;
-  const [a, r = ""] = (n ? e.slice(1) : e).split("."), [l, d = ""] = (o ? t.slice(1) : t).split(".");
+  const [a, s = ""] = (n ? e.slice(1) : e).split("."), [l, d = ""] = (o ? t.slice(1) : t).split(".");
   let c = Math.sign(a.length - l.length);
   if (!c && a !== l && (c = a < l ? -1 : 1), !c) {
-    const u = Math.max(r.length, d.length), m = r.padEnd(u, "0"), h = d.padEnd(u, "0");
-    c = m === h ? 0 : m < h ? -1 : 1;
+    const u = Math.max(s.length, d.length), m = s.padEnd(u, "0"), _ = d.padEnd(u, "0");
+    c = m === _ ? 0 : m < _ ? -1 : 1;
   }
   return c === 0 ? 0 : n ? -c : c;
 }
-function pa(e, t) {
+function ha(e, t) {
   if (typeof t == "number" && !Number.isFinite(t))
     throw new TypeError("Numeric scale must be finite.");
-  const n = [e, A(String(t))].map((r) => {
-    const [l, d = ""] = r.split(".");
+  const n = [e, x(String(t))].map((s) => {
+    const [l, d = ""] = s.split(".");
     return { coefficient: BigInt(l + d), digits: d.length };
   }), o = n[0].coefficient * n[1].coefficient, a = n[0].digits + n[1].digits;
-  return A(`${o}e-${a}`);
+  return x(`${o}e-${a}`);
 }
-function Fi(e) {
+function Mi(e) {
   try {
-    return A(e) === e;
+    return x(e) === e;
   } catch {
     return !1;
   }
 }
-const ct = i.object({
+const ft = i.object({
   kind: i.literal("exact_number"),
   type: i.enum(["integer", "decimal"]),
-  value: i.string().max(D).refine(Fi, "Expected canonical decimal text.")
+  value: i.string().max(D).refine(Mi, "Expected canonical decimal text.")
 }).strict().superRefine((e, t) => {
   e.type === "integer" && e.value.includes(".") && t.addIssue({ code: "custom", path: ["value"], message: "An integer cannot have fractional digits." });
-}), q = i.union([
+}), L = i.union([
   i.null(),
   i.string(),
   i.boolean(),
   i.number().finite(),
-  ct
+  ft
 ]);
-function Ri(e, t) {
-  return ct.parse({ kind: "exact_number", type: t, value: A(e) });
+function Di(e, t) {
+  return ft.parse({ kind: "exact_number", type: t, value: x(e) });
 }
-function V(e) {
+function H(e) {
   return typeof e == "object" && e !== null && "kind" in e && e.kind === "exact_number" && "type" in e && (e.type === "integer" || e.type === "decimal") && "value" in e && typeof e.value == "string";
 }
-function ma(e) {
-  const t = ki(e.nativeDataType);
+function _a(e) {
+  const t = xi(e.nativeDataType);
   if (!t) throw new TypeError("Numeric result type is not established.");
   if (e.value === null) return null;
   if (t === "float") {
@@ -1156,12 +1156,12 @@ function ma(e) {
   }
   if (e.exactText === void 0)
     throw new TypeError("Exact numeric sidecar is required; rounded result values cannot substitute.");
-  return Ri(e.exactText, t);
+  return Di(e.exactText, t);
 }
-const Se = i.string().uuid(), Ie = i.enum(["rows", "columns"]), Ti = i.enum(["member", "subtotal", "grand_total", "others"]), Mi = i.discriminatedUnion("kind", [
-  i.object({ kind: i.literal("value"), value: q }).strict(),
-  i.object({ kind: i.literal("others"), rankingId: Se }).strict()
-]), x = i.array(i.object({ levelId: Se, member: Mi }).strict()).readonly().superRefine((e, t) => {
+const we = i.string().uuid(), Ae = i.enum(["rows", "columns"]), Ni = i.enum(["member", "subtotal", "grand_total", "others"]), Ei = i.discriminatedUnion("kind", [
+  i.object({ kind: i.literal("value"), value: L }).strict(),
+  i.object({ kind: i.literal("others"), rankingId: we }).strict()
+]), F = i.array(i.object({ levelId: we, member: Ei }).strict()).readonly().superRefine((e, t) => {
   new Set(e.map((n) => n.levelId)).size !== e.length && t.addIssue({
     code: "custom",
     path: [],
@@ -1173,12 +1173,12 @@ const Se = i.string().uuid(), Ie = i.enum(["rows", "columns"]), Ti = i.enum(["me
     path: [],
     message: "Others is terminal."
   });
-}), fa = i.object({
-  rowPath: x,
-  columnPath: x,
-  measureId: Se
+}), ba = i.object({
+  rowPath: F,
+  columnPath: F,
+  measureId: we
 }).strict();
-function pt(e) {
+function gt(e) {
   return JSON.stringify(
     e.map(({ levelId: t, member: n }) => [
       t,
@@ -1186,11 +1186,11 @@ function pt(e) {
     ])
   );
 }
-const re = "SEMAPHOR_CALCULATED_FIELD", Di = "calculated_fields";
-function ga(e) {
+const le = "SEMAPHOR_CALCULATED_FIELD", ji = "calculated_fields";
+function $i(e) {
   return (e == null ? void 0 : e.sourceField) || (e == null ? void 0 : e.name) || "";
 }
-const Ni = [
+const Ci = [
   // Day granularity formats
   "MM-DD-YYYY",
   "YYYY-MM-DD",
@@ -1225,40 +1225,90 @@ const Ni = [
   // Custom format
   "custom"
 ];
-function ha(e) {
+function ya(e) {
   return e.role === "metric" && "expression" in e && !!e.expression;
 }
-function _a(e) {
+function va(e) {
   return !!e.expression;
 }
-function ba(e) {
-  return !!e.expression;
+function Oi(e) {
+  return !!(e && (e.calculationRepresentation || e.expression || e.derivedField || e.calculatedFieldOrigin || e.calculatedFormula || de(e)));
 }
-function ya(e) {
-  var t, n;
-  return e ? !!(e.expression || e.derivedField || (n = (t = e.calculatedFormula) == null ? void 0 : t.inputFields) != null && n.length || Ei(e)) : !1;
+function ht(e) {
+  var _, y, w;
+  if (!e)
+    return {
+      representation: "physical",
+      ownership: "local",
+      completeness: "not-calculated",
+      runtimeExecutable: !1,
+      legacyManual: !1
+    };
+  const t = e.fieldScope === "domain" ? "domain" : "local", n = ((_ = e.derivedField) == null ? void 0 : _.computeStage) || ((y = e.calculatedFormula) == null ? void 0 : y.computeStage), o = !e.calculatedFormula || Array.isArray(e.calculatedFormula.inputFields) && e.calculatedFormula.inputFields.every((h) => {
+    const P = h && $i(h);
+    return typeof P == "string" && !!P.trim();
+  }), a = typeof e.expression == "string" && !!e.expression.trim() && o, s = e.calculationRepresentation;
+  if (e.derivedField || s === "typed-derived") {
+    const h = e.derivedField !== void 0 && ve(e.derivedField).ok;
+    return {
+      representation: "typed-derived",
+      ownership: t,
+      completeness: (!s || s === "typed-derived") && h && (!e.expression && !e.calculatedFormula || a) ? "complete" : "incomplete",
+      computeStage: n,
+      runtimeExecutable: a,
+      legacyManual: !1
+    };
+  }
+  if (!(!!s || Oi(e)))
+    return {
+      representation: "physical",
+      ownership: t,
+      completeness: "not-calculated",
+      runtimeExecutable: !1,
+      legacyManual: !1
+    };
+  const d = n || (e.role === "groupby" || ((w = e.calculatedFieldOrigin) == null ? void 0 : w.role) === "groupby" ? "row" : void 0), c = t === "domain" || de(e) || e.fieldScope === "card" || e.fieldScope === "sheet" || e.fieldScope === "dashboard" ? "manual" : "inline-expression", u = s === "manual" || s === "inline-expression" ? s : c, m = (!s || s === "manual" || s === "inline-expression") && !(s === "inline-expression" && de(e));
+  return {
+    representation: u,
+    ownership: t,
+    completeness: a && m ? "complete" : "incomplete",
+    computeStage: d,
+    runtimeExecutable: a,
+    legacyManual: u === "manual" && t === "local" && !d
+  };
 }
-function va(e) {
+function Sa(e) {
+  if (e.calculationRepresentation) return e;
+  const { representation: t } = ht(e);
+  return t === "physical" ? e : { ...e, calculationRepresentation: t };
+}
+function Ia(e) {
+  return ht(e).computeStage;
+}
+function ka(e, t) {
+  return e === "aggregate" && t === "default";
+}
+function wa(e) {
   var n, o;
   const t = e;
   return !!(t != null && t.expression && ((o = (n = t.calculatedFormula) == null ? void 0 : n.inputFields) != null && o.length));
 }
-function Sa(e) {
-  return !!(e && (e.entityName === re || e.entityId === re));
+function Aa(e) {
+  return !!(e && (e.entityName === le || e.entityId === le));
 }
-function Ei(e) {
+function de(e) {
   return e ? [e.entityName, e.entityId, e.qualifiedEntityName].some(
-    (t) => t === re || t === Di
+    (t) => t === le || t === ji
   ) : !1;
 }
-var ji = /* @__PURE__ */ ((e) => (e.SUBTOTAL = "__SUBTOTAL__", e.TOTAL = "__TOTAL__", e.ALL = "__ALL__", e))(ji || {});
-const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
-  $i.innerType().strict(),
-  Ci.extend({ type: i.literal("date") }).strict(),
-  Oi.strict(),
-  Yi.strict(),
-  W
-]), y = i.string().min(1), mt = i.enum([
+var Yi = /* @__PURE__ */ ((e) => (e.SUBTOTAL = "__SUBTOTAL__", e.TOTAL = "__TOTAL__", e.ALL = "__ALL__", e))(Yi || {});
+const [Pi, Bi, qi, Li] = he.options, Ui = i.union([
+  Pi.innerType().strict(),
+  Bi.extend({ type: i.literal("date") }).strict(),
+  qi.strict(),
+  Li.strict(),
+  X
+]), v = i.string().min(1), Oe = i.enum(["groupby", "metric", "sortby", "pivotby", "detail"]), _t = i.enum([
   "table",
   "view",
   "materialized view",
@@ -1267,8 +1317,8 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
   "dataset",
   "url",
   "upload"
-]), ne = i.object({
-  connectionId: y,
+]), ae = i.object({
+  connectionId: v,
   connectionType: i.enum([
     "GoogleSheets",
     "FileUpload",
@@ -1284,13 +1334,13 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
     "API",
     "none"
   ]),
-  type: mt,
-  name: y,
+  type: _t,
+  name: v,
   // Grounded relationship plans retain semantic identity and display metadata.
   // SQL stays server-resolved; it is not accepted inside a join entity.
   alias: i.string().optional(),
-  id: y.optional(),
-  domainId: y.optional(),
+  id: v.optional(),
+  domainId: v.optional(),
   datasetType: i.enum(["physical", "virtual"]).optional(),
   label: i.string().optional(),
   description: i.string().optional(),
@@ -1307,36 +1357,41 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
     "duckdb",
     "mssql"
   ]).optional()
-}).strict(), H = i.lazy(
+}).strict(), G = i.lazy(
   () => i.object({
-    id: y,
-    name: y,
+    id: v,
+    name: v,
     label: i.string(),
     /** Set when `label` was synthesized from `name`; see `Field.derivedLabel`. */
     derivedLabel: i.string().optional(),
-    qualifiedFieldName: y,
-    dataType: y,
-    entityId: y,
-    entityName: y,
-    entityType: mt,
+    qualifiedFieldName: v,
+    dataType: v,
+    entityId: v,
+    entityName: v,
+    entityType: _t,
     alias: i.string().optional(),
     sourceField: i.string().optional(),
-    source: be.optional(),
+    source: Se.optional(),
     nativeDataType: i.string().optional(),
     description: i.string().optional(),
     qualifiedEntityName: i.string().optional(),
-    dateFormat: i.enum(Ni).optional(),
+    dateFormat: i.enum(Ci).optional(),
     customFormat: i.string().optional(),
-    granularity: L.optional(),
-    role: i.enum(["groupby", "metric", "sortby", "pivotby", "detail"]).optional(),
+    granularity: U.optional(),
+    role: Oe.optional(),
+    calculationRepresentation: i.enum(["inline-expression", "manual", "typed-derived"]).optional(),
+    calculatedFieldOrigin: i.object({ id: v, role: Oe.optional() }).strict().optional(),
+    aggregateOrigin: i.enum(["default", "explicit"]).optional(),
+    labelOrigin: i.enum(["semantic", "override"]).optional(),
+    formatOrigin: i.enum(["semantic", "override"]).optional(),
     expression: i.string().optional(),
-    derivedField: ye.optional(),
-    format: Pi.optional(),
+    derivedField: Ie.optional(),
+    format: Ui.optional(),
     semanticTemporalPresentation: i.object({
-      granularity: L,
-      format: W
+      granularity: U,
+      format: X
     }).strict().optional(),
-    aggregate: F.optional(),
+    aggregate: R.optional(),
     fieldScope: i.enum(["card", "sheet", "dashboard", "domain"]).optional(),
     calculatedFormula: i.object({
       operation: i.enum([
@@ -1349,19 +1404,20 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
         "scale",
         "custom"
       ]),
-      inputFields: i.array(H),
-      constant: i.number().finite().optional()
+      inputFields: i.array(G),
+      constant: i.number().finite().optional(),
+      computeStage: i.enum(["row", "aggregate"]).optional()
     }).strict().optional()
   }).strict()
-), Bi = i.union([
+), Vi = i.union([
   i.string(),
   i.number().finite(),
   i.boolean(),
   i.date(),
   i.null()
-]), qi = i.object({
-  id: y,
-  field: H,
+]), Hi = i.object({
+  id: v,
+  field: G,
   operator: i.enum([
     "=",
     "!=",
@@ -1381,9 +1437,9 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
     "isNull",
     "isNotNull"
   ]),
-  value: i.union([Bi, i.array(i.string()), i.array(i.number().finite())]),
+  value: i.union([Vi, i.array(i.string()), i.array(i.number().finite())]),
   label: i.string().optional(),
-  temporalBucket: se.optional()
+  temporalBucket: re.optional()
 }).strict().superRefine((e, t) => {
   const { operator: n, value: o } = e;
   (n === "between" || n === "not between") && (!Array.isArray(o) || o.length !== 2) && t.addIssue({
@@ -1395,21 +1451,21 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
     path: ["value"],
     message: "Membership requires an array."
   });
-}), ft = i.lazy(
+}), bt = i.lazy(
   () => i.object({
-    id: y,
+    id: v,
     logicalOperator: i.enum(["AND", "OR"]),
     negate: i.boolean(),
-    conditions: i.array(qi),
-    groups: i.array(ft)
+    conditions: i.array(Hi),
+    groups: i.array(bt)
   }).strict()
-), Li = i.object({
-  baseEntity: ne,
+), Gi = i.object({
+  baseEntity: ae,
   joins: i.array(
     i.object({
-      id: y,
-      source: ne,
-      target: ne,
+      id: v,
+      source: ae,
+      target: ae,
       joinType: i.enum(["INNER", "LEFT", "RIGHT", "FULL"]),
       sequence: i.number().int().nonnegative(),
       relationshipId: i.string().optional(),
@@ -1418,13 +1474,13 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
       relationshipTraversalDirection: i.enum(["forward", "reverse"]).optional(),
       joinKeyGroups: i.array(
         i.object({
-          id: y,
+          id: v,
           operator: i.enum(["AND", "OR"]),
           keys: i.array(
             i.object({
               id: i.string().optional(),
-              source: H,
-              target: H,
+              source: G,
+              target: G,
               operator: i.enum(["=", "!=", ">", ">=", "<", "<="])
             }).strict()
           ).min(1)
@@ -1432,14 +1488,14 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
       ).min(1)
     }).strict()
   )
-}).strict(), Ui = i.object({
-  axis: Ie,
+}).strict(), zi = i.object({
+  axis: Ae,
   levelId: i.string().uuid().optional(),
   // Persisted table preferences are edited through Immer; runtime paths remain readonly.
-  oppositePath: x.transform((e) => [...e]).optional()
-}).strict(), I = i.string().min(1), Vi = i.array(
+  oppositePath: F.transform((e) => [...e]).optional()
+}).strict(), I = i.string().min(1), Ki = i.array(
   i.enum(["body", "header", "footer", "subtotal", "grandTotal"])
-), Hi = i.enum(["normal", "medium", "semibold", "bold"]), Gi = i.enum(["none", "underline", "line-through"]), gt = i.object({
+), Qi = i.enum(["normal", "medium", "semibold", "bold"]), Wi = i.enum(["none", "underline", "line-through"]), yt = i.object({
   version: i.literal(1),
   rules: i.array(
     i.object({
@@ -1448,11 +1504,11 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
       enabled: i.boolean().optional(),
       target: i.object({
         level: i.enum(["cell", "row"]),
-        matrix: Ui.optional(),
+        matrix: zi.optional(),
         columnIds: i.array(I).optional(),
         conditionColumnId: I.optional(),
         applyToColumnIds: i.array(I).optional(),
-        tableParts: Vi.optional(),
+        tableParts: Ki.optional(),
         rowRoles: i.array(i.string()).optional(),
         depth: i.number().int().nonnegative().optional(),
         includeTotals: i.boolean().optional(),
@@ -1463,13 +1519,13 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
           kind: i.literal("comparison"),
           columnId: I,
           operator: i.enum(["eq", "neq", "gt", "gte", "lt", "lte"]),
-          value: q
+          value: L
         }).strict(),
         i.object({
           kind: i.literal("between"),
           columnId: I,
-          min: q,
-          max: q,
+          min: L,
+          max: L,
           inclusive: i.boolean().optional()
         }).strict(),
         i.object({
@@ -1516,64 +1572,64 @@ const [$i, Ci, Oi, Yi] = fe.options, Pi = i.union([
       style: i.object({
         backgroundColor: i.string().optional(),
         textColor: i.string().optional(),
-        fontWeight: Hi.optional(),
+        fontWeight: Qi.optional(),
         italic: i.boolean().optional(),
-        textDecoration: Gi.optional(),
+        textDecoration: Wi.optional(),
         icon: i.enum(["arrowUp", "arrowDown", "warning", "check", "x"]).optional(),
         dataBar: i.object({ color: i.string(), showValue: i.boolean() }).strict().optional()
       }).strict().optional()
     }).strict()
   )
 }).strict();
-function Ia(e, t) {
-  const n = (r) => {
-    if (V(r)) return r.value;
-    const l = typeof r == "string" ? Ai(r.trim()) ?? le(r) : le(r);
+function xa(e, t) {
+  const n = (s) => {
+    if (H(s)) return s.value;
+    const l = typeof s == "string" ? Ri(s.trim()) ?? ue(s) : ue(s);
     if (l === null) return null;
     try {
-      return xi(String(l));
+      return Ti(String(l));
     } catch {
       return null;
     }
   }, o = n(e), a = n(t);
-  return o === null || a === null ? null : ut(o, a);
+  return o === null || a === null ? null : mt(o, a);
 }
-function ka(e, t, n) {
-  const o = Qi(e);
+function Fa(e, t, n) {
+  const o = Ji(e);
   if (o === null) return null;
   if (typeof o == "number" && typeof t == "number" && typeof n == "number") {
-    const _ = Wi(o, t, n);
-    return { ratio: _, midpointComparison: Math.sign(_ - 0.5) };
+    const h = en(o, t, n);
+    return { ratio: h, midpointComparison: Math.sign(h - 0.5) };
   }
-  if ([t, n].some((_) => typeof _ == "number" && !Number.isFinite(_))) return null;
-  const a = [o, t, n].map((_) => {
-    const Nt = typeof _ == "number" ? A(String(_)) : _.value, [Et, Fe = ""] = Nt.split(".");
-    return { coefficient: Et + Fe, scale: Fe.length };
-  }), r = Math.max(...a.map((_) => _.scale)), [l, d, c] = a.map(
-    (_) => BigInt(_.coefficient) * 10n ** BigInt(r - _.scale)
+  if ([t, n].some((h) => typeof h == "number" && !Number.isFinite(h))) return null;
+  const a = [o, t, n].map((h) => {
+    const P = typeof h == "number" ? x(String(h)) : h.value, [Ct, Me = ""] = P.split(".");
+    return { coefficient: Ct + Me, scale: Me.length };
+  }), s = Math.max(...a.map((h) => h.scale)), [l, d, c] = a.map(
+    (h) => BigInt(h.coefficient) * 10n ** BigInt(s - h.scale)
   ), u = c - d, m = l - d;
   if (u <= 0n)
     return {
       ratio: l >= c ? 1 : 0,
       midpointComparison: l >= c ? 1 : -1
     };
-  const h = m * 2n - u, v = h < 0n ? -1 : h > 0n ? 1 : 0;
-  return { ratio: m <= 0n ? 0 : m >= u ? 1 : Number(m * 1000000000n / u) / 1e9, midpointComparison: v };
+  const _ = m * 2n - u, y = _ < 0n ? -1 : _ > 0n ? 1 : 0;
+  return { ratio: m <= 0n ? 0 : m >= u ? 1 : Number(m * 1000000000n / u) / 1e9, midpointComparison: y };
 }
-function wa(e) {
+function Ra(e) {
   return !!e && typeof e == "object" && !Array.isArray(e);
 }
-function Aa(e) {
+function Ta(e) {
   return e.enabled !== !1;
 }
-function xa(e) {
+function Ma(e) {
   return e.kind === "topBottom" || e.kind === "colorScale" && e.range === "auto" || e.kind === "dataBar" && e.range === "auto";
 }
-function zi(e) {
+function Xi(e) {
   return e.columnId;
 }
-function Ki(e) {
-  const t = [zi(e.condition)];
+function Zi(e) {
+  const t = [Xi(e.condition)];
   return { validationRefs: [.../* @__PURE__ */ new Set([
     ...t,
     ...e.target.conditionColumnId === void 0 ? [] : [e.target.conditionColumnId],
@@ -1581,7 +1637,7 @@ function Ki(e) {
     ...e.target.applyToColumnIds ?? []
   ])], evaluationInputs: t };
 }
-function le(e) {
+function ue(e) {
   if (typeof e == "number")
     return Number.isFinite(e) ? e : null;
   if (typeof e == "string" && e.trim() !== "") {
@@ -1590,30 +1646,30 @@ function le(e) {
   }
   return null;
 }
-function Qi(e) {
-  return V(e) ? e : le(e);
+function Ji(e) {
+  return H(e) ? e : ue(e);
 }
-function Fa(e) {
+function Da(e) {
   const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
   for (const o of e)
-    V(o) ? n.add(o.value) : t.add(o);
+    H(o) ? n.add(o.value) : t.add(o);
   return {
-    has: (o) => V(o) ? n.has(o.value) : t.has(o)
+    has: (o) => H(o) ? n.has(o.value) : t.has(o)
   };
 }
-function Ra(e, t) {
-  return typeof e == "number" && typeof t == "number" ? Math.sign(e - t) : ut(
-    typeof e == "number" ? A(String(e)) : e.value,
-    typeof t == "number" ? A(String(t)) : t.value
+function Na(e, t) {
+  return typeof e == "number" && typeof t == "number" ? Math.sign(e - t) : mt(
+    typeof e == "number" ? x(String(e)) : e.value,
+    typeof t == "number" ? x(String(t)) : t.value
   );
 }
-function Ta(e) {
+function Ea(e) {
   return e == null || e === "";
 }
-function Wi(e, t, n) {
+function en(e, t, n) {
   return !Number.isFinite(e) || !Number.isFinite(t) || !Number.isFinite(n) ? 0 : n === t ? e >= n ? 1 : 0 : Math.max(0, Math.min(1, (e - t) / (n - t)));
 }
-function Xi(e) {
+function tn(e) {
   switch (e) {
     case "bold":
       return 700;
@@ -1627,105 +1683,105 @@ function Xi(e) {
       return;
   }
 }
-function Ma(e) {
-  return e ? ht({
-    fontWeight: Xi(e.fontWeight),
+function ja(e) {
+  return e ? vt({
+    fontWeight: tn(e.fontWeight),
     fontStyle: e.italic ? "italic" : void 0,
     color: e.textColor,
     backgroundColor: e.backgroundColor,
     textDecoration: e.textDecoration
   }) : {};
 }
-function Da(...e) {
+function $a(...e) {
   return Object.assign(
     {},
-    ...e.filter((t) => !!t).map(ht)
+    ...e.filter((t) => !!t).map(vt)
   );
 }
-function ht(e) {
+function vt(e) {
   return Object.fromEntries(
     Object.entries(e).filter(([, t]) => t !== void 0)
   );
 }
-const S = i.string().uuid(), Zi = i.string().min(1), Ji = i.number().int().positive().max(Number.MAX_SAFE_INTEGER), en = i.enum([
+const S = i.string().uuid(), nn = i.string().min(1), an = i.number().int().positive().max(Number.MAX_SAFE_INTEGER), on = i.enum([
   "SUM",
   "COUNT",
   "DISTINCT",
   "AVG",
   "MIN",
   "MAX"
-]), _t = _i.omit({
+]), St = vi.omit({
   aggregate: !0
-}), tn = {
+}), sn = {
   id: S,
-  field: _t,
-  grain: L.optional()
-}, de = i.object(tn).strict(), nn = i.object({
+  field: St,
+  grain: U.optional()
+}, ce = i.object(sn).strict(), rn = i.object({
   id: S,
   kind: i.literal("aggregate"),
-  field: _t,
-  aggregate: en
-}).strict(), an = i.object({
+  field: St,
+  aggregate: on
+}).strict(), ln = i.object({
   id: S,
   kind: i.literal("calculated"),
-  definition: ye
-}).strict(), bt = i.discriminatedUnion("kind", [nn, an]), on = i.discriminatedUnion("kind", [
+  definition: Ie
+}).strict(), It = i.discriminatedUnion("kind", [rn, ln]), dn = i.discriminatedUnion("kind", [
   i.object({ kind: i.literal("member") }).strict(),
   i.object({
     kind: i.literal("measure"),
     measureId: S,
-    oppositePath: x
+    oppositePath: F
   }).strict()
-]), yt = i.object({
-  axis: Ie,
+]), kt = i.object({
+  axis: Ae,
   levelId: S,
   scope: i.discriminatedUnion("kind", [
     i.object({ kind: i.literal("level") }).strict(),
-    i.object({ kind: i.literal("branch"), parent: x }).strict()
+    i.object({ kind: i.literal("branch"), parent: F }).strict()
   ]),
-  target: on,
+  target: dn,
   direction: i.enum(["asc", "desc"]),
   nulls: i.enum(["first", "last"])
-}).strict(), sn = i.object({
+}).strict(), un = i.object({
   id: S,
-  axis: Ie,
+  axis: Ae,
   levelId: S,
   direction: i.enum(["top", "bottom"]),
-  count: Ji,
+  count: an,
   measureId: S,
-  oppositePath: x,
+  oppositePath: F,
   others: i.boolean()
-}).strict(), vt = i.object({
-  source: be,
-  rows: i.array(de).min(1).readonly(),
-  columns: i.array(de).readonly(),
-  measures: i.array(bt).min(1).readonly(),
-  filters: ft.optional(),
-  joinPlan: Li.optional(),
-  relationshipHint: i.object({ relationshipIds: i.array(Zi).optional() }).strict().optional(),
-  sorts: i.array(yt).readonly(),
-  rankings: i.array(sn).readonly()
+}).strict(), wt = i.object({
+  source: Se,
+  rows: i.array(ce).min(1).readonly(),
+  columns: i.array(ce).readonly(),
+  measures: i.array(It).min(1).readonly(),
+  filters: bt.optional(),
+  joinPlan: Gi.optional(),
+  relationshipHint: i.object({ relationshipIds: i.array(nn).optional() }).strict().optional(),
+  sorts: i.array(kt).readonly(),
+  rankings: i.array(un).readonly()
 }).strict();
-function St(e) {
+function At(e) {
   return JSON.stringify([
     e.axis,
     e.levelId,
     e.scope.kind,
-    e.scope.kind === "branch" ? pt(e.scope.parent) : null
+    e.scope.kind === "branch" ? gt(e.scope.parent) : null
   ]);
 }
 function g(e, t, n) {
   e.addIssue({ code: "custom", path: t, message: n });
 }
-function w(e, t, n) {
+function A(e, t, n) {
   new Set(e).size !== e.length && g(t, n, "Duplicate identity.");
 }
-function $(e, t, n, o, a, r = !1) {
+function $(e, t, n, o, a, s = !1) {
   n.length > e[t].length && g(o, a, "Path exceeds axis depth."), n.forEach((l, d) => {
     var c;
     if (l.levelId !== ((c = e[t][d]) == null ? void 0 : c.id) && g(o, [...a, d], "Path must be an ordered axis prefix."), l.member.kind === "others") {
       const u = l.member.rankingId;
-      (r || d !== n.length - 1 || !e.rankings.some(
+      (s || d !== n.length - 1 || !e.rankings.some(
         (m) => m.id === u && m.others && m.axis === t && m.levelId === l.levelId
       )) && g(
         o,
@@ -1735,9 +1791,9 @@ function $(e, t, n, o, a, r = !1) {
     }
   });
 }
-function It(e, t, n, o) {
-  w(t.map(St), n, o), t.forEach((a, r) => {
-    const l = [...o, r], d = e[a.axis].findIndex((c) => c.id === a.levelId);
+function xt(e, t, n, o) {
+  A(t.map(At), n, o), t.forEach((a, s) => {
+    const l = [...o, s], d = e[a.axis].findIndex((c) => c.id === a.levelId);
     if (d < 0 && g(n, l, "Sort level is not on its axis."), a.scope.kind === "branch" && ($(
       e,
       a.axis,
@@ -1762,35 +1818,35 @@ function It(e, t, n, o) {
     }
   });
 }
-function B(e, t, n, o) {
+function q(e, t, n, o) {
   e && (e.kind !== t.kind || e.kind === "semantic" && t.kind === "semantic" && e.domainId !== t.domainId || e.kind === "physical" && t.kind === "physical" && e.connectionId !== t.connectionId) && g(
     n,
     o,
     "Field source must belong to the same semantic domain or physical connection."
   );
 }
-function ae(e, t, n) {
+function oe(e, t, n) {
   (e.defaultAggregate === "MEDIAN" || Object.values(e.inputs).some(
     (o) => o.aggregate === "MEDIAN" || o.field.aggregate === "MEDIAN"
   )) && g(t, n, "MEDIAN dependencies are not supported at launch."), (e.aggregationBehavior === "snapshot" || e.aggregationBehavior === "weighted" || e.aggregationStrategy === "weighted") && g(t, n, "This measure semantic requires a later capability.");
 }
-function kt(e, t) {
-  w(
+function Ft(e, t) {
+  A(
     [...e.rows, ...e.columns, ...e.measures].map((a) => a.id),
     t,
     []
-  ), w(
+  ), A(
     e.rankings.map((a) => a.id),
     t,
     ["rankings"]
-  ), w(
+  ), A(
     e.rankings.map((a) => JSON.stringify([a.axis, a.levelId])),
     t,
     ["rankings"]
   );
   for (const a of ["rows", "columns"])
-    e[a].forEach((r, l) => {
-      r.grain && r.field.dataType !== void 0 && !["date", "datetime", "unknown"].includes(r.field.dataType) && g(t, [a, l, "grain"], "Grain requires a temporal field.");
+    e[a].forEach((s, l) => {
+      s.grain && s.field.dataType !== void 0 && !["date", "datetime", "unknown"].includes(s.field.dataType) && g(t, [a, l, "grain"], "Grain requires a temporal field.");
     });
   const n = [
     ...e.rows,
@@ -1798,7 +1854,7 @@ function kt(e, t) {
     ...e.measures.filter((a) => a.kind === "aggregate")
   ];
   for (const a of n)
-    if (B(a.field.source, e.source, t, [
+    if (q(a.field.source, e.source, t, [
       a.id,
       "field",
       "source"
@@ -1807,9 +1863,9 @@ function kt(e, t) {
         t,
         [a.id],
         "Aggregate-stage calculations cannot be grouped or wrapped in an aggregate."
-      ), ae(a.field.derivedField, t, [a.id]);
-      for (const r of Object.values(a.field.derivedField.inputs))
-        B(r.field.source, e.source, t, [a.id, "inputs"]);
+      ), oe(a.field.derivedField, t, [a.id]);
+      for (const s of Object.values(a.field.derivedField.inputs))
+        q(s.field.source, e.source, t, [a.id, "inputs"]);
     }
   for (const a of e.measures)
     if (a.kind === "calculated") {
@@ -1817,72 +1873,72 @@ function kt(e, t) {
         t,
         [a.id],
         "Calculated measures require aggregate stage and measure role."
-      ), ae(a.definition, t, [a.id]);
-      for (const r of Object.values(a.definition.inputs))
-        B(r.field.source, e.source, t, [
+      ), oe(a.definition, t, [a.id]);
+      for (const s of Object.values(a.definition.inputs))
+        q(s.field.source, e.source, t, [
           a.id,
           "inputs"
         ]);
     }
   const o = (a) => {
-    const r = (l, d) => {
+    const s = (l, d) => {
       var c, u;
       if ((l.aggregate || ((c = l.derivedField) == null ? void 0 : c.computeStage) === "aggregate") && g(t, d, "Aggregate/HAVING filters are not supported."), l.derivedField) {
-        ae(l.derivedField, t, d);
+        oe(l.derivedField, t, d);
         for (const m of Object.values(l.derivedField.inputs))
-          B(m.field.source, e.source, t, d);
+          q(m.field.source, e.source, t, d);
       }
       for (const m of ((u = l.calculatedFormula) == null ? void 0 : u.inputFields) ?? [])
-        r(m, d);
+        s(m, d);
     };
     for (const l of a.conditions)
-      r(l.field, ["filters", l.id]);
+      s(l.field, ["filters", l.id]);
     a.groups.forEach(o);
   };
   if (e.filters && o(e.filters), e.joinPlan) {
     const a = [
       e.joinPlan.baseEntity,
-      ...e.joinPlan.joins.flatMap((r) => [r.source, r.target])
+      ...e.joinPlan.joins.flatMap((s) => [s.source, s.target])
     ];
-    (new Set(a.map((r) => r.connectionId)).size > 1 || e.source.kind === "physical" && a[0].connectionId !== e.source.connectionId) && g(t, ["joinPlan"], "Joins must stay within the source connection."), w(
-      e.joinPlan.joins.map((r) => r.id),
+    (new Set(a.map((s) => s.connectionId)).size > 1 || e.source.kind === "physical" && a[0].connectionId !== e.source.connectionId) && g(t, ["joinPlan"], "Joins must stay within the source connection."), A(
+      e.joinPlan.joins.map((s) => s.id),
       t,
       ["joinPlan", "joins"]
     );
   }
-  It(e, e.sorts, t, ["sorts"]), e.rankings.forEach((a, r) => {
-    (!e[a.axis].some((l) => l.id === a.levelId) || !e.measures.some((l) => l.id === a.measureId)) && g(t, ["rankings", r], "Unknown ranking level or measure."), $(
+  xt(e, e.sorts, t, ["sorts"]), e.rankings.forEach((a, s) => {
+    (!e[a.axis].some((l) => l.id === a.levelId) || !e.measures.some((l) => l.id === a.measureId)) && g(t, ["rankings", s], "Unknown ranking level or measure."), $(
       e,
       a.axis === "rows" ? "columns" : "rows",
       a.oppositePath,
       t,
-      ["rankings", r, "oppositePath"],
+      ["rankings", s, "oppositePath"],
       !0
     );
   });
 }
-const Y = vt.superRefine(kt), rn = vt.extend({
-  rows: i.array(de).readonly(),
-  measures: i.array(bt).readonly()
-}), ln = rn.superRefine(kt), dn = Y.innerType().extend({ kind: i.literal("matrix") }), un = dn.superRefine(({ kind: e, ...t }, n) => {
+const Y = wt.superRefine(Ft), cn = wt.extend({
+  rows: i.array(ce).readonly(),
+  measures: i.array(It).readonly()
+}), pn = cn.superRefine(Ft), mn = Y.innerType().extend({ kind: i.literal("matrix") }), fn = mn.superRefine(({ kind: e, ...t }, n) => {
   const o = Y.safeParse(t);
   o.success || o.error.issues.forEach((a) => n.addIssue(a));
-}), je = i.object({
+}), Ye = i.object({
   visible: i.boolean(),
   position: i.enum(["before", "after"]),
   label: i.string().optional()
-}).strict(), $e = i.object({
-  grand: je,
-  levels: i.record(S, je).readonly()
-}).strict(), Ce = gt.shape.rules.element, cn = gt.extend({
-  rules: i.array(Ce.extend({
-    target: Ce.shape.target.extend({
-      rowRoles: i.array(Ti).optional()
+}).strict(), Pe = i.object({
+  grand: Ye,
+  levels: i.record(S, Ye).readonly()
+}).strict(), Be = yt.shape.rules.element, gn = yt.extend({
+  rules: i.array(Be.extend({
+    target: Be.shape.target.extend({
+      rowRoles: i.array(Ni).optional()
     })
   }))
 }).superRefine((e, t) => {
   var n;
-  w(e.rules.map((o) => o.id), t, ["rules"]);
+  A(e.rules.map((o) => o.id), t, ["rules"]);
   for (const o of e.rules) {
     const a = o.condition;
     a.kind === "topBottom" && g(
@@ -1904,13 +1960,13 @@ const Y = vt.superRefine(kt), rn = vt.extend({
     );
   }
 });
-function pn(e, t, n, o, a = []) {
-  for (const r of e.rules) {
-    const l = [...a, "rules", r.id], d = r.target.matrix;
-    d && (d.levelId !== void 0 && !t[d.axis].some((c) => c.id === d.levelId) && g(o, [...l, "target", "matrix", "levelId"], "Conditional-format level is not on the selected axis."), d.oppositePath !== void 0 && $(t, d.axis === "rows" ? "columns" : "rows", d.oppositePath, o, [...l, "target", "matrix", "oppositePath"])), Ki(r).validationRefs.some((c) => !n.has(c)) && g(o, l, "Conditional rules must reference displayed measures.");
+function hn(e, t, n, o, a = []) {
+  for (const s of e.rules) {
+    const l = [...a, "rules", s.id], d = s.target.matrix;
+    d && (d.levelId !== void 0 && !t[d.axis].some((c) => c.id === d.levelId) && g(o, [...l, "target", "matrix", "levelId"], "Conditional-format level is not on the selected axis."), d.oppositePath !== void 0 && $(t, d.axis === "rows" ? "columns" : "rows", d.oppositePath, o, [...l, "target", "matrix", "oppositePath"])), Zi(s).validationRefs.some((c) => !n.has(c)) && g(o, l, "Conditional rules must reference displayed measures.");
   }
 }
-const mn = {
+const _n = {
   layout: i.discriminatedUnion("kind", [
     i.object({ kind: i.literal("compact") }).strict(),
     i.object({ kind: i.literal("tabular"), repeatLabels: i.boolean() }).strict()
@@ -1918,27 +1974,27 @@ const mn = {
   absence: i.object({ emptyText: i.string(), nullText: i.string() }).strict(),
   levelLabels: i.record(S, i.string()).readonly(),
   measureLabels: i.record(S, i.string()).readonly(),
-  levelFormats: i.record(S, Me).readonly(),
-  measureFormats: i.record(S, Me).readonly(),
-  totals: i.object({ rows: $e, columns: $e }).strict(),
-  conditionalFormatting: cn.optional()
-}, ke = i.object(mn).strict(), fn = i.object({
+  levelFormats: i.record(S, Ee).readonly(),
+  measureFormats: i.record(S, Ee).readonly(),
+  totals: i.object({ rows: Pe, columns: Pe }).strict(),
+  conditionalFormatting: gn.optional()
+}, xe = i.object(_n).strict(), bn = i.object({
   depth: i.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
   overrides: i.array(
-    i.object({ path: x, expanded: i.boolean() }).strict()
+    i.object({ path: F, expanded: i.boolean() }).strict()
   ).readonly()
-}).strict(), Oe = fn.superRefine(
-  (e, t) => w(
-    e.overrides.map((n) => pt(n.path)),
+}).strict(), qe = bn.superRefine(
+  (e, t) => A(
+    e.overrides.map((n) => gt(n.path)),
     t,
     ["overrides"]
   )
-), gn = { rows: Oe, columns: Oe }, Z = i.object(gn).strict(), hn = Z.extend({ sorts: i.array(yt).readonly() }).strict(), _n = hn.superRefine(
-  (e, t) => w(e.sorts.map(St), t, ["sorts"])
+), yn = { rows: qe, columns: qe }, J = i.object(yn).strict(), vn = J.extend({ sorts: i.array(kt).readonly() }).strict(), Sn = vn.superRefine(
+  (e, t) => A(e.sorts.map(At), t, ["sorts"])
 );
-function J(e, t) {
+function ee(e, t) {
   var c;
-  const { spec: n, presentation: o, defaults: a, session: r } = e, l = new Set([...n.rows, ...n.columns].map((u) => u.id)), d = new Set(n.measures.map((u) => u.id));
+  const { spec: n, presentation: o, defaults: a, session: s } = e, l = new Set([...n.rows, ...n.columns].map((u) => u.id)), d = new Set(n.measures.map((u) => u.id));
   for (const u of [
     "levelLabels",
     "levelFormats",
@@ -1946,10 +2002,10 @@ function J(e, t) {
     "measureFormats"
   ]) {
     const m = u.startsWith("level") ? l : d;
-    for (const h of Object.keys(o[u]))
-      m.has(h) || g(
+    for (const _ of Object.keys(o[u]))
+      m.has(_) || g(
         t,
-        ["presentation", u, h],
+        ["presentation", u, _],
         "Unknown presentation reference."
       );
   }
@@ -1960,34 +2016,34 @@ function J(e, t) {
       "Measures cannot own temporal bucket formats."
     );
   for (const [u, m] of Object.entries(o.levelFormats))
-    m.type === "temporal_bucket" && !((c = [...n.rows, ...n.columns].find((h) => h.id === u)) != null && c.grain) && g(
+    m.type === "temporal_bucket" && !((c = [...n.rows, ...n.columns].find((_) => _.id === u)) != null && c.grain) && g(
       t,
       ["presentation", "levelFormats", u],
       "Temporal bucket formats require a grain."
     );
   for (const u of ["rows", "columns"]) {
     const m = Object.keys(o.totals[u].levels);
-    (m.length !== n[u].length || m.some((h) => !n[u].some((v) => v.id === h))) && g(
+    (m.length !== n[u].length || m.some((_) => !n[u].some((y) => y.id === _))) && g(
       t,
       ["presentation", "totals", u],
       "Subtotal map must contain exactly the current axis levels."
     );
-    for (const h of [a, ...r ? [r] : []])
-      for (const v of h[u].overrides)
+    for (const _ of [a, ...s ? [s] : []])
+      for (const y of _[u].overrides)
         $(
           n,
           u,
-          v.path,
+          y.path,
           t,
           [u, "overrides"],
           !0
-        ), v.path.length || g(
+        ), y.path.length || g(
           t,
           [u, "overrides"],
           "Use depth to expand/collapse the root."
         );
   }
-  r && It(n, r.sorts, t, ["session", "sorts"]), o.conditionalFormatting && pn(
+  s && xt(n, s.sorts, t, ["session", "sorts"]), o.conditionalFormatting && hn(
     o.conditionalFormatting,
     n,
     d,
@@ -1995,32 +2051,32 @@ function J(e, t) {
     ["presentation", "conditionalFormatting"]
   );
 }
-const bn = i.object({
+const In = i.object({
   spec: Y,
-  presentation: ke,
-  defaults: Z,
-  session: _n.optional()
-}).strict(), Na = bn.superRefine(J), yn = i.object({
+  presentation: xe,
+  defaults: J,
+  session: Sn.optional()
+}).strict(), Ca = In.superRefine(ee), kn = i.object({
   version: i.literal(1),
   spec: Y,
-  presentation: ke,
-  defaultView: Z
-}).strict(), vn = yn.superRefine(
-  (e, t) => J({ ...e, defaults: e.defaultView }, t)
-), Sn = vn.innerType().extend({
-  spec: ln
-}), Ea = Sn.superRefine((e, t) => J({ ...e, defaults: e.defaultView }, t)), Ye = i.object({ spec: Y, presentation: ke }).strict(), In = i.union([
-  Ye.extend({
+  presentation: xe,
+  defaultView: J
+}).strict(), wn = kn.superRefine(
+  (e, t) => ee({ ...e, defaults: e.defaultView }, t)
+), An = wn.innerType().extend({
+  spec: pn
+}), Oa = An.superRefine((e, t) => ee({ ...e, defaults: e.defaultView }, t)), Le = i.object({ spec: Y, presentation: xe }).strict(), xn = i.union([
+  Le.extend({
     mode: i.literal("layout"),
     format: i.enum(["csv", "xlsx", "pdf"]),
     expansion: i.union([
-      Z.extend({ kind: i.literal("current") }).strict(),
+      J.extend({ kind: i.literal("current") }).strict(),
       i.object({ kind: i.literal("all") }).strict()
     ])
   }).strict(),
-  Ye.extend({ mode: i.literal("flat"), format: i.literal("csv") }).strict()
-]), ja = In.superRefine(
-  (e, t) => J(
+  Le.extend({ mode: i.literal("flat"), format: i.literal("csv") }).strict()
+]), Ya = xn.superRefine(
+  (e, t) => ee(
     {
       ...e,
       defaults: e.mode === "layout" && e.expansion.kind === "current" ? e.expansion : {
@@ -2031,17 +2087,17 @@ const bn = i.object({
     t
   )
 );
-function $a(e) {
+function Pa(e) {
   return e && "id" in e ? e.id : void 0;
 }
-const kn = "SUM";
+const Fn = "SUM";
 function k(e) {
   return typeof e == "string" && e.trim().length > 0;
 }
 function N(e) {
   return k(e) ? e.trim().toLowerCase() : "";
 }
-function Ca(e) {
+function Ba(e) {
   const t = k(e.id) ? e.id.trim() : void 0;
   if (!t) return;
   const n = N(t), o = k(e.table) ? e.table.trim() : void 0;
@@ -2053,7 +2109,7 @@ function T(e) {
   if (t)
     return N(t) === N(e.datasetName) ? void 0 : t;
 }
-function wt(e) {
+function Rt(e) {
   if (e.kind !== "semantic") return e;
   const t = T(e), { datasetId: n, ...o } = e;
   return {
@@ -2061,10 +2117,10 @@ function wt(e) {
     ...t ? { datasetId: t } : {}
   };
 }
-function Oa(e) {
+function qa(e) {
   return e ? e.kind === "semantic" ? !!(k(e.domainId) && (k(e.datasetId) || k(e.datasetName))) : e.kind === "physical" ? k(e.connectionId) && k(e.tableName) : k(e.connectionId) : !1;
 }
-function ue(e) {
+function pe(e) {
   if (!e)
     return "";
   if (e.kind === "semantic") {
@@ -2088,7 +2144,7 @@ function ue(e) {
     e.label || ""
   ].join(":");
 }
-function we(e, t) {
+function Fe(e, t) {
   if (!e || !t)
     return e === t;
   if (e.kind !== t.kind)
@@ -2099,10 +2155,10 @@ function we(e, t) {
     const n = T(e), o = T(t);
     return n && o ? n === o : e.datasetName === t.datasetName;
   }
-  return ue(e) === ue(t);
+  return pe(e) === pe(t);
 }
-function At(e, t) {
-  return e.kind !== "semantic" || t.kind !== "semantic" ? e : wt({
+function Tt(e, t) {
+  return e.kind !== "semantic" || t.kind !== "semantic" ? e : Rt({
     ...e,
     datasetName: e.datasetName || t.datasetName,
     datasetId: T(e) || T(t),
@@ -2110,79 +2166,79 @@ function At(e, t) {
     connectionId: e.connectionId || t.connectionId
   });
 }
-function Ya(e) {
+function La(e) {
   const t = [];
   for (const n of e) {
-    const o = wt(
+    const o = Rt(
       n
     ), a = t.findIndex(
-      (r) => we(r, o)
+      (s) => Fe(s, o)
     );
     if (a === -1) {
       t.push(o);
       continue;
     }
-    t[a] = At(
+    t[a] = Tt(
       t[a],
       o
     );
   }
   return t;
 }
-function wn(e, t) {
-  return e.name === t.name && we(e.source, t.source);
+function Rn(e, t) {
+  return e.name === t.name && Fe(e.source, t.source);
 }
-function Pa(e) {
+function Ua(e) {
   return [
-    e.source ? ue(e.source) : "unknown",
-    xt(e),
+    e.source ? pe(e.source) : "unknown",
+    Mt(e),
     e.name
   ].filter(Boolean).join(":");
 }
-function xt(e) {
-  return An(
-    e.aggregate || kn
+function Mt(e) {
+  return Tn(
+    e.aggregate || Fn
   );
 }
-function An(e) {
+function Tn(e) {
   return e.trim().toUpperCase();
 }
-function Ba(e, t) {
+function Va(e, t) {
   return {
     ...e,
     label: e.label || t.label,
     role: e.role || t.role,
     dataType: e.dataType || t.dataType,
-    source: e.source && t.source ? At(e.source, t.source) : e.source || t.source
+    source: e.source && t.source ? Tt(e.source, t.source) : e.source || t.source
   };
 }
-function xn(e) {
+function Mn(e) {
   for (let t = 0; t < e.length; t += 1) {
     const n = e[t];
     if (e.some(
-      (o, a) => a !== t && Rt(o, n)
+      (o, a) => a !== t && Nt(o, n)
     ))
       return !1;
   }
   return !0;
 }
-function Ft(e, t) {
-  return wn(e, t);
+function Dt(e, t) {
+  return Rn(e, t);
 }
-function Rt(e, t) {
-  return Ft(e, t) && C(e) === C(t);
+function Nt(e, t) {
+  return Dt(e, t) && C(e) === C(t);
 }
-function Fn(e) {
+function Dn(e) {
   return `Metric intent has duplicate measure "${e.name}" with the same aggregate (${C(e)}). Use different aggregates to request both, or remove one entry.`;
 }
-function Pe(e) {
+function Ue(e) {
   return typeof e == "string" || typeof e == "number" || typeof e == "boolean" || e === null;
 }
-function Rn(e, t, n) {
+function Nn(e, t, n) {
   if (e !== void 0) {
     if (!e || typeof e != "object" || Array.isArray(e)) {
       n.push(
-        s(
+        r(
           "invalid_sql_default_parameters",
           "SQL defaultParameters must be an object keyed by parameter name.",
           t
@@ -2193,7 +2249,7 @@ function Rn(e, t, n) {
     Object.entries(e).forEach(([o, a]) => {
       if (!o.trim()) {
         n.push(
-          s(
+          r(
             "invalid_sql_default_parameter_name",
             "SQL defaultParameters names must be non-empty strings.",
             `${t}.${o}`
@@ -2201,8 +2257,8 @@ function Rn(e, t, n) {
         );
         return;
       }
-      (Array.isArray(a) ? a.every(Pe) : Pe(a)) || n.push(
-        s(
+      (Array.isArray(a) ? a.every(Ue) : Ue(a)) || n.push(
+        r(
           "invalid_sql_default_parameter_value",
           "SQL defaultParameters values must be strings, numbers, booleans, nulls, or arrays of those scalar values.",
           `${t}.${o}`
@@ -2211,72 +2267,72 @@ function Rn(e, t, n) {
     });
   }
 }
-function Tn(e, t) {
-  return Ae(e, t).length === 1;
+function En(e, t) {
+  return Re(e, t).length === 1;
 }
-function Mn(e, t) {
-  return Ae(e, t).length === 1;
+function jn(e, t) {
+  return Re(e, t).length === 1;
 }
-function Ae(e, t) {
+function Re(e, t) {
   return t.filter(
-    (o) => Dn(e, o)
+    (o) => $n(e, o)
   );
 }
-function Dn(e, t) {
-  return Nn(e, t) ? e.source ? Ft(t, e) : !0 : !1;
+function $n(e, t) {
+  return Cn(e, t) ? e.source ? Dt(t, e) : !0 : !1;
 }
-function Nn(e, t) {
-  return !(t.name !== e.name || e.role !== void 0 && t.role !== void 0 && t.role !== e.role || En(e, t) && C(t) !== C(e));
+function Cn(e, t) {
+  return !(t.name !== e.name || e.role !== void 0 && t.role !== void 0 && t.role !== e.role || On(e, t) && C(t) !== C(e));
 }
-function En(e, t) {
+function On(e, t) {
   return e.role === "measure" || t.role === "measure" || e.aggregate !== void 0 || t.aggregate !== void 0;
 }
 function C(e) {
-  return xt(e);
+  return Mt(e);
 }
-const jn = /^(\d{4})-(\d{2})-(\d{2})$/, Tt = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?(Z|[+-]\d{2}:\d{2})$/;
-function ce(e) {
+const Yn = /^(\d{4})-(\d{2})-(\d{2})$/, Et = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?(Z|[+-]\d{2}:\d{2})$/;
+function me(e) {
   if (typeof e != "string")
     return null;
-  const t = e.trim(), n = jn.exec(t);
+  const t = e.trim(), n = Yn.exec(t);
   if (n) {
-    const [, v, R, _] = n;
-    return Be(v, R, _) ? new Date(Date.UTC(Number(v), Number(R) - 1, Number(_))) : null;
+    const [, y, w, h] = n;
+    return Ve(y, w, h) ? new Date(Date.UTC(Number(y), Number(w) - 1, Number(h))) : null;
   }
-  const o = Tt.exec(t);
+  const o = Et.exec(t);
   if (!o)
     return null;
-  const [, a, r, l, d, c, u = "00", , m] = o;
-  if (!Be(a, r, l) || !E(d, 0, 23) || !E(c, 0, 59) || !E(u, 0, 59) || !$n(m))
+  const [, a, s, l, d, c, u = "00", , m] = o;
+  if (!Ve(a, s, l) || !E(d, 0, 23) || !E(c, 0, 59) || !E(u, 0, 59) || !Pn(m))
     return null;
-  const h = new Date(t);
-  return Number.isFinite(h.getTime()) ? h : null;
+  const _ = new Date(t);
+  return Number.isFinite(_.getTime()) ? _ : null;
 }
-function qa(e) {
-  return typeof e != "string" || !Tt.test(e.trim()) ? null : ce(e);
+function Ha(e) {
+  return typeof e != "string" || !Et.test(e.trim()) ? null : me(e);
 }
-function Be(e, t, n) {
-  const o = Number(e), a = Number(t), r = Number(n);
-  if (!Number.isInteger(o) || !Number.isInteger(a) || !Number.isInteger(r) || a < 1 || a > 12)
+function Ve(e, t, n) {
+  const o = Number(e), a = Number(t), s = Number(n);
+  if (!Number.isInteger(o) || !Number.isInteger(a) || !Number.isInteger(s) || a < 1 || a > 12)
     return !1;
-  const l = new Date(Date.UTC(o, a - 1, r));
-  return l.getUTCFullYear() === o && l.getUTCMonth() === a - 1 && l.getUTCDate() === r;
+  const l = new Date(Date.UTC(o, a - 1, s));
+  return l.getUTCFullYear() === o && l.getUTCMonth() === a - 1 && l.getUTCDate() === s;
 }
 function E(e, t, n) {
   const o = Number(e);
   return Number.isInteger(o) && o >= t && o <= n;
 }
-function $n(e) {
+function Pn(e) {
   if (e === "Z")
     return !0;
   const t = /^([+-])(\d{2}):(\d{2})$/.exec(e);
   return !!(t && E(t[2], 0, 23) && E(t[3], 0, 59));
 }
-function qe(e, t, n) {
+function He(e, t, n) {
   if (e !== void 0) {
     if (!f(e)) {
       n.push(
-        s(
+        r(
           "invalid_pagination",
           "Pagination must be an object with positive integer page and pageSize.",
           t
@@ -2285,13 +2341,13 @@ function qe(e, t, n) {
       return;
     }
     (!Number.isInteger(e.page) || typeof e.page != "number" || e.page < 1) && n.push(
-      s(
+      r(
         "invalid_pagination_page",
         "Pagination page must be a positive integer.",
         `${t}.page`
       )
     ), (!Number.isInteger(e.pageSize) || typeof e.pageSize != "number" || e.pageSize < 1) && n.push(
-      s(
+      r(
         "invalid_pagination_page_size",
         "Pagination pageSize must be a positive integer.",
         `${t}.pageSize`
@@ -2299,7 +2355,7 @@ function qe(e, t, n) {
     );
   }
 }
-function Le(e) {
+function Ge(e) {
   const t = /* @__PURE__ */ new Set();
   for (const n of e) {
     if (t.has(n))
@@ -2308,10 +2364,10 @@ function Le(e) {
   }
   return null;
 }
-function Cn(e, t, n) {
+function Bn(e, t, n) {
   if (!f(e)) {
     n.push(
-      s(
+      r(
         "invalid_input_binding",
         "Input bindings must be structured objects.",
         t
@@ -2320,27 +2376,27 @@ function Cn(e, t, n) {
     return;
   }
   p(e.inputId) || n.push(
-    s(
+    r(
       "invalid_input_binding",
       "Input bindings need a non-empty inputId.",
       `${t}.inputId`
     )
   ), e.kind !== void 0 && e.kind !== "filter" && e.kind !== "control" && n.push(
-    s(
+    r(
       "invalid_input_binding",
       "Input binding kind must be filter or control.",
       `${t}.kind`
     )
-  ), e.field !== void 0 && b(e.field, `${t}.field`, n), e.relationshipHint !== void 0 && xe(
+  ), e.field !== void 0 && b(e.field, `${t}.field`, n), e.relationshipHint !== void 0 && Te(
     e.relationshipHint,
     `${t}.relationshipHint`,
     n
   );
 }
-function xe(e, t, n) {
+function Te(e, t, n) {
   if (!f(e)) {
     n.push(
-      s(
+      r(
         "invalid_relationship_hint",
         "Relationship hints must be structured objects.",
         t
@@ -2349,39 +2405,39 @@ function xe(e, t, n) {
     return;
   }
   e.relationshipIds !== void 0 && (!Array.isArray(e.relationshipIds) || e.relationshipIds.some((o) => !p(o))) && n.push(
-    s(
+    r(
       "invalid_relationship_hint",
       "Relationship hint relationshipIds must be non-empty strings.",
       `${t}.relationshipIds`
     )
   );
 }
-function On(e, t) {
+function qn(e, t) {
   var o, a;
   if (((o = e.source) == null ? void 0 : o.kind) !== "semantic" && ((a = e.source) == null ? void 0 : a.kind) !== "physical" && t.push(
-    s(
+    r(
       "invalid_input_options_source",
       "Input options must use a semantic or physical source.",
       "source"
     )
   ), p(e.inputId) || t.push(
-    s(
+    r(
       "missing_input_options_input_id",
       "Input options intent needs the inputId it populates.",
       "inputId"
     )
   ), e.search !== void 0 && typeof e.search != "string" && t.push(
-    s(
+    r(
       "invalid_input_options_search",
       "Input options search must be a string.",
       "search"
     )
   ), e.matchValues !== void 0) {
-    const r = Yt(e.matchValues);
-    r.ok || t.push(
-      s("invalid_input_options_match_values", r.error, "matchValues")
+    const s = qt(e.matchValues);
+    s.ok || t.push(
+      r("invalid_input_options_match_values", s.error, "matchValues")
     ), typeof e.search == "string" && e.search.trim() && t.push(
-      s(
+      r(
         "invalid_input_options_match_values",
         "Input options matchValues cannot be combined with search.",
         "matchValues"
@@ -2389,13 +2445,13 @@ function On(e, t) {
     );
   }
   if (e.limit !== void 0 && (typeof e.limit != "number" || !Number.isFinite(e.limit) || !Number.isInteger(e.limit) || e.limit <= 0) && t.push(
-    s(
+    r(
       "invalid_input_options_limit",
       "Input options limit must be a positive finite number.",
       "limit"
     )
   ), (!e.labelField || !p(e.labelField.name)) && t.push(
-    s(
+    r(
       "missing_input_options_label_field",
       "Input options intent needs a labelField.",
       "labelField"
@@ -2403,7 +2459,7 @@ function On(e, t) {
   ), b(e.labelField, "labelField", t, {
     required: !0
   }), (!e.valueField || !p(e.valueField.name)) && t.push(
-    s(
+    r(
       "missing_input_options_value_field",
       "Input options intent needs a valueField.",
       "valueField"
@@ -2412,12 +2468,12 @@ function On(e, t) {
     required: !0
   }), e.searchField !== void 0 && b(e.searchField, "searchField", t, {
     required: !0
-  }), e.disambiguationFields !== void 0 && (Array.isArray(e.disambiguationFields) ? e.disambiguationFields.forEach((r, l) => {
-    b(r, `disambiguationFields.${l}`, t, {
+  }), e.disambiguationFields !== void 0 && (Array.isArray(e.disambiguationFields) ? e.disambiguationFields.forEach((s, l) => {
+    b(s, `disambiguationFields.${l}`, t, {
       required: !0
     });
   }) : t.push(
-    s(
+    r(
       "invalid_input_options_disambiguation_fields",
       "Input options disambiguationFields must be an array of field refs.",
       "disambiguationFields"
@@ -2426,71 +2482,71 @@ function On(e, t) {
     { field: e.labelField, path: "labelField" },
     { field: e.valueField, path: "valueField" },
     ...e.searchField ? [{ field: e.searchField, path: "searchField" }] : [],
-    ...Array.isArray(e.disambiguationFields) ? e.disambiguationFields.map((r, l) => ({
-      field: r,
+    ...Array.isArray(e.disambiguationFields) ? e.disambiguationFields.map((s, l) => ({
+      field: s,
       path: `disambiguationFields.${l}`
     })) : []
-  ].forEach(({ field: r, path: l }) => {
-    r != null && r.source && !we(r.source, e.source) && t.push(
-      s(
+  ].forEach(({ field: s, path: l }) => {
+    s != null && s.source && !Fe(s.source, e.source) && t.push(
+      r(
         "input_options_field_source_mismatch",
         "Input option fields must belong to the declared option source.",
         `${l}.source`
       )
     );
   }), e.dependencies !== void 0) {
-    const r = Pn(
+    const s = Un(
       e.dependencies
     );
-    t.push(...r.errors), r.ok && qn(e, t);
+    t.push(...s.errors), s.ok && Hn(e, t);
   }
   if (e.population !== void 0) {
-    const r = e.population;
-    if (!f(r))
+    const s = e.population;
+    if (!f(s))
       t.push(
-        s(
+        r(
           "invalid_input_options_population",
           "Input options population must be a structured object.",
           "population"
         )
       );
     else {
-      const l = r.kind;
+      const l = s.kind;
       l !== "option_source" && l !== "related_population" && t.push(
-        s(
+        r(
           "invalid_input_options_population",
           "Input options population kind must be option_source or related_population.",
           "population.kind"
         )
-      ), l === "option_source" && r.baseSource !== void 0 && t.push(
-        s(
+      ), l === "option_source" && s.baseSource !== void 0 && t.push(
+        r(
           "invalid_input_options_population",
           "Input options population baseSource is only valid for related_population.",
           "population.baseSource"
         )
-      ), l === "option_source" && r.relationshipHint !== void 0 && t.push(
-        s(
+      ), l === "option_source" && s.relationshipHint !== void 0 && t.push(
+        r(
           "invalid_input_options_population",
           "Input options population relationshipHint is only valid for related_population.",
           "population.relationshipHint"
         )
-      ), l === "related_population" && (he(
-        r.baseSource,
+      ), l === "related_population" && (be(
+        s.baseSource,
         "population.baseSource",
         t
-      ), r.relationshipHint !== void 0 && xe(
-        r.relationshipHint,
+      ), s.relationshipHint !== void 0 && Te(
+        s.relationshipHint,
         "population.relationshipHint",
         t
       ));
     }
   }
 }
-function Yn(e, t) {
+function Ln(e, t) {
   if (!(!("inputs" in e) || e.inputs === void 0)) {
     if (!Array.isArray(e.inputs)) {
       t.push(
-        s(
+        r(
           "invalid_input_binding",
           "Analytics intent inputs must be an array of input bindings.",
           "inputs"
@@ -2499,15 +2555,15 @@ function Yn(e, t) {
       return;
     }
     e.inputs.forEach(
-      (n, o) => Cn(n, `inputs.${o}`, t)
+      (n, o) => Bn(n, `inputs.${o}`, t)
     );
   }
 }
-function Pn(e, t = "protocol") {
+function Un(e, t = "protocol") {
   const n = [];
   if (!f(e))
     return n.push(
-      s(
+      r(
         "invalid_input_options_dependencies",
         "Input options dependencies must be a structured object.",
         "dependencies"
@@ -2515,88 +2571,88 @@ function Pn(e, t = "protocol") {
     ), { ok: !1, errors: n, warnings: [] };
   const o = e, a = o.mode;
   if (a !== void 0 && a !== "independent" && a !== "explicit" && a !== "all_applicable" && n.push(
-    s(
+    r(
       "invalid_input_options_dependencies",
       "Input options dependencies mode must be independent, explicit, or all_applicable.",
       "dependencies.mode"
     )
-  ), oe(
+  ), se(
     o.includeInputIds,
     "dependencies.includeInputIds",
     n,
     "Input options includeInputIds must be non-empty strings."
-  ), oe(
+  ), se(
     o.excludeInputIds,
     "dependencies.excludeInputIds",
     n,
     "Input options excludeInputIds must be non-empty strings."
   ), a === "all_applicable" && o.includeInputIds !== void 0 && n.push(
-    s(
+    r(
       "invalid_input_options_dependencies",
       "All applicable dependencies cannot specify includeInputIds.",
       "dependencies.includeInputIds"
     )
-  ), oe(
+  ), se(
     o.omitInputIds,
     "dependencies.omitInputIds",
     n,
     "Input options omitInputIds must be non-empty strings."
   ), Array.isArray(o.omitInputIds)) {
-    const r = new Set(
+    const s = new Set(
       Array.isArray(o.includeInputIds) ? o.includeInputIds : []
     );
-    (a !== "explicit" || new Set(o.omitInputIds).size !== o.omitInputIds.length || o.omitInputIds.some((l) => !r.has(l))) && n.push(
-      s(
+    (a !== "explicit" || new Set(o.omitInputIds).size !== o.omitInputIds.length || o.omitInputIds.some((l) => !s.has(l))) && n.push(
+      r(
         "invalid_input_options_dependencies",
         "A browse override may only omit unique ids from an explicit includeInputIds list.",
         "dependencies.omitInputIds"
       )
     );
   }
-  return t === "dashboard" && Bn(o, n), { ok: n.length === 0, errors: n, warnings: [] };
+  return t === "dashboard" && Vn(o, n), { ok: n.length === 0, errors: n, warnings: [] };
 }
-function Bn(e, t) {
+function Vn(e, t) {
   const { mode: n, includeInputIds: o, excludeInputIds: a } = e;
   n === void 0 && t.push(
-    s(
+    r(
       "invalid_input_options_dependencies",
       "Dashboard option dependencies must declare a mode.",
       "dependencies.mode"
     )
   );
-  for (const [r, l] of [
+  for (const [s, l] of [
     ["dependencies.includeInputIds", o],
     ["dependencies.excludeInputIds", a]
   ])
     Array.isArray(l) && new Set(l).size !== l.length && t.push(
-      s(
+      r(
         "invalid_input_options_dependencies",
         "Dashboard option dependency input IDs must be unique.",
-        r
+        s
       )
     );
   n === "independent" && (o !== void 0 || a !== void 0) && t.push(
-    s(
+    r(
       "invalid_input_options_dependencies",
       "Independent dashboard dependencies cannot specify input IDs.",
       "dependencies"
     )
   ), n === "explicit" && (!Array.isArray(o) || o.length === 0 || a !== void 0) && t.push(
-    s(
+    r(
       "invalid_input_options_dependencies",
       "Explicit dashboard dependencies require included input IDs and cannot specify exclusions.",
       "dependencies"
     )
   );
 }
-function qn(e, t) {
-  var a, r, l;
+function Hn(e, t) {
+  var a, s, l;
   const n = new Set(
     Array.isArray(e.inputs) ? e.inputs.map((d) => f(d) ? d.inputId : void 0).filter((d) => typeof d == "string") : []
   ), o = new Set(((a = e.dependencies) == null ? void 0 : a.omitInputIds) || []);
-  for (const d of ((r = e.dependencies) == null ? void 0 : r.includeInputIds) || [])
+  for (const d of ((s = e.dependencies) == null ? void 0 : s.includeInputIds) || [])
     !n.has(d) && !o.has(d) && t.push(
-      s(
+      r(
         "invalid_input_options_dependencies",
         `Input options dependency "${d}" is not declared in inputs.`,
         "dependencies.includeInputIds"
@@ -2604,21 +2660,21 @@ function qn(e, t) {
     );
   for (const d of ((l = e.dependencies) == null ? void 0 : l.excludeInputIds) || [])
     d !== e.inputId && !n.has(d) && t.push(
-      s(
+      r(
         "invalid_input_options_dependencies",
         `Input options dependency exclusion "${d}" is not the populated inputId and is not declared in inputs.`,
         "dependencies.excludeInputIds"
       )
     );
 }
-function oe(e, t, n, o) {
-  e !== void 0 && (!Array.isArray(e) || e.some((a) => !p(a))) && n.push(s("invalid_input_options_dependencies", o, t));
+function se(e, t, n, o) {
+  e !== void 0 && (!Array.isArray(e) || e.some((a) => !p(a))) && n.push(r("invalid_input_options_dependencies", o, t));
 }
-const Ln = new Set(G);
-function Un(e, t, n) {
+const Gn = new Set(z);
+function zn(e, t, n) {
   if (f(e) && e.type === "temporal_bucket") {
     n.push(
-      s(
+      r(
         "invalid_scalar_value_format",
         "Scalar and measure slots cannot own temporal bucket presentation; declare it with grain on a grouped field or axis.",
         t
@@ -2626,12 +2682,12 @@ function Un(e, t, n) {
     );
     return;
   }
-  Je(e, t, n);
+  nt(e, t, n);
 }
-function Ue(e, t, n) {
+function ze(e, t, n) {
   if (!f(e)) {
     n.push(
-      s(
+      r(
         "invalid_result_column_ref",
         "Result calculation references must use columnKey or field.",
         t
@@ -2642,7 +2698,7 @@ function Ue(e, t, n) {
   const o = p(e.columnKey), a = f(e.field);
   if (o === a) {
     n.push(
-      s(
+      r(
         "invalid_result_column_ref",
         "Result calculation references must identify exactly one of columnKey or field.",
         t
@@ -2654,10 +2710,10 @@ function Ue(e, t, n) {
     required: !0
   });
 }
-function Vn(e, t, n) {
+function Kn(e, t, n) {
   if (!f(e)) {
     n.push(
-      s(
+      r(
         "invalid_result_calculation_output",
         "Result calculation output must be a structured object.",
         t
@@ -2666,25 +2722,25 @@ function Vn(e, t, n) {
     return;
   }
   p(e.key) || n.push(
-    s(
+    r(
       "invalid_result_calculation_output",
       "Result calculation output needs a stable key.",
       `${t}.key`
     )
-  ), e.dataType !== void 0 && (typeof e.dataType != "string" || !Ze.has(e.dataType)) && n.push(
-    s(
+  ), e.dataType !== void 0 && (typeof e.dataType != "string" || !it.has(e.dataType)) && n.push(
+    r(
       "invalid_result_calculation_output",
       "Result calculation output dataType must be string, number, boolean, date, datetime, or unknown.",
       `${t}.dataType`
     )
-  ), Un(e.format, `${t}.format`, n);
+  ), zn(e.format, `${t}.format`, n);
 }
-function Hn(e, t) {
+function Qn(e, t) {
   if (e.analysis === void 0)
     return;
   if (!f(e.analysis)) {
     t.push(
-      s(
+      r(
         "invalid_measure_analysis",
         "Metric analysis must be a structured object.",
         "analysis"
@@ -2694,7 +2750,7 @@ function Hn(e, t) {
   }
   if (e.analysis.kind !== "period_change") {
     t.push(
-      s(
+      r(
         "invalid_measure_analysis",
         "Metric analysis kind is not supported.",
         "analysis.kind"
@@ -2703,31 +2759,31 @@ function Hn(e, t) {
     return;
   }
   e.dateField || t.push(
-    s(
+    r(
       "missing_analysis_date_field",
       "Period-change analysis needs a dateField.",
       "dateField"
     )
   ), e.timeGrain || t.push(
-    s(
+    r(
       "missing_analysis_time_grain",
       "Period-change analysis needs a timeGrain.",
       "timeGrain"
     )
   ), e.analysis.orderBy !== void 0 && e.analysis.orderBy !== "absolute_change" && e.analysis.orderBy !== "positive_change" && e.analysis.orderBy !== "negative_change" && e.analysis.orderBy !== "period" && t.push(
-    s(
+    r(
       "invalid_measure_analysis",
       "Period-change analysis orderBy must be absolute_change, positive_change, negative_change, or period.",
       "analysis.orderBy"
     )
   );
   const { timeWindow: n } = e.analysis;
-  n !== void 0 && pe(n, "analysis.timeWindow", t);
+  n !== void 0 && fe(n, "analysis.timeWindow", t);
 }
-function pe(e, t, n) {
+function fe(e, t, n) {
   if (!f(e)) {
     n.push(
-      s(
+      r(
         "invalid_time_window",
         "Time window must be a structured object.",
         t
@@ -2736,40 +2792,40 @@ function pe(e, t, n) {
     return;
   }
   if (e.kind !== void 0 && e.kind !== "relative" && e.kind !== "absolute" && n.push(
-    s(
+    r(
       "invalid_time_window",
       "Time window kind must be relative or absolute.",
       `${t}.kind`
     )
   ), e.kind === "absolute") {
     if (p(e.start) || n.push(
-      s(
+      r(
         "invalid_time_window",
         "Absolute time window start must be a non-empty ISO date or timestamp string.",
         `${t}.start`
       )
     ), p(e.end) || n.push(
-      s(
+      r(
         "invalid_time_window",
         "Absolute time window end must be a non-empty ISO date or timestamp string.",
         `${t}.end`
       )
     ), p(e.start) && p(e.end)) {
-      const o = ce(e.start), a = ce(e.end);
+      const o = me(e.start), a = me(e.end);
       o || n.push(
-        s(
+        r(
           "invalid_time_window",
           "Absolute time window start must be a valid ISO date or timestamp.",
           `${t}.start`
         )
       ), a || n.push(
-        s(
+        r(
           "invalid_time_window",
           "Absolute time window end must be a valid ISO date or timestamp.",
           `${t}.end`
         )
       ), o && a && o.getTime() > a.getTime() && n.push(
-        s(
+        r(
           "invalid_time_window",
           "Absolute time window start must be before or equal to end.",
           t
@@ -2778,37 +2834,37 @@ function pe(e, t, n) {
     }
     return;
   }
-  (typeof e.unit != "string" || !Ln.has(e.unit)) && n.push(
-    s(
+  (typeof e.unit != "string" || !Gn.has(e.unit)) && n.push(
+    r(
       "invalid_time_window",
-      `Time window unit must be one of: ${G.join(", ")}.`,
+      `Time window unit must be one of: ${z.join(", ")}.`,
       `${t}.unit`
     )
   ), (typeof e.value != "number" || !Number.isFinite(e.value) || e.value <= 0) && n.push(
-    s(
+    r(
       "invalid_time_window",
       "Time window value must be a positive number.",
       `${t}.value`
     )
   ), e.anchor !== void 0 && e.anchor !== "now" && e.anchor !== "latest_available" && n.push(
-    s(
+    r(
       "invalid_time_window",
       "Time window anchor must be now or latest_available.",
       `${t}.anchor`
     )
   ), e.completeness !== void 0 && e.completeness !== "include_partial" && e.completeness !== "complete_periods" && n.push(
-    s(
+    r(
       "invalid_time_window",
       "Time window completeness must be include_partial or complete_periods.",
       `${t}.completeness`
     )
   );
 }
-function me(e, t, n) {
+function ge(e, t, n) {
   if (e !== void 0) {
     if (!Array.isArray(e)) {
       n.push(
-        s(
+        r(
           "invalid_analytics_filters",
           "Analytics filters must be an array.",
           t
@@ -2818,62 +2874,62 @@ function me(e, t, n) {
     }
     e.forEach((o, a) => {
       var c;
-      const r = `${t}.${a}`;
+      const s = `${t}.${a}`;
       if (!f(o)) {
         n.push(
-          s(
+          r(
             "invalid_analytics_filter",
             "Analytics filter must be a structured object.",
-            r
+            s
           )
         );
         return;
       }
       const l = o;
-      b(l.field, `${r}.field`, n, {
+      b(l.field, `${s}.field`, n, {
         required: !0
       }), l.scope !== void 0 && l.scope !== "row" && l.scope !== "aggregate" && n.push(
-        s(
+        r(
           "invalid_analytics_filter_scope",
           "Analytics filter scope must be row or aggregate.",
-          `${r}.scope`
+          `${s}.scope`
         )
       ), l.scope === "aggregate" && ((c = l.field) == null ? void 0 : c.role) !== void 0 && l.field.role !== "measure" && n.push(
-        s(
+        r(
           "invalid_analytics_filter_scope",
           "Aggregate-scope analytics filters must target a measure field.",
-          `${r}.scope`
+          `${s}.scope`
         )
       );
       const d = l.operator === "is_null" || l.operator === "is_not_null";
       if (l.operator !== void 0 && l.operator !== "=" && l.operator !== "!=" && l.operator !== "in" && l.operator !== "not_in" && l.operator !== "contains" && l.operator !== "not_contains" && l.operator !== "between" && l.operator !== "not_between" && l.operator !== ">" && l.operator !== ">=" && l.operator !== "<" && l.operator !== "<=" && l.operator !== "is_null" && l.operator !== "is_not_null" && n.push(
-        s(
+        r(
           "invalid_analytics_filter_operator",
           "Analytics filter operator is not supported.",
-          `${r}.operator`
+          `${s}.operator`
         )
       ), l.values === void 0 && !d && n.push(
-        s(
+        r(
           "missing_analytics_filter_value",
           "Analytics filter needs values unless it is a null check.",
-          r
+          s
         )
       ), d && l.values !== void 0) {
         n.push(
-          s(
+          r(
             "invalid_analytics_filter_values",
             "Null-check analytics filters must not include values.",
-            `${r}.values`
+            `${s}.values`
           )
         );
         return;
       }
       if (l.values !== void 0 && !Array.isArray(l.values)) {
         n.push(
-          s(
+          r(
             "invalid_analytics_filter_values",
             "Analytics filter values must be an array when provided.",
-            `${r}.values`
+            `${s}.values`
           )
         );
         return;
@@ -2882,68 +2938,68 @@ function me(e, t, n) {
         const u = l.values.length;
         if (l.operator === "between" || l.operator === "not_between") {
           u !== 2 && n.push(
-            s(
+            r(
               "invalid_analytics_filter_values",
               "Between analytics filters must include exactly two values.",
-              `${r}.values`
+              `${s}.values`
             )
           );
           return;
         }
         (l.operator === "contains" || l.operator === "not_contains" || l.operator === "=" || l.operator === "!=" || l.operator === ">" || l.operator === ">=" || l.operator === "<" || l.operator === "<=" || l.operator === void 0) && u !== 1 && n.push(
-          s(
+          r(
             "invalid_analytics_filter_values",
             "Scalar analytics filters must include exactly one value. Use in/not_in for multiple values.",
-            `${r}.values`
+            `${s}.values`
           )
         );
       }
     });
   }
 }
-function La(e) {
+function Ga(e) {
   const t = [];
   if (!f(e))
     return t.push(
-      s(
+      r(
         "invalid_result_calculation",
         "Result calculation must be a structured object."
       )
     ), { ok: !1, errors: t, warnings: [] };
   if (p(e.id) || t.push(
-    s(
+    r(
       "invalid_result_calculation_id",
       "Result calculation needs an id.",
       "id"
     )
   ), p(e.label) || t.push(
-    s(
+    r(
       "invalid_result_calculation_label",
       "Result calculation needs a label.",
       "label"
     )
   ), e.kind !== "percent_of_total" && e.kind !== "rank" && e.kind !== "running_total" && e.kind !== "previous_row_delta" && t.push(
-    s(
+    r(
       "invalid_result_calculation_kind",
       "Result calculation kind must be percent_of_total, rank, running_total, or previous_row_delta.",
       "kind"
     )
-  ), Ue(e.input, "input", t), Vn(e.output, "output", t), e.kind === "percent_of_total") {
+  ), ze(e.input, "input", t), Kn(e.output, "output", t), e.kind === "percent_of_total") {
     const n = e.denominator;
     n !== void 0 && (f(n) ? n.scope === "population" ? (b(n.metric, "denominator.metric", t, {
       required: !0
-    }), me(
+    }), ge(
       n.filters,
       "denominator.filters",
       t
     )) : n.scope !== "returned_result" && t.push(
-      s(
+      r(
         "invalid_result_calculation_denominator",
         "Percent-of-total denominator scope must be returned_result or population.",
         "denominator.scope"
       )
     ) : t.push(
-      s(
+      r(
         "invalid_result_calculation_denominator",
         "Percent-of-total denominator must be a structured object.",
         "denominator"
@@ -2951,21 +3007,21 @@ function La(e) {
     ));
   }
   return e.kind === "rank" && e.order !== void 0 && e.order !== "asc" && e.order !== "desc" && t.push(
-    s(
+    r(
       "invalid_result_calculation_order",
       "Rank result calculation order must be asc or desc.",
       "order"
     )
-  ), (e.kind === "running_total" || e.kind === "previous_row_delta") && e.orderBy !== void 0 && Ue(e.orderBy, "orderBy", t), { ok: t.length === 0, errors: t, warnings: [] };
+  ), (e.kind === "running_total" || e.kind === "previous_row_delta") && e.orderBy !== void 0 && ze(e.orderBy, "orderBy", t), { ok: t.length === 0, errors: t, warnings: [] };
 }
-function Mt(e) {
+function jt(e) {
   var o;
   const t = [], n = [];
   if (!e || typeof e != "object")
     return {
       ok: !1,
       errors: [
-        s(
+        r(
           "invalid_analytics_intent",
           "Analytics intent must be a structured object."
         )
@@ -2979,101 +3035,101 @@ function Mt(e) {
       ]
     };
   if (e.kind === "matrix") {
-    const a = un.safeParse(e);
-    return a.success || t.push(...a.error.issues.map((r) => s("invalid_matrix_intent", r.message, r.path.join(".")))), { ok: t.length === 0, errors: t, warnings: n, repairHints: Ve(t) };
+    const a = fn.safeParse(e);
+    return a.success || t.push(...a.error.issues.map((s) => r("invalid_matrix_intent", s.message, s.path.join(".")))), { ok: t.length === 0, errors: t, warnings: n, repairHints: Ke(t) };
   }
   if (e.version !== void 0 && e.version !== 1 && t.push(
-    s(
+    r(
       "invalid_version",
       "Analytics intent version must be 1.",
       "version"
     )
-  ), he(e.source, "source", t), Gn(e, t), Yn(e, t), "relationshipHint" in e && e.relationshipHint !== void 0 && xe(
+  ), be(e.source, "source", t), Wn(e, t), Ln(e, t), "relationshipHint" in e && e.relationshipHint !== void 0 && Te(
     e.relationshipHint,
     "relationshipHint",
     t
   ), e.kind === "metric") {
     const a = Array.isArray(e.measures) ? e.measures.filter(
-      (r) => f(r) && p(r.name)
+      (s) => f(s) && p(s.name)
     ) : [];
     if (!Array.isArray(e.measures) || e.measures.length === 0 ? t.push(
-      s(
+      r(
         "missing_measure",
         "Metric intent needs at least one measure.",
         "measures"
       )
     ) : e.measures.some(
-      (r) => !f(r) || !p(r.name)
+      (s) => !f(s) || !p(s.name)
     ) && t.push(
-      s(
+      r(
         "invalid_measure_list",
         "Metric intent measures must be an array of field references with names.",
         "measures"
       )
-    ), a.forEach((r, l) => {
-      b(r, `measures.${l}`, t, {
+    ), a.forEach((s, l) => {
+      b(s, `measures.${l}`, t, {
         required: !0
       });
-    }), a.length > 0 && !xn(a)) {
-      const r = a.find(
+    }), a.length > 0 && !Mn(a)) {
+      const s = a.find(
         (l, d) => a.some(
-          (c, u) => u !== d && Rt(c, l)
+          (c, u) => u !== d && Nt(c, l)
         )
       );
-      r && t.push(
-        s(
+      s && t.push(
+        r(
           "duplicate_measure",
-          Fn(r),
+          Dn(s),
           "measures"
         )
       );
     }
-    if (f(e.primaryMeasure) && p(e.primaryMeasure.name) && Ae(
+    if (f(e.primaryMeasure) && p(e.primaryMeasure.name) && Re(
       e.primaryMeasure,
       a
     ).length > 1 && t.push(
-      s(
+      r(
         "ambiguous_primary_measure",
         "Metric intent primaryMeasure must identify exactly one selected measure.",
         "primaryMeasure"
       )
     ), e.primaryMeasure !== void 0 && (b(e.primaryMeasure, "primaryMeasure", t, {
       required: !0
-    }), f(e.primaryMeasure) && p(e.primaryMeasure.name) && a.length > 0 && !Tn(
+    }), f(e.primaryMeasure) && p(e.primaryMeasure.name) && a.length > 0 && !En(
       e.primaryMeasure,
       a
     ) && t.push(
-      s(
+      r(
         "invalid_primary_measure",
         "Metric intent primaryMeasure must match one measure field reference.",
         "primaryMeasure"
       )
     )), e.dimensions !== void 0 && !Array.isArray(e.dimensions) ? t.push(
-      s(
+      r(
         "invalid_measure_dimensions",
         "Metric intent dimensions must be an array of field references.",
         "dimensions"
       )
     ) : Array.isArray(e.dimensions) && e.dimensions.some(
-      (r) => !f(r) || !p(r.name)
+      (s) => !f(s) || !p(s.name)
     ) && t.push(
-      s(
+      r(
         "invalid_measure_dimensions",
         "Metric intent dimensions must be an array of field references with names.",
         "dimensions"
       )
-    ), e.dateField !== void 0 && b(e.dateField, "dateField", t), e.timeWindow !== void 0 && (pe(e.timeWindow, "timeWindow", t), e.dateField || t.push(
-      s(
+    ), e.dateField !== void 0 && b(e.dateField, "dateField", t), e.timeWindow !== void 0 && (fe(e.timeWindow, "timeWindow", t), e.dateField || t.push(
+      r(
         "missing_time_window_date_field",
         "Metric timeWindow needs a dateField.",
         "dateField"
       )
-    )), me(e.filters, "filters", t), Array.isArray(e.dimensions) && e.dimensions.forEach((r, l) => {
-      b(r, `dimensions.${l}`, t);
+    )), ge(e.filters, "filters", t), Array.isArray(e.dimensions) && e.dimensions.forEach((s, l) => {
+      b(s, `dimensions.${l}`, t);
     }), e.orderBy !== void 0) {
       if (!f(e.orderBy))
         t.push(
-          s(
+          r(
             "invalid_measure_order_by",
             "Metric intent orderBy must be a structured object.",
             "orderBy"
@@ -3082,24 +3138,24 @@ function Mt(e) {
       else if (b(e.orderBy.field, "orderBy.field", t, {
         required: !0
       }), e.orderBy.direction !== "asc" && e.orderBy.direction !== "desc" && t.push(
-        s(
+        r(
           "invalid_measure_order_direction",
           "Metric intent orderBy direction must be asc or desc.",
           "orderBy.direction"
         )
       ), f(e.orderBy.field) && p(e.orderBy.field.name)) {
-        const r = [
+        const s = [
           ...a,
           ...e.timeGrain && e.dateField && f(e.dateField) ? [e.dateField] : [],
           ...Array.isArray(e.dimensions) ? e.dimensions.filter(
             (l) => f(l) && p(l.name)
           ) : []
         ];
-        r.length > 0 && !Mn(
+        s.length > 0 && !jn(
           e.orderBy.field,
-          r
+          s
         ) && t.push(
-          s(
+          r(
             "invalid_measure_order_by",
             "Metric intent orderBy.field must match one selected measure, grouped dateField, or dimension.",
             "orderBy.field"
@@ -3107,10 +3163,10 @@ function Mt(e) {
         );
       }
     }
-    Hn(e, t);
+    Qn(e, t);
   } else if (e.kind === "records") {
     if (!Array.isArray(e.fields) || e.fields.length === 0 ? t.push(
-      s(
+      r(
         "missing_record_fields",
         "Records intent needs at least one field.",
         "fields"
@@ -3118,37 +3174,37 @@ function Mt(e) {
     ) : e.fields.some(
       (a) => !f(a) || !p(a.name)
     ) && t.push(
-      s(
+      r(
         "invalid_record_fields",
         "Records intent fields must be field references with names.",
         "fields"
       )
-    ), Array.isArray(e.fields) && e.fields.forEach((a, r) => {
-      b(a, `fields.${r}`, t);
-    }), e.dateField !== void 0 && b(e.dateField, "dateField", t), qe(e.pagination, "pagination", t), e.timeWindow !== void 0 && (pe(e.timeWindow, "timeWindow", t), e.dateField || t.push(
-      s(
+    ), Array.isArray(e.fields) && e.fields.forEach((a, s) => {
+      b(a, `fields.${s}`, t);
+    }), e.dateField !== void 0 && b(e.dateField, "dateField", t), He(e.pagination, "pagination", t), e.timeWindow !== void 0 && (fe(e.timeWindow, "timeWindow", t), e.dateField || t.push(
+      r(
         "missing_time_window_date_field",
         "Records timeWindow needs a dateField.",
         "dateField"
       )
-    )), me(e.filters, "filters", t), Array.isArray(e.filters) && e.filters.forEach((a, r) => {
+    )), ge(e.filters, "filters", t), Array.isArray(e.filters) && e.filters.forEach((a, s) => {
       f(a) && a.scope === "aggregate" && t.push(
-        s(
+        r(
           "unsupported_record_filter_scope",
           "Records intents support row-scope filters only. Use a metric intent for aggregate-scope filters.",
-          `filters.${r}.scope`
+          `filters.${s}.scope`
         )
       );
     }), e.orderBy !== void 0 && (f(e.orderBy) ? (b(e.orderBy.field, "orderBy.field", t, {
       required: !0
     }), e.orderBy.direction !== "asc" && e.orderBy.direction !== "desc" && t.push(
-      s(
+      r(
         "invalid_record_order_direction",
         "Records intent orderBy direction must be asc or desc.",
         "orderBy.direction"
       )
     )) : t.push(
-      s(
+      r(
         "invalid_record_order_by",
         "Records intent orderBy must be a structured object.",
         "orderBy"
@@ -3156,7 +3212,7 @@ function Mt(e) {
     )), e.totals !== void 0)
       if (!f(e.totals))
         t.push(
-          s(
+          r(
             "invalid_records_totals",
             "Records totals must be a structured server totals request.",
             "totals"
@@ -3164,7 +3220,7 @@ function Mt(e) {
         );
       else {
         e.totals.mode !== "server" && t.push(
-          s(
+          r(
             "invalid_records_totals",
             "Records totals mode must be server.",
             "totals.mode"
@@ -3172,16 +3228,16 @@ function Mt(e) {
         );
         const a = e.totals.measures;
         !Array.isArray(a) || a.length === 0 ? t.push(
-          s(
+          r(
             "missing_records_totals_measures",
             "Records server totals need at least one measure.",
             "totals.measures"
           )
-        ) : a.forEach((r, l) => {
-          b(r, `totals.measures.${l}`, t, {
+        ) : a.forEach((s, l) => {
+          b(s, `totals.measures.${l}`, t, {
             required: !0
-          }), (!f(r) || r.role !== "measure") && t.push(
-            s(
+          }), (!f(s) || s.role !== "measure") && t.push(
+            r(
               "invalid_records_totals_measure",
               "Records server totals measures must be measure field references.",
               `totals.measures.${l}.role`
@@ -3189,22 +3245,22 @@ function Mt(e) {
           );
         });
       }
-  } else e.kind === "inputOptions" ? On(e, t) : e.kind === "sql" ? (((o = e.source) == null ? void 0 : o.kind) !== "sql" && t.push(
-    s(
+  } else e.kind === "inputOptions" ? qn(e, t) : e.kind === "sql" ? (((o = e.source) == null ? void 0 : o.kind) !== "sql" && t.push(
+    r(
       "invalid_sql_source",
       "SQL analytics intent must use a SQL execution source.",
       "source"
     )
   ), p(e.sql) || t.push(
-    s("missing_sql", "SQL analytics intent needs SQL text.", "sql")
-  ), Rn(
+    r("missing_sql", "SQL analytics intent needs SQL text.", "sql")
+  ), Nn(
     e.defaultParameters,
     "defaultParameters",
     t
-  ), Array.isArray(e.fields) && e.fields.forEach((a, r) => {
-    b(a, `fields.${r}`, t);
-  }), qe(e.pagination, "pagination", t)) : t.push(
-    s(
+  ), Array.isArray(e.fields) && e.fields.forEach((a, s) => {
+    b(a, `fields.${s}`, t);
+  }), He(e.pagination, "pagination", t)) : t.push(
+    r(
       "invalid_analytics_kind",
       "Analytics kind is not supported.",
       "kind"
@@ -3214,14 +3270,14 @@ function Mt(e) {
     ok: t.length === 0,
     errors: t,
     warnings: n,
-    repairHints: Ve(t)
+    repairHints: Ke(t)
   };
 }
-function Gn(e, t) {
+function Wn(e, t) {
   if (!(!("derivedFields" in e) || e.derivedFields === void 0)) {
     if (!Array.isArray(e.derivedFields)) {
       t.push(
-        s(
+        r(
           "invalid_derived_fields",
           "Analytics intent derivedFields must be an array of derived field definitions.",
           "derivedFields"
@@ -3230,24 +3286,24 @@ function Gn(e, t) {
       return;
     }
     e.derivedFields.forEach((n, o) => {
-      et(
+      ve(
         n
-      ).errors.forEach((r) => {
+      ).errors.forEach((s) => {
         t.push({
-          ...r,
-          path: r.path ? `derivedFields.${o}.${r.path}` : `derivedFields.${o}`
+          ...s,
+          path: s.path ? `derivedFields.${o}.${s.path}` : `derivedFields.${o}`
         });
       });
     });
   }
 }
-function zn(e) {
+function Xn(e) {
   const t = [], n = [];
   if (!e || typeof e != "object")
     return {
       ok: !1,
       errors: [
-        s(
+        r(
           "invalid_operation_intent",
           "Operation intent must be a structured object."
         )
@@ -3261,27 +3317,27 @@ function zn(e) {
       ]
     };
   if (e.version !== 1 && t.push(
-    s(
+    r(
       "invalid_version",
       "Operation intent version must be 1.",
       "version"
     )
   ), e.kind === "answer_obligations")
     !Array.isArray(e.obligations) || e.obligations.length === 0 ? t.push(
-      s(
+      r(
         "missing_obligations",
         "Answer-obligations operation intent needs at least one obligation.",
         "obligations"
       )
     ) : e.obligations.forEach((o, a) => {
       p(o.id) || t.push(
-        s(
+        r(
           "missing_obligation_id",
           "Each analytics obligation needs an id.",
           `obligations.${a}.id`
         )
       ), p(o.prompt) || t.push(
-        s(
+        r(
           "missing_obligation_prompt",
           "Each analytics obligation needs a prompt.",
           `obligations.${a}.prompt`
@@ -3290,20 +3346,20 @@ function zn(e) {
     });
   else if (e.kind === "dashboard_change" || e.kind === "data_app_change") {
     if (p(e.instruction) || t.push(
-      s(
+      r(
         "missing_instruction",
         "Change operation intent needs an instruction.",
         "instruction"
       )
     ), e.analyticsIntent) {
-      const o = Mt(
+      const o = jt(
         e.analyticsIntent
       );
       t.push(...o.errors), n.push(...o.warnings);
     }
   } else
     t.push(
-      s(
+      r(
         "invalid_operation_kind",
         "Operation intent kind is not supported.",
         "kind"
@@ -3313,16 +3369,16 @@ function zn(e) {
     ok: t.length === 0,
     errors: t,
     warnings: n,
-    repairHints: Dt(t)
+    repairHints: $t(t)
   };
 }
-function Ua(e) {
+function za(e) {
   const t = [], n = [];
   if (!e || typeof e != "object")
     return {
       ok: !1,
       errors: [
-        s(
+        r(
           "invalid_recovery_plan",
           "Analytics recovery plan must be a structured object."
         )
@@ -3336,19 +3392,19 @@ function Ua(e) {
       ]
     };
   e.version !== 1 && t.push(
-    s("invalid_version", "Recovery plan version must be 1.", "version")
+    r("invalid_version", "Recovery plan version must be 1.", "version")
   ), e.kind !== "analytics_recovery_plan" && t.push(
-    s(
+    r(
       "invalid_recovery_plan_kind",
       "Recovery plan kind must be analytics_recovery_plan.",
       "kind"
     )
   );
-  const o = zn(
+  const o = Xn(
     e.operationIntent
   );
   return t.push(...o.errors), n.push(...o.warnings), Array.isArray(e.plannedToolCalls) || t.push(
-    s(
+    r(
       "invalid_planned_tool_calls",
       "Recovery plan plannedToolCalls must be an array.",
       "plannedToolCalls"
@@ -3357,16 +3413,16 @@ function Ua(e) {
     ok: t.length === 0,
     errors: t,
     warnings: n,
-    repairHints: Dt(t)
+    repairHints: $t(t)
   };
 }
-function Dt(e) {
+function $t(e) {
   return e.map((t) => ({
     code: t.code,
     recommendedNextStep: t.code === "missing_obligations" ? "Normalize the user request into one or more typed analytics obligations before recovery planning." : "Correct the operation/recovery contract shape before planning execution."
   }));
 }
-function Ve(e) {
+function Ke(e) {
   return e.map((t) => {
     switch (t.code) {
       case "invalid_matrix_intent":
@@ -3454,18 +3510,18 @@ function Ve(e) {
     }
   }).filter((t) => !!t);
 }
-function Kn(e, t, n, o) {
+function Zn(e, t, n, o) {
   if (!e || typeof e != "object") {
     n.push(
-      s("invalid_view", "Dashboard view must be an object.", t)
+      r("invalid_view", "Dashboard view must be an object.", t)
     );
     return;
   }
   if (p(e.title) || n.push(
-    s("missing_view_title", "Dashboard view needs a title.", t)
+    r("missing_view_title", "Dashboard view needs a title.", t)
   ), !e.presentation || typeof e.presentation != "object") {
     n.push(
-      s(
+      r(
         "missing_presentation",
         "Dashboard view needs a presentation.",
         `${t}.presentation`
@@ -3475,7 +3531,7 @@ function Kn(e, t, n, o) {
   }
   if (e.presentation.kind === "text") {
     p(e.text) || o.push(
-      s(
+      r(
         "missing_text_content",
         "Text views should include text content.",
         `${t}.text`
@@ -3485,7 +3541,7 @@ function Kn(e, t, n, o) {
   }
   if (!e.analytics) {
     n.push(
-      s(
+      r(
         "missing_view_analytics",
         "Non-text dashboard views need analytics intent.",
         `${t}.analytics`
@@ -3494,37 +3550,37 @@ function Kn(e, t, n, o) {
     return;
   }
   e.presentation.kind === "matrixTable" && e.analytics.kind !== "matrix" && n.push(
-    s(
+    r(
       "invalid_matrix_view_analytics",
       "Matrix table views need matrix analytics intent.",
       `${t}.analytics.kind`
     )
   );
-  const a = Mt(e.analytics);
-  for (const r of a.errors)
+  const a = jt(e.analytics);
+  for (const s of a.errors)
     n.push(
-      s(
-        r.code,
-        r.message,
-        `${t}.analytics${r.path ? `.${r.path}` : ""}`
+      r(
+        s.code,
+        s.message,
+        `${t}.analytics${s.path ? `.${s.path}` : ""}`
       )
     );
-  for (const r of a.warnings)
+  for (const s of a.warnings)
     o.push(
-      s(
-        r.code,
-        r.message,
-        `${t}.analytics${r.path ? `.${r.path}` : ""}`
+      r(
+        s.code,
+        s.message,
+        `${t}.analytics${s.path ? `.${s.path}` : ""}`
       )
     );
 }
-function Va(e) {
+function Ka(e) {
   const t = [], n = [];
   if (!e || typeof e != "object")
     return {
       ok: !1,
       errors: [
-        s(
+        r(
           "invalid_dashboard_intent",
           "Dashboard intent must be a structured object."
         )
@@ -3532,17 +3588,17 @@ function Va(e) {
       warnings: n
     };
   e.version !== 1 && t.push(
-    s("invalid_version", "Dashboard intent version must be 1.")
+    r("invalid_version", "Dashboard intent version must be 1.")
   ), e.kind !== "dashboard" && t.push(
-    s("invalid_kind", "Experience intent kind must be dashboard.")
+    r("invalid_kind", "Experience intent kind must be dashboard.")
   ), p(e.title) || t.push(
-    s("missing_title", "Dashboard intent needs a title.", "title")
+    r("missing_title", "Dashboard intent needs a title.", "title")
   );
-  const o = Array.isArray(e.inputs) ? e.inputs : [], a = Le(
+  const o = Array.isArray(e.inputs) ? e.inputs : [], a = Ge(
     o.filter(f).map((c) => c.id).filter((c) => typeof c == "string")
   );
   a && t.push(
-    s(
+    r(
       "duplicate_input_id",
       `Duplicate input id: ${a}.`,
       "inputs"
@@ -3552,41 +3608,41 @@ function Va(e) {
     const m = `inputs.${c}`;
     if (!f(u)) {
       t.push(
-        s("invalid_input", "Dashboard input must be an object.", m)
+        r("invalid_input", "Dashboard input must be an object.", m)
       );
       continue;
     }
     p(u.id) || t.push(
-      s("missing_input_id", "Input needs an id.", `${m}.id`)
+      r("missing_input_id", "Input needs an id.", `${m}.id`)
     ), p(u.label) || t.push(
-      s("missing_input_label", "Input needs a label.", `${m}.label`)
+      r("missing_input_label", "Input needs a label.", `${m}.label`)
     ), !u.field || !p(u.field.name) ? t.push(
-      s("missing_input_field", "Input needs a field.", `${m}.field`)
+      r("missing_input_field", "Input needs a field.", `${m}.field`)
     ) : b(u.field, `${m}.field`, t);
   }
-  const r = Array.isArray(e.sections) ? e.sections : [];
-  r.length === 0 && t.push(
-    s(
+  const s = Array.isArray(e.sections) ? e.sections : [];
+  s.length === 0 && t.push(
+    r(
       "missing_sections",
       "Dashboard intent needs at least one section.",
       "sections"
     )
   );
-  const l = r.flatMap(
+  const l = s.flatMap(
     (c) => c && typeof c == "object" && Array.isArray(c.views) ? c.views.filter(f).map((u) => u.id).filter((u) => !!u) : []
-  ), d = Le(l);
+  ), d = Ge(l);
   d && t.push(
-    s(
+    r(
       "duplicate_view_id",
       `Duplicate dashboard view id: ${d}.`,
       "sections"
     )
   );
-  for (const [c, u] of r.entries()) {
+  for (const [c, u] of s.entries()) {
     const m = `sections.${c}`;
     if (!u || typeof u != "object") {
       t.push(
-        s(
+        r(
           "invalid_section",
           "Dashboard section must be an object.",
           m
@@ -3595,14 +3651,14 @@ function Va(e) {
       continue;
     }
     if (p(u.title) || t.push(
-      s(
+      r(
         "missing_section_title",
         "Dashboard section needs a title.",
         m
       )
     ), !Array.isArray(u.views) || u.views.length === 0) {
       t.push(
-        s(
+        r(
           "missing_section_views",
           "Dashboard section needs at least one view.",
           `${m}.views`
@@ -3610,10 +3666,10 @@ function Va(e) {
       );
       continue;
     }
-    for (const [h, v] of u.views.entries())
-      Kn(
-        v,
-        `${m}.views.${h}`,
+    for (const [_, y] of u.views.entries())
+      Zn(
+        y,
+        `${m}.views.${_}`,
         t,
         n
       );
@@ -3621,150 +3677,153 @@ function Va(e) {
   return { ok: t.length === 0, errors: t, warnings: n };
 }
 export {
-  Re as $,
-  en as A,
-  _t as B,
-  re as C,
-  Ni as D,
-  de as E,
-  bt as F,
-  Mi as G,
-  x as H,
-  fa as I,
-  on as J,
-  yt as K,
-  Di as L,
-  sn as M,
-  pt as N,
-  Y as O,
-  ji as P,
-  je as Q,
-  Zn as R,
-  ke as S,
-  Jn as T,
-  Oe as U,
-  Z as V,
-  _n as W,
-  ja as X,
-  be as Y,
-  jt as Z,
-  Wn as _,
-  _a as a,
-  q as a$,
-  G as a0,
-  Xn as a1,
-  $t as a2,
-  ea as a3,
-  Ot as a4,
+  Se as $,
+  qa as A,
+  Ni as B,
+  le as C,
+  Ci as D,
+  Ae as E,
+  on as F,
+  St as G,
+  ce as H,
+  It as I,
+  Ei as J,
+  F as K,
+  ji as L,
+  ba as M,
+  dn as N,
+  kt as O,
+  Yi as P,
+  un as Q,
+  ia as R,
+  gt as S,
+  na as T,
+  Y as U,
+  Ye as V,
+  xe as W,
+  qe as X,
+  J as Y,
+  Sn as Z,
+  Ya as _,
+  va as a,
+  Tt as a$,
+  Ot as a0,
+  ea as a1,
+  De as a2,
+  z as a3,
+  ta as a4,
   Yt as a5,
-  ce as a6,
-  Pn as a7,
-  La as a8,
-  Mt as a9,
-  Gt as aA,
-  Ge as aB,
-  ze as aC,
-  Ke as aD,
-  Qe as aE,
-  We as aF,
-  ta as aG,
-  ia as aH,
-  j as aI,
-  na as aJ,
-  aa as aK,
-  Te as aL,
-  oa as aM,
-  sa as aN,
-  ra as aO,
-  Jt as aP,
-  ei as aQ,
-  la as aR,
-  da as aS,
-  $a as aT,
-  Ca as aU,
-  T as aV,
-  wt as aW,
-  we as aX,
-  At as aY,
-  Pa as aZ,
-  ct as a_,
-  zn as aa,
-  Ua as ab,
-  Va as ac,
-  et as ad,
-  ve as ae,
-  bi as af,
-  yi as ag,
-  nt as ah,
-  ki as ai,
-  wi as aj,
+  aa as a6,
+  Bt as a7,
+  qt as a8,
+  me as a9,
+  he as aA,
+  _e as aB,
+  Qe as aC,
+  Qt as aD,
+  We as aE,
+  Xe as aF,
+  Ze as aG,
+  Je as aH,
+  et as aI,
+  oa as aJ,
+  sa as aK,
+  j as aL,
+  ra as aM,
+  la as aN,
+  Ne as aO,
+  da as aP,
+  ua as aQ,
+  ca as aR,
+  ii as aS,
+  ni as aT,
+  pa as aU,
+  ma as aV,
+  Pa as aW,
+  Ba as aX,
+  T as aY,
+  Rt as aZ,
+  Fe as a_,
+  Un as aa,
+  Ga as ab,
+  jt as ac,
+  Xn as ad,
+  za as ae,
+  Ka as af,
+  ve as ag,
+  ke as ah,
+  Si as ai,
+  Ii as aj,
   st as ak,
-  rt as al,
-  Ne as am,
+  xi as al,
+  Fi as am,
   dt as an,
-  ua as ao,
-  ca as ap,
-  Bt as aq,
-  O as ar,
-  F as as,
-  L as at,
-  ee as au,
-  W as av,
-  Vt as aw,
-  fe as ax,
-  ge as ay,
-  He as az,
-  ba as b,
-  Ri as b0,
-  V as b1,
-  ma as b2,
-  A as b3,
-  Ai as b4,
-  pa as b5,
-  ut as b6,
-  $ as b7,
-  Me as b8,
-  Ki as b9,
-  cn as ba,
-  wa as bb,
-  Ui as bc,
-  Da as bd,
-  Ma as be,
-  Aa as bf,
-  xa as bg,
-  zi as bh,
-  Qi as bi,
-  Ra as bj,
-  Fa as bk,
-  Ta as bl,
-  Ia as bm,
-  le as bn,
-  ka as bo,
-  pn as bp,
-  ye as bq,
-  ii as br,
-  ya as c,
-  Sa as d,
-  Ei as e,
-  Pt as f,
-  ga as g,
-  va as h,
-  ha as i,
-  xt as j,
-  St as k,
-  ue as l,
-  un as m,
-  Ea as n,
-  vn as o,
-  Ba as p,
-  Ya as q,
-  Ct as r,
-  wn as s,
-  se as t,
-  ln as u,
-  Na as v,
-  qa as w,
-  Oa as x,
-  Ti as y,
-  Ie as z
+  ut as ao,
+  $e as ap,
+  pt as aq,
+  fa as ar,
+  ga as as,
+  Ut as at,
+  O as au,
+  R as av,
+  U as aw,
+  te as ax,
+  X as ay,
+  zt as az,
+  Oi as b,
+  Ua as b0,
+  ft as b1,
+  L as b2,
+  Di as b3,
+  H as b4,
+  _a as b5,
+  x as b6,
+  Ri as b7,
+  ha as b8,
+  mt as b9,
+  $ as ba,
+  Ee as bb,
+  Zi as bc,
+  gn as bd,
+  Ra as be,
+  zi as bf,
+  $a as bg,
+  ja as bh,
+  Ta as bi,
+  Ma as bj,
+  Xi as bk,
+  Ji as bl,
+  Na as bm,
+  Da as bn,
+  Ea as bo,
+  xa as bp,
+  ue as bq,
+  Fa as br,
+  hn as bs,
+  Ie as bt,
+  oi as bu,
+  ht as c,
+  Ia as d,
+  Aa as e,
+  de as f,
+  $i as g,
+  wa as h,
+  ya as i,
+  Lt as j,
+  Rn as k,
+  Mt as l,
+  fn as m,
+  Sa as n,
+  At as o,
+  Va as p,
+  pe as q,
+  Oa as r,
+  ka as s,
+  wn as t,
+  La as u,
+  re as v,
+  Pt as w,
+  pn as x,
+  Ca as y,
+  Ha as z
 };