react-semaphor 0.1.449 → 0.1.454

package/dist/chunks/pivot-result-lifecycle-sjzIOpvp.js

@@ -0,0 +1,1641 @@
+var ee = Object.defineProperty;
+var te = (e, t, r) => t in e ? ee(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var g = (e, t, r) => te(e, typeof t != "symbol" ? t + "" : t, r);
+import { b as k, al as G, x as re } from "./validators-DEmd8Sin.js";
+import { p as ae } from "./raw-temporal-contract-CxncLze5.js";
+import { canonicalizeSupportedLocale as E, canonicalizeSupportedCurrencyCode as $ } from "../value-format-preferences/index.js";
+import { l as h, j as ne, a as ie } from "./temporal-bucket-5UYEotyQ.js";
+import { f as oe } from "./index-CACdoqu3.js";
+import { b as se } from "./report-runtime-context-SM6YO61_.js";
+import "./analyze-result-contract-BbRJ-C06.js";
+import { a as ce } from "./temporal-bucket-contract-D5d-xEl3.js";
+import { d as me, P as le } from "./pivot-result-identity-DU1v-5Xk.js";
+function N(e) {
+  if (!e) return !1;
+  const t = e.toLowerCase().replace("_", "-");
+  return t === "en-in" || t.startsWith("en-in-");
+}
+function z(e, t) {
+  const r = Math.abs(e);
+  return r >= 1e12 ? { divisor: 1e12, suffix: "T" } : r >= 1e9 ? { divisor: 1e9, suffix: "B" } : N(t) && r >= 1e7 ? { divisor: 1e7, suffix: "Cr" } : r >= 1e6 ? { divisor: 1e6, suffix: "M" } : N(t) && r >= 1e5 ? { divisor: 1e5, suffix: "L" } : r >= 1e3 ? { divisor: 1e3, suffix: "K" } : { divisor: 1, suffix: "" };
+}
+function D(e, t) {
+  try {
+    const r = x(t);
+    return z(e, r);
+  } catch {
+    return z(e, "en-US");
+  }
+}
+function ue(e) {
+  try {
+    return new Intl.NumberFormat(e), !0;
+  } catch {
+    return !1;
+  }
+}
+function x(e) {
+  return e && ue(e) ? e : "en-US";
+}
+function A(e, t) {
+  if (e == null || isNaN(e))
+    return "";
+  const r = x(t == null ? void 0 : t.locale);
+  let a = e;
+  if (t != null && t.multiplyBy && (a *= t.multiplyBy), t != null && t.useSuffix) {
+    const { divisor: i, suffix: o } = D(a, r);
+    a = a / i;
+    const s = new Intl.NumberFormat(r, {
+      minimumFractionDigits: (t == null ? void 0 : t.minimumFractionDigits) ?? 0,
+      maximumFractionDigits: (t == null ? void 0 : t.maximumFractionDigits) ?? 2,
+      useGrouping: (t == null ? void 0 : t.useGrouping) ?? !0
+    }).format(a);
+    return `${(t == null ? void 0 : t.prefix) ?? ""}${s}${o}${(t == null ? void 0 : t.suffix) ?? ""}`;
+  }
+  const n = new Intl.NumberFormat(r, {
+    minimumFractionDigits: (t == null ? void 0 : t.minimumFractionDigits) ?? 0,
+    maximumFractionDigits: (t == null ? void 0 : t.maximumFractionDigits) ?? 2,
+    useGrouping: (t == null ? void 0 : t.useGrouping) ?? !0
+  }).format(a);
+  if (t != null && t.negativeInParentheses && a < 0) {
+    const i = n.replace("-", "");
+    return `(${(t == null ? void 0 : t.prefix) ?? ""}${i}${(t == null ? void 0 : t.suffix) ?? ""})`;
+  }
+  return `${(t == null ? void 0 : t.prefix) ?? ""}${n}${(t == null ? void 0 : t.suffix) ?? ""}`;
+}
+function B(e, t) {
+  if (e == null || isNaN(e))
+    return "";
+  const r = x(t == null ? void 0 : t.locale), a = (t == null ? void 0 : t.currency) || "USD", n = e < 0, i = !!(t != null && t.negativeInParentheses && n), o = i ? Math.abs(e) : e;
+  try {
+    if (t != null && t.useSuffix) {
+      const { divisor: m, suffix: l } = D(o, r), c = o / m, f = `${new Intl.NumberFormat(r, {
+        style: "currency",
+        currency: a,
+        minimumFractionDigits: (t == null ? void 0 : t.minimumFractionDigits) ?? 0,
+        maximumFractionDigits: (t == null ? void 0 : t.maximumFractionDigits) ?? 2,
+        useGrouping: (t == null ? void 0 : t.useGrouping) ?? !0
+      }).format(c)}${l}`;
+      return i ? `(${f})` : f;
+    }
+    const s = new Intl.NumberFormat(r, {
+      style: "currency",
+      currency: a,
+      minimumFractionDigits: (t == null ? void 0 : t.minimumFractionDigits) ?? 0,
+      maximumFractionDigits: (t == null ? void 0 : t.maximumFractionDigits) ?? 2,
+      useGrouping: (t == null ? void 0 : t.useGrouping) ?? !0
+    }).format(o);
+    return i ? `(${s})` : s;
+  } catch {
+    const s = Math.abs(e), m = t != null && t.useSuffix ? D(s, r) : { divisor: 1, suffix: "" }, l = A(
+      s / m.divisor,
+      {
+        locale: r,
+        minimumFractionDigits: (t == null ? void 0 : t.minimumFractionDigits) ?? 0,
+        maximumFractionDigits: (t == null ? void 0 : t.maximumFractionDigits) ?? 2,
+        useGrouping: (t == null ? void 0 : t.useGrouping) ?? !0
+      }
+    ), c = `${a} ${l}${m.suffix}`;
+    return n ? t != null && t.negativeInParentheses ? `(${c})` : `-${c}` : c;
+  }
+}
+function U(e, t) {
+  if (e == null || isNaN(e))
+    return "";
+  const r = x(t == null ? void 0 : t.locale), n = (t == null ? void 0 : t.alreadyPercent) ?? (t == null ? void 0 : t.percentValueMode) === "whole" ? e / 100 : e;
+  return new Intl.NumberFormat(r, {
+    style: "percent",
+    minimumFractionDigits: (t == null ? void 0 : t.minimumFractionDigits) ?? 0,
+    maximumFractionDigits: (t == null ? void 0 : t.maximumFractionDigits) ?? 2,
+    useGrouping: (t == null ? void 0 : t.useGrouping) ?? !0
+  }).format(n);
+}
+function Z(e, t) {
+  if (e == null || isNaN(e))
+    return "";
+  const r = x(t == null ? void 0 : t.locale);
+  return new Intl.NumberFormat(r, {
+    notation: "scientific",
+    minimumFractionDigits: (t == null ? void 0 : t.minimumFractionDigits) ?? 0,
+    maximumFractionDigits: (t == null ? void 0 : t.maximumFractionDigits) ?? 2
+  }).format(e);
+}
+function de(e, t) {
+  if (e == null || Number.isNaN(e))
+    return "";
+  const r = t.scale === void 0 ? e : e * t.scale, a = t.negativeStyle === "parentheses" && r < 0, n = a ? Math.abs(r) : r, i = {
+    style: t.type === "number" ? "decimal" : t.type,
+    locale: t.locale,
+    currency: t.currency,
+    minimumFractionDigits: t.minimumFractionDigits,
+    maximumFractionDigits: t.maximumFractionDigits,
+    useGrouping: t.useGrouping,
+    percentValueMode: t.percentValueMode,
+    useSuffix: t.compact
+  };
+  let o;
+  switch (t.type) {
+    case "currency":
+      o = B(n, i);
+      break;
+    case "percent":
+      o = U(n, i);
+      break;
+    case "scientific":
+      o = Z(n, i);
+      break;
+    default:
+      o = A(n, i);
+      break;
+  }
+  const s = `${t.prefix ?? ""}${o}${t.suffix ?? ""}`;
+  return a ? `(${s})` : s;
+}
+function ot(e, t, r = "en-US") {
+  if (e == null || isNaN(e))
+    return "";
+  const a = x((t == null ? void 0 : t.locale) || r), n = (t == null ? void 0 : t.style) || "decimal", i = n === "decimal" ? "number" : n;
+  return i === "currency" && new Intl.NumberFormat(a, {
+    style: "currency",
+    currency: (t == null ? void 0 : t.currency) || "USD"
+  }), de(e, {
+    type: i,
+    locale: a,
+    currency: i === "currency" ? (t == null ? void 0 : t.currency) || "USD" : void 0,
+    minimumFractionDigits: (t == null ? void 0 : t.minimumFractionDigits) ?? 0,
+    maximumFractionDigits: (t == null ? void 0 : t.maximumFractionDigits) ?? 2,
+    useGrouping: (t == null ? void 0 : t.useGrouping) ?? !0,
+    percentValueMode: i === "percent" ? (t == null ? void 0 : t.percentValueMode) ?? "whole" : void 0,
+    scale: t == null ? void 0 : t.scale,
+    compact: t == null ? void 0 : t.compact,
+    negativeStyle: t == null ? void 0 : t.negativeStyle,
+    prefix: t == null ? void 0 : t.prefix,
+    suffix: t == null ? void 0 : t.suffix
+  });
+}
+function st(e, t, r) {
+  const a = {
+    style: t === "currency" ? "currency" : t === "percent" ? "percent" : "decimal",
+    locale: r == null ? void 0 : r.locale,
+    currency: r == null ? void 0 : r.currency,
+    minimumFractionDigits: r == null ? void 0 : r.decimalPlaces,
+    maximumFractionDigits: r == null ? void 0 : r.decimalPlaces,
+    useSuffix: r == null ? void 0 : r.useSuffix,
+    prefix: r == null ? void 0 : r.prefix,
+    suffix: r == null ? void 0 : r.suffix,
+    negativeInParentheses: r == null ? void 0 : r.negativeInParentheses,
+    multiplyBy: r == null ? void 0 : r.multiplyBy
+  };
+  switch (t) {
+    case "currency":
+      return B(e, a);
+    case "percent":
+      return U(e, a);
+    case "scientific":
+      return Z(e, a);
+    default:
+      return A(e, a);
+  }
+}
+const fe = [
+  "type",
+  "locale",
+  "minimumFractionDigits",
+  "maximumFractionDigits",
+  "useGrouping",
+  "prefix",
+  "suffix",
+  "negativeStyle",
+  "compact",
+  "scale",
+  "currency",
+  "percentValueMode"
+];
+function ye(e) {
+  if (!h(e))
+    return {
+      ok: !1,
+      issues: [{ path: "$", message: "Numeric format must be an object." }]
+    };
+  const t = [], r = new Set(fe);
+  Object.keys(e).filter((i) => !r.has(i)).forEach(
+    (i) => t.push({ path: i, message: `Unknown property "${i}".` })
+  ), e.type !== "number" && e.type !== "currency" && e.type !== "percent" && e.type !== "scientific" && t.push({
+    path: "type",
+    message: "Expected number, currency, percent, or scientific."
+  });
+  const a = e.locale === void 0 ? void 0 : E(e.locale);
+  e.locale !== void 0 && !a && t.push({ path: "locale", message: "Expected a supported BCP 47 locale." });
+  const n = e.currency === void 0 ? void 0 : $(e.currency);
+  e.currency !== void 0 && !n && t.push({
+    path: "currency",
+    message: "Expected a supported ISO 4217 currency code."
+  });
+  for (const i of ["minimumFractionDigits", "maximumFractionDigits"]) {
+    const o = e[i];
+    o !== void 0 && (!Number.isInteger(o) || typeof o != "number" || o < 0 || o > 20) && t.push({
+      path: i,
+      message: "Expected an integer from 0 to 20."
+    });
+  }
+  typeof e.minimumFractionDigits == "number" && typeof e.maximumFractionDigits == "number" && e.minimumFractionDigits > e.maximumFractionDigits && t.push({
+    path: "maximumFractionDigits",
+    message: "Must be greater than or equal to minimumFractionDigits."
+  });
+  for (const i of ["useGrouping", "compact"])
+    e[i] !== void 0 && typeof e[i] != "boolean" && t.push({ path: i, message: "Expected a boolean." });
+  for (const i of ["prefix", "suffix"])
+    e[i] !== void 0 && typeof e[i] != "string" && t.push({ path: i, message: "Expected a string." });
+  return e.negativeStyle !== void 0 && e.negativeStyle !== "minus" && e.negativeStyle !== "parentheses" && t.push({
+    path: "negativeStyle",
+    message: "Expected minus or parentheses."
+  }), e.percentValueMode !== void 0 && e.percentValueMode !== "fraction" && e.percentValueMode !== "whole" && t.push({
+    path: "percentValueMode",
+    message: "Expected fraction or whole."
+  }), e.scale !== void 0 && (typeof e.scale != "number" || !Number.isFinite(e.scale)) && t.push({ path: "scale", message: "Expected a finite number." }), t.length > 0 ? { ok: !1, issues: t } : {
+    ok: !0,
+    value: {
+      type: e.type,
+      ...a ? { locale: a } : {},
+      ...e.minimumFractionDigits !== void 0 ? { minimumFractionDigits: e.minimumFractionDigits } : {},
+      ...e.maximumFractionDigits !== void 0 ? { maximumFractionDigits: e.maximumFractionDigits } : {},
+      ...e.useGrouping !== void 0 ? { useGrouping: e.useGrouping } : {},
+      ...e.prefix !== void 0 ? { prefix: e.prefix } : {},
+      ...e.suffix !== void 0 ? { suffix: e.suffix } : {},
+      ...e.negativeStyle !== void 0 ? {
+        negativeStyle: e.negativeStyle
+      } : {},
+      ...e.compact !== void 0 ? { compact: e.compact } : {},
+      ...e.scale !== void 0 ? { scale: e.scale } : {},
+      ...n ? { currency: n } : {},
+      ...e.percentValueMode !== void 0 ? {
+        percentValueMode: e.percentValueMode
+      } : {}
+    }
+  };
+}
+function he(e) {
+  const t = ye(e);
+  if (!t.ok)
+    return t;
+  const r = [];
+  return t.value.locale || r.push({
+    path: "locale",
+    message: "Resolved numeric formats require an explicit locale."
+  }), t.value.minimumFractionDigits === void 0 && r.push({
+    path: "minimumFractionDigits",
+    message: "Resolved numeric formats require minimumFractionDigits."
+  }), t.value.maximumFractionDigits === void 0 && r.push({
+    path: "maximumFractionDigits",
+    message: "Resolved numeric formats require maximumFractionDigits."
+  }), t.value.type === "currency" && !t.value.currency && r.push({
+    path: "currency",
+    message: "Resolved currency formats require an explicit currency."
+  }), r.length > 0 ? { ok: !1, issues: r } : t;
+}
+function ct(e) {
+  var a;
+  const t = /* @__PURE__ */ new Set();
+  if (e.snapshot.resolvedFormats.forEach((n, i) => {
+    if (n.format.type !== "temporal_bucket") {
+      if (n.scope.attachmentIndex !== void 0)
+        throw new Error(
+          `resolvedFormats.${i}.scope.attachmentIndex is not valid for a card export`
+        );
+      if (n.scope.dashboardId !== e.expectedScope.dashboardId || n.scope.cardId !== e.expectedScope.cardId)
+        throw new Error(
+          `resolvedFormats.${i}.scope must match the executing dashboard/card`
+        );
+      if (n.target.kind !== "column")
+        throw new Error(
+          `resolvedFormats.${i}.target must identify an export column`
+        );
+      if (t.has(n.target.columnKey))
+        throw new Error(
+          `resolvedFormats.${i} duplicates export column "${n.target.columnKey}"`
+        );
+      t.add(n.target.columnKey);
+    }
+  }), !e.useFormattedValues)
+    return;
+  if (!((a = e.visibleColumns) != null && a.length))
+    throw new Error(
+      "visibleColumns must identify every formatted export column"
+    );
+  const r = e.visibleColumns.find(
+    (n) => !t.has(n)
+  );
+  if (r)
+    throw new Error(
+      `resolvedFormats is missing visible export column "${r}"`
+    );
+}
+function ge(e, t) {
+  const r = new Intl.NumberFormat(e, {
+    style: "currency",
+    currency: t
+  }).resolvedOptions();
+  return {
+    minimumFractionDigits: r.minimumFractionDigits,
+    maximumFractionDigits: r.maximumFractionDigits
+  };
+}
+function ve(e) {
+  if (e.minimumFractionDigits !== void 0 || e.maximumFractionDigits !== void 0) {
+    const r = e.minimumFractionDigits ?? 0;
+    return {
+      minimumFractionDigits: r,
+      maximumFractionDigits: e.maximumFractionDigits ?? Math.max(r, 2)
+    };
+  }
+  const t = e.type === "percent" ? 1 : e.type === "scientific" ? 2 : 0;
+  return {
+    minimumFractionDigits: t,
+    maximumFractionDigits: t
+  };
+}
+function mt(e, t, r) {
+  const a = E(e.locale) ?? t.locale, n = e.type === "number" || e.type === "currency" ? $(r) : void 0;
+  if (!(e.type === "currency" || n !== void 0))
+    return {
+      ...e,
+      locale: a,
+      ...ve(e)
+    };
+  const o = n ?? $(e.currency) ?? t.defaultCurrency, s = ge(
+    a,
+    o
+  ), m = s.minimumFractionDigits ?? 0, l = s.maximumFractionDigits ?? m, c = e.minimumFractionDigits ?? Math.min(
+    m,
+    e.maximumFractionDigits ?? m
+  ), y = e.maximumFractionDigits ?? Math.max(
+    c,
+    l
+  );
+  return {
+    ...e,
+    type: "currency",
+    locale: a,
+    currency: o,
+    minimumFractionDigits: c,
+    maximumFractionDigits: y
+  };
+}
+class p extends Error {
+  constructor(r, a) {
+    super(a);
+    g(this, "code");
+    this.name = "RawTemporalFormatContractError", this.code = r;
+  }
+}
+const we = [
+  "SSSSSSSSS",
+  "SSSSSSSS",
+  "SSSSSSS",
+  "SSSSSS",
+  "SSSSS",
+  "SSSS",
+  "SSS",
+  "SS",
+  "S"
+], H = /^(\d{4})-(\d{2})-(\d{2})$/, Y = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?$/, X = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(Z|[+-]\d{2}:\d{2})$/, pe = [
+  "yyyy",
+  "MMMM",
+  "LLLL",
+  "zzz",
+  "XXX",
+  "MMM",
+  "LLL",
+  "yy",
+  "MM",
+  "dd",
+  "HH",
+  "hh",
+  "mm",
+  "ss",
+  "M",
+  "d",
+  "H",
+  "h",
+  "m",
+  "s",
+  "a"
+], xe = /* @__PURE__ */ new Set([
+  "HH",
+  "H",
+  "hh",
+  "h",
+  "mm",
+  "m",
+  "ss",
+  "s",
+  "a",
+  ...we
+]), Se = /* @__PURE__ */ new Set(["zzz", "XXX"]), F = /* @__PURE__ */ new Set(["short", "medium", "long"]);
+function v(e, t) {
+  return Object.keys(e).length === t.length && t.every((a) => a in e);
+}
+function d(e) {
+  throw new p(
+    "invalid_raw_temporal_format",
+    e
+  );
+}
+function W(e) {
+  if (!e || e.trim() !== e || e.length > 256)
+    return d(
+      "date_fns patterns must be non-empty, trimmed, and at most 256 characters."
+    );
+  const t = [], r = (n) => {
+    const i = t[t.length - 1];
+    (i == null ? void 0 : i.kind) === "literal" ? i.value += n : t.push({ kind: "literal", value: n });
+  };
+  let a = 0;
+  for (; a < e.length; ) {
+    if (e[a] === "'") {
+      if (e[a + 1] === "'") {
+        r("'"), a += 2;
+        continue;
+      }
+      let o = "", s = !1;
+      for (a += 1; a < e.length; ) {
+        if (e[a] === "'") {
+          if (e[a + 1] === "'") {
+            o += "'", a += 2;
+            continue;
+          }
+          s = !0, a += 1;
+          break;
+        }
+        o += e[a], a += 1;
+      }
+      if (!s)
+        return d("date_fns pattern has an unclosed quote.");
+      r(o);
+      continue;
+    }
+    if (e[a] === "S") {
+      let o = a + 1;
+      for (; e[o] === "S"; ) o += 1;
+      const s = e.slice(a, o);
+      if (s.length > 9)
+        return d(
+          "date_fns fractional-second tokens support at most nine digits."
+        );
+      t.push({
+        kind: "token",
+        value: s
+      }), a = o;
+      continue;
+    }
+    const n = pe.find(
+      (o) => e.startsWith(o, a)
+    );
+    if (n) {
+      t.push({ kind: "token", value: n }), a += n.length;
+      continue;
+    }
+    const i = e[a];
+    if (/[A-Za-z]/.test(i))
+      return d(
+        `Unsupported date_fns pattern token beginning at "${e.slice(a)}".`
+      );
+    r(i), a += 1;
+  }
+  return t.some((n) => n.kind === "token") ? t : d("date_fns patterns must contain at least one token.");
+}
+function J(e, t) {
+  if (e === "semaphor_tokens") {
+    const r = G(t);
+    r.ok || d(r.message);
+    return;
+  }
+  W(t);
+}
+function be(e) {
+  return !h(e) || !v(e, ["dateStyle", "dateTime"]) ? d("Automatic raw temporal styles are incomplete.") : F.has(e.dateStyle) ? !h(e.dateTime) || !v(e.dateTime, ["dateStyle", "timeStyle"]) || !F.has(e.dateTime.dateStyle) || !F.has(e.dateTime.timeStyle) ? d(
+    "Automatic dateTime styles are incomplete or invalid."
+  ) : {
+    dateStyle: e.dateStyle,
+    dateTime: {
+      dateStyle: e.dateTime.dateStyle,
+      timeStyle: e.dateTime.timeStyle
+    }
+  } : d("Automatic dateStyle is invalid.");
+}
+function R(e) {
+  const t = ["type", "locale", "calendarTimezone", "presentation"], r = [...t, "sourceTimezone"];
+  if (!h(e) || !v(e, t) && !v(e, r) || e.type !== "raw_temporal")
+    return d("Resolved raw temporal format has an invalid shape.");
+  const a = E(e.locale);
+  return a ? typeof e.calendarTimezone != "string" || !k(e.calendarTimezone) ? d(
+    "Raw temporal calendarTimezone must be a valid IANA timezone."
+  ) : e.sourceTimezone !== void 0 && (typeof e.sourceTimezone != "string" || !k(e.sourceTimezone)) ? d(
+    "Raw temporal sourceTimezone must be a valid IANA timezone."
+  ) : h(e.presentation) ? e.presentation.mode === "auto" ? v(e.presentation, ["mode", "styles"]) ? {
+    type: "raw_temporal",
+    locale: a,
+    calendarTimezone: e.calendarTimezone,
+    ...e.sourceTimezone ? { sourceTimezone: e.sourceTimezone } : {},
+    presentation: {
+      mode: "auto",
+      styles: be(e.presentation.styles)
+    }
+  } : d(
+    "Automatic raw temporal presentation has unknown fields."
+  ) : e.presentation.mode !== "pattern" || !v(e.presentation, ["mode", "dialect", "pattern"]) || e.presentation.dialect !== "semaphor_tokens" && e.presentation.dialect !== "date_fns" || typeof e.presentation.pattern != "string" ? d(
+    "Pattern raw temporal presentation has an invalid shape."
+  ) : (J(e.presentation.dialect, e.presentation.pattern), {
+    type: "raw_temporal",
+    locale: a,
+    calendarTimezone: e.calendarTimezone,
+    ...e.sourceTimezone ? { sourceTimezone: e.sourceTimezone } : {},
+    presentation: {
+      mode: "pattern",
+      dialect: e.presentation.dialect,
+      pattern: e.presentation.pattern
+    }
+  }) : d("Raw temporal presentation must be an object.") : d("Raw temporal locale is invalid or unsupported.");
+}
+function lt(e) {
+  var s, m, l;
+  if (e.format) {
+    if (!h(e.format))
+      return d(
+        "Authored raw temporal format has an invalid shape."
+      );
+    const c = Object.keys(e.format);
+    if (!c.includes("type") || !c.includes("presentation") || c.some(
+      (f) => f !== "type" && f !== "presentation" && f !== "timezone" && f !== "sourceTimezone"
+    ) || e.format.type !== "raw_temporal" || !h(e.format.presentation))
+      return d(
+        "Authored raw temporal format has an invalid shape."
+      );
+    const y = e.format.presentation;
+    if (y.mode === "auto") {
+      if (!v(y, ["mode"]))
+        return d(
+          "Automatic authored raw temporal format has unknown fields."
+        );
+    } else {
+      if (y.mode !== "pattern" || !v(y, ["mode", "dialect", "pattern"]) || y.dialect !== "semaphor_tokens" && y.dialect !== "date_fns" || typeof y.pattern != "string")
+        return d(
+          "Authored raw temporal pattern has an invalid shape."
+        );
+      J(y.dialect, y.pattern);
+    }
+  }
+  const t = (s = e.format) == null ? void 0 : s.timezone, r = (m = e.format) == null ? void 0 : m.sourceTimezone, a = t && t !== "auto" ? t : e.calendar.tz, n = r && r !== "auto" ? r === "local" ? Intl.DateTimeFormat().resolvedOptions().timeZone : r : void 0;
+  if (t !== void 0 && t !== "auto" && !k(a) || n !== void 0 && !k(n))
+    return d("Authored raw temporal timezone is invalid.");
+  const i = ((l = e.format) == null ? void 0 : l.presentation) ?? { mode: "auto" }, o = {
+    type: "raw_temporal",
+    locale: e.preferences.locale,
+    calendarTimezone: a,
+    ...n ? { sourceTimezone: n } : {},
+    presentation: i.mode === "pattern" ? { ...i } : {
+      mode: "auto",
+      styles: {
+        dateStyle: e.preferences.dateStyle,
+        dateTime: { ...e.preferences.dateTime }
+      }
+    }
+  };
+  return R(o);
+}
+function _e(e) {
+  if (H.test(e)) return "date";
+  if (X.test(e)) return "instant";
+  if (Y.test(e)) return "wall_datetime";
+}
+function ut(e) {
+  const t = /* @__PURE__ */ new Set();
+  let r = !1;
+  for (const a of e.values) {
+    if (a === null) continue;
+    r = !0;
+    const n = _e(a);
+    n && t.add(n);
+  }
+  if (!r) return { status: "empty" };
+  if (t.size === 0) return { status: "invalid_only" };
+  if (t.size > 1)
+    throw new p(
+      "mixed_sql_temporal_semantics",
+      `Declared SQL temporal column "${e.columnKey}" mixes date, wall-datetime, or instant semantics. Normalize it to one kind.`
+    );
+  return {
+    status: "classified",
+    metadata: {
+      kind: "raw_temporal",
+      valueKind: [...t][0]
+    }
+  };
+}
+function dt(e) {
+  return {
+    version: 1,
+    columns: Object.fromEntries(
+      [...e].map(([t, r]) => [
+        t,
+        r.status === "classified" ? r.metadata.valueKind : r.status
+      ])
+    )
+  };
+}
+function Te(e) {
+  if (!h(e) || e.version !== 1 || !h(e.columns) || Object.keys(e).some((a) => a !== "version" && a !== "columns"))
+    throw new p(
+      "invalid_raw_temporal_format",
+      "Raw temporal chunk classification evidence is malformed."
+    );
+  const t = {}, r = /* @__PURE__ */ new Set([
+    "empty",
+    "invalid_only",
+    "date",
+    "wall_datetime",
+    "instant"
+  ]);
+  for (const [a, n] of Object.entries(e.columns)) {
+    if (!a.trim() || !r.has(n))
+      throw new p(
+        "invalid_raw_temporal_format",
+        "Raw temporal chunk classification evidence contains an invalid column or status."
+      );
+    t[a] = n;
+  }
+  return { version: 1, columns: t };
+}
+function ft(e) {
+  if (e.length === 0) return;
+  const t = e.map(Te), r = Object.keys(t[0].columns).sort();
+  for (let a = 1; a < t.length; a += 1) {
+    const n = Object.keys(t[a].columns).sort();
+    if (n.length !== r.length || n.some((i, o) => i !== r[o]))
+      throw new p(
+        "invalid_raw_temporal_format",
+        "Raw temporal chunk classification evidence has inconsistent columns."
+      );
+  }
+  for (const a of r)
+    if (new Set(
+      t.map((i) => i.columns[a]).filter(
+        (i) => i !== "empty" && i !== "invalid_only"
+      )
+    ).size > 1)
+      throw new p(
+        "mixed_sql_temporal_semantics",
+        `Declared SQL temporal column "${a}" has inconsistent semantics across export chunks. Normalize it to one kind.`
+      );
+}
+function ke(e) {
+  return e % 4 === 0 && (e % 100 !== 0 || e % 400 === 0);
+}
+function Ie(e, t) {
+  return t === 2 ? ke(e) ? 29 : 28 : [4, 6, 9, 11].includes(t) ? 30 : 31;
+}
+function Fe(e) {
+  return e.year >= 1 && e.year <= 9999 && e.month >= 1 && e.month <= 12 && e.day >= 1 && e.day <= Ie(e.year, e.month) && e.hour >= 0 && e.hour <= 23 && e.minute >= 0 && e.minute <= 59 && e.second >= 0 && e.second <= 59;
+}
+function $e(e) {
+  return {
+    year: Number(e[1]),
+    month: Number(e[2]),
+    day: Number(e[3]),
+    hour: Number(e[4] ?? 0),
+    minute: Number(e[5] ?? 0),
+    second: Number(e[6] ?? 0),
+    fraction: e[7] ?? ""
+  };
+}
+function De(e, t) {
+  const r = t === "date" ? e.match(H) : t === "wall_datetime" ? e.match(Y) : e.match(X);
+  if (!r) return { status: "invalid_shape" };
+  const a = $e(r);
+  if (!Fe(a)) return { status: "out_of_range" };
+  if (t === "instant") {
+    const n = r[8];
+    if (n && n !== "Z") {
+      const [o, s] = n.slice(1).split(":").map(Number);
+      if (o > 23 || s > 59) return { status: "out_of_range" };
+    }
+    const i = new Date(e.replace(" ", "T"));
+    return Number.isNaN(i.getTime()) ? { status: "out_of_range" } : { status: "valid", fields: a, instant: i };
+  }
+  return { status: "valid", fields: a };
+}
+function C(e) {
+  const t = /* @__PURE__ */ new Date(0);
+  return t.setUTCFullYear(e.year, e.month - 1, e.day), t.setUTCHours(e.hour, e.minute, e.second, 0), t;
+}
+function Q(e, t) {
+  const r = e.fraction ? `.${e.fraction.padEnd(3, "0").slice(0, 3)}` : "";
+  return oe(
+    `${String(e.year).padStart(4, "0")}-${String(e.month).padStart(2, "0")}-${String(e.day).padStart(2, "0")}T${String(e.hour).padStart(2, "0")}:${String(e.minute).padStart(2, "0")}:${String(e.second).padStart(2, "0")}${r}`,
+    t
+  );
+}
+function Ce(e, t) {
+  const r = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map();
+  let n, i, o, s;
+  return {
+    number(m, l = 1) {
+      let c = r.get(l);
+      return c || (c = new Intl.NumberFormat(e, {
+        useGrouping: !1,
+        minimumIntegerDigits: l,
+        maximumFractionDigits: 0
+      }), r.set(l, c)), c.format(m);
+    },
+    month(m, l, c) {
+      var b;
+      const y = `${l}:${c ? "standalone" : "contextual"}`;
+      let f = a.get(y);
+      if (!f) {
+        const _ = {
+          calendar: "gregory",
+          timeZone: "UTC",
+          month: l
+        };
+        c || (_.day = "numeric"), f = new Intl.DateTimeFormat(e, _), a.set(y, f);
+      }
+      return ((b = f.formatToParts(m).find((_) => _.type === "month")) == null ? void 0 : b.value) ?? "";
+    },
+    dayPeriod(m) {
+      var l;
+      return n ?? (n = new Intl.DateTimeFormat(e, {
+        calendar: "gregory",
+        timeZone: "UTC",
+        hour: "numeric",
+        hour12: !0
+      })), ((l = n.formatToParts(m).find((c) => c.type === "dayPeriod")) == null ? void 0 : l.value) ?? "";
+    },
+    instantFields(m) {
+      i ?? (i = new Intl.DateTimeFormat("en-CA", {
+        calendar: "gregory",
+        numberingSystem: "latn",
+        timeZone: t,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hourCycle: "h23"
+      }));
+      const l = i.formatToParts(m), c = (y) => {
+        var f;
+        return Number((f = l.find((b) => b.type === y)) == null ? void 0 : f.value);
+      };
+      return {
+        year: c("year"),
+        month: c("month"),
+        day: c("day"),
+        hour: c("hour"),
+        minute: c("minute"),
+        second: c("second"),
+        fraction: ""
+      };
+    },
+    timezoneName(m) {
+      var l;
+      return o ?? (o = new Intl.DateTimeFormat(e, {
+        calendar: "gregory",
+        timeZone: t,
+        timeZoneName: "short"
+      })), ((l = o.formatToParts(m).find((c) => c.type === "timeZoneName")) == null ? void 0 : l.value) ?? "";
+    },
+    timezoneOffset(m) {
+      var y;
+      s ?? (s = new Intl.DateTimeFormat("en-US", {
+        calendar: "gregory",
+        timeZone: t,
+        timeZoneName: "longOffset"
+      }));
+      const l = (y = s.formatToParts(m).find((f) => f.type === "timeZoneName")) == null ? void 0 : y.value;
+      if (!l)
+        return d("Unable to resolve the instant timezone offset.");
+      const c = l.replace(/^GMT/, "");
+      return c === "" || /^[+-]00:00$/.test(c) ? "Z" : c;
+    }
+  };
+}
+function Ee(e, t, r, a, n) {
+  if (/^S{1,9}$/.test(e)) {
+    const i = t.fraction.padEnd(e.length, "0").slice(0, e.length);
+    return a.number(Number(i), e.length);
+  }
+  switch (e) {
+    case "YYYY":
+    case "yyyy":
+      return a.number(t.year, 4);
+    case "YY":
+    case "yy":
+      return a.number(t.year % 100, 2);
+    case "MMMM":
+      return a.month(r, "long", !1);
+    case "LLLL":
+      return a.month(r, "long", !0);
+    case "MMM":
+      return a.month(r, "short", !1);
+    case "LLL":
+      return a.month(r, "short", !0);
+    case "MM":
+      return a.number(t.month, 2);
+    case "M":
+      return a.number(t.month);
+    case "DD":
+    case "dd":
+      return a.number(t.day, 2);
+    case "d":
+      return a.number(t.day);
+    case "HH":
+      return a.number(t.hour, 2);
+    case "H":
+      return a.number(t.hour);
+    case "hh":
+      return a.number(t.hour % 12 || 12, 2);
+    case "h":
+      return a.number(t.hour % 12 || 12);
+    case "mm":
+      return a.number(t.minute, 2);
+    case "m":
+      return a.number(t.minute);
+    case "ss":
+      return a.number(t.second, 2);
+    case "s":
+      return a.number(t.second);
+    case "a":
+      return a.dayPeriod(r);
+    case "zzz":
+      return n ? a.timezoneName(n) : d(
+        "Timezone pattern tokens require an instant value."
+      );
+    case "XXX":
+      return n ? a.timezoneOffset(n) : d(
+        "Timezone pattern tokens require an instant value."
+      );
+    default:
+      return d(
+        `Unsupported raw temporal pattern token "${e}".`
+      );
+  }
+}
+function Ae(e, t, r, a) {
+  const n = C(t);
+  return e.map(
+    (i) => i.kind === "literal" ? i.value : Ee(i.value, t, n, r, a)
+  ).join("");
+}
+function Re(e, t, r, a) {
+  const n = r === "date_fns" ? W(a) : (() => {
+    const s = G(a);
+    return s.ok ? s.segments : d(s.message);
+  })(), i = n.filter((s) => s.kind === "token").map((s) => s.value);
+  if (e.valueKind === "date" && i.some((s) => xe.has(s)))
+    return d("Date patterns cannot contain time tokens.");
+  if (e.valueKind !== "instant" && i.some((s) => Se.has(s)))
+    return d("Timezone pattern tokens require an instant value.");
+  const o = Ce(t.locale, t.calendarTimezone);
+  return (s) => {
+    const m = e.valueKind === "wall_datetime" && t.sourceTimezone ? Q(s.fields, t.sourceTimezone) : void 0, l = e.valueKind === "instant" ? {
+      ...o.instantFields(s.instant),
+      fraction: s.fields.fraction
+    } : m ? {
+      ...o.instantFields(m),
+      fraction: s.fields.fraction
+    } : s.fields;
+    return Ae(n, l, o, s.instant ?? m);
+  };
+}
+function Me(e, t) {
+  const r = t.presentation.mode === "auto" ? t.presentation.styles : d("Automatic raw temporal formatting requires styles.");
+  if (e.valueKind === "date") {
+    const o = new Intl.DateTimeFormat(t.locale, {
+      calendar: "gregory",
+      timeZone: "UTC",
+      dateStyle: r.dateStyle
+    });
+    return (s) => o.format(C(s.fields));
+  }
+  const a = e.valueKind === "instant", n = !a && r.dateTime.timeStyle === "long" ? "medium" : r.dateTime.timeStyle, i = new Intl.DateTimeFormat(t.locale, {
+    calendar: "gregory",
+    timeZone: a || e.valueKind === "wall_datetime" && t.sourceTimezone ? t.calendarTimezone : "UTC",
+    dateStyle: r.dateTime.dateStyle,
+    timeStyle: n
+  });
+  return (o) => a ? i.format(o.instant) : e.valueKind === "wall_datetime" && t.sourceTimezone ? i.format(Q(o.fields, t.sourceTimezone)) : i.format(C(o.fields));
+}
+function P(e, t, r) {
+  return {
+    ok: !1,
+    text: e,
+    diagnostic: {
+      code: r,
+      message: `Raw temporal ${t.valueKind} value is ${r === "invalid_raw_temporal_value" ? "malformed" : "out of range"}.`
+    }
+  };
+}
+function Ke(e) {
+  const t = ae(e.metadata), r = R(e.format), a = r.presentation.mode === "auto" ? Me(t, r) : Re(
+    t,
+    r,
+    r.presentation.dialect,
+    r.presentation.pattern
+  );
+  return (n) => {
+    if (n === null)
+      return { ok: !0, text: "", status: "empty" };
+    const i = De(n, t.valueKind);
+    return i.status === "invalid_shape" ? P(n, t, "invalid_raw_temporal_value") : i.status === "out_of_range" ? P(n, t, "out_of_range_raw_temporal_value") : { ok: !0, text: a(i), status: "formatted" };
+  };
+}
+function yt(e) {
+  return Ke({
+    metadata: e.metadata,
+    format: e.format
+  })(e.value);
+}
+class j extends Error {
+  constructor(r) {
+    super(
+      `invalid_presentation_execution_snapshot: ${r} Resave this report before running it again.`
+    );
+    g(this, "code", "invalid_presentation_execution_snapshot");
+    g(this, "deliveryBlocking", !0);
+    this.name = "PresentationExecutionSnapshotError";
+  }
+}
+class ht extends Error {
+  constructor(r) {
+    super(
+      `missing_resolved_raw_temporal_format: Column "${r}" has no captured presentation. Resave this report before running it again.`
+    );
+    g(this, "code", "missing_resolved_raw_temporal_format");
+    g(this, "deliveryBlocking", !0);
+    this.name = "MissingResolvedRawTemporalFormatError";
+  }
+}
+function S(e, t, r) {
+  const a = new Set(t), n = Object.keys(e).find((i) => !a.has(i));
+  if (n)
+    throw new Error(`${r} contains unknown property "${n}"`);
+}
+function Ne(e, t = "scope") {
+  if (!h(e))
+    throw new Error(`${t} must be an object`);
+  S(
+    e,
+    ["dashboardId", "cardId", "attachmentIndex"],
+    t
+  );
+  const r = typeof e.dashboardId == "string" ? e.dashboardId.trim() : "";
+  if (!r)
+    throw new Error(`${t}.dashboardId is required`);
+  const a = typeof e.cardId == "string" ? e.cardId.trim() : void 0;
+  if (e.cardId !== void 0 && !a)
+    throw new Error(`${t}.cardId must be a non-empty string`);
+  const n = e.attachmentIndex;
+  if (n !== void 0 && (typeof n != "number" || !Number.isInteger(n) || n < 0))
+    throw new Error(
+      `${t}.attachmentIndex must be a non-negative integer`
+    );
+  return {
+    dashboardId: r,
+    ...a ? { cardId: a } : {},
+    ...typeof n == "number" ? { attachmentIndex: n } : {}
+  };
+}
+function w(e, t, r, a) {
+  if (e.kind !== t) return;
+  S(e, ["kind", r], a);
+  const n = typeof e[r] == "string" ? e[r].trim() : "";
+  if (!n)
+    throw new Error(`${a}.${r} is required`);
+  return n;
+}
+function ze(e, t) {
+  if (!h(e))
+    throw new Error(`${t} must be an object`);
+  const r = w(e, "metric", "metricId", t);
+  if (r) return { kind: "metric", metricId: r };
+  const a = w(e, "column", "columnKey", t);
+  if (a) return { kind: "column", columnKey: a };
+  const n = w(
+    e,
+    "matrix_measure",
+    "measureId",
+    t
+  );
+  if (n) return { kind: "matrix_measure", measureId: n };
+  throw new Error(`${t} is not a valid numeric presentation target`);
+}
+function Pe(e, t) {
+  if (!h(e))
+    throw new Error(`${t} must be an object`);
+  if (e.kind === "field") {
+    S(e, ["kind", "fieldId", "role"], t);
+    const n = typeof e.fieldId == "string" ? e.fieldId.trim() : "";
+    if (!n)
+      throw new Error(`${t}.fieldId is required`);
+    const i = e.role;
+    if (i !== void 0 && i !== "groupby" && i !== "pivotby")
+      throw new Error(`${t}.role must be groupby or pivotby`);
+    return {
+      kind: "field",
+      fieldId: n,
+      ...i ? { role: i } : {}
+    };
+  }
+  const r = w(e, "column", "columnKey", t);
+  if (r) return { kind: "column", columnKey: r };
+  const a = w(
+    e,
+    "matrix_axis",
+    "axisInstanceId",
+    t
+  );
+  if (a) return { kind: "matrix_axis", axisInstanceId: a };
+  throw new Error(`${t} is not a valid temporal bucket presentation target`);
+}
+function je(e, t) {
+  if (!h(e))
+    throw new Error(`${t} must be an object`);
+  const r = w(e, "column", "columnKey", t);
+  if (!r)
+    throw new Error(`${t} must identify a column`);
+  return { kind: "column", columnKey: r };
+}
+function Oe(e) {
+  return [
+    e.dashboardId,
+    e.cardId ?? null,
+    e.attachmentIndex ?? null
+  ];
+}
+function I(e) {
+  switch (e.kind) {
+    case "metric":
+      return [e.kind, e.metricId];
+    case "column":
+      return [e.kind, e.columnKey];
+    case "matrix_measure":
+      return [e.kind, e.measureId];
+    case "field":
+      return [e.kind, e.fieldId, e.role ?? ""];
+    case "matrix_axis":
+      return [e.kind, e.axisInstanceId];
+  }
+}
+function M(e, t) {
+  return e.dashboardId === t.dashboardId && e.cardId === t.cardId && e.attachmentIndex === t.attachmentIndex;
+}
+function K(e, t) {
+  const r = I(e), a = I(t);
+  return r.length === a.length && r.every((n, i) => n === a[i]);
+}
+function Le(e) {
+  if (!Array.isArray(e))
+    throw new Error("resolvedFormats must be an array");
+  const t = /* @__PURE__ */ new Set();
+  return e.map((r, a) => {
+    var m, l;
+    const n = `resolvedFormats.${a}`;
+    if (!h(r))
+      throw new Error(`${n} must be an object`);
+    S(r, ["scope", "target", "format"], n);
+    const i = Ne(r.scope, `${n}.scope`);
+    if (!h(r.format))
+      throw new Error(`${n}.format must be an object`);
+    let o;
+    switch (r.format.type) {
+      case "temporal_bucket": {
+        const c = ne(r.format);
+        if (!c.ok)
+          throw new Error(
+            `${n}.format is invalid: ${((m = c.issues[0]) == null ? void 0 : m.message) ?? "invalid value"}`
+          );
+        o = {
+          scope: i,
+          target: Pe(r.target, `${n}.target`),
+          format: c.value
+        };
+        break;
+      }
+      case "raw_temporal":
+        o = {
+          scope: i,
+          target: je(r.target, `${n}.target`),
+          format: R(r.format)
+        };
+        break;
+      case "number":
+      case "currency":
+      case "percent":
+      case "scientific": {
+        const c = he(r.format);
+        if (!c.ok)
+          throw new Error(
+            `${n}.format is invalid: ${((l = c.issues[0]) == null ? void 0 : l.message) ?? "invalid value"}`
+          );
+        o = {
+          scope: i,
+          target: ze(r.target, `${n}.target`),
+          format: c.value
+        };
+        break;
+      }
+      default:
+        throw new Error(`${n}.format.type is unsupported`);
+    }
+    const s = JSON.stringify([
+      ...Oe(o.scope),
+      ...I(o.target)
+    ]);
+    if (t.has(s))
+      throw new Error(
+        `${n} duplicates a scoped presentation target`
+      );
+    return t.add(s), o;
+  });
+}
+function qe(e) {
+  try {
+    if (!h(e))
+      throw new Error("presentation execution snapshot must be an object");
+    if (S(
+      e,
+      ["version", "reportContext", "resolvedFormats"],
+      "presentation execution snapshot"
+    ), e.version !== 1)
+      throw new Error("presentation execution snapshot version must be 1");
+    const t = se(e.reportContext);
+    if (!t.ok) {
+      const r = t.issues[0];
+      throw new Error(
+        `presentation execution snapshot reportContext is invalid: ${r != null && r.path && r.path !== "$" ? `${r.path}: ` : ""}${(r == null ? void 0 : r.message) ?? "invalid value"}`
+      );
+    }
+    return {
+      version: 1,
+      reportContext: t.value,
+      resolvedFormats: Le(e.resolvedFormats)
+    };
+  } catch (t) {
+    throw t instanceof j ? t : new j(
+      t instanceof Error ? t.message : "Snapshot is invalid."
+    );
+  }
+}
+function gt(e) {
+  return qe({
+    version: 1,
+    reportContext: e.reportContext,
+    resolvedFormats: [...e.resolvedFormats]
+  });
+}
+function vt(e) {
+  const t = e.snapshot.resolvedFormats.find(
+    (r) => r.format.type !== "temporal_bucket" && r.format.type !== "raw_temporal" && M(r.scope, e.scope) && K(r.target, e.target)
+  );
+  return t == null ? void 0 : t.format;
+}
+function wt(e) {
+  const t = e.snapshot.resolvedFormats.find(
+    (r) => r.format.type === "raw_temporal" && M(r.scope, e.scope) && K(r.target, e.target)
+  );
+  return t == null ? void 0 : t.format;
+}
+function pt(e) {
+  const t = e.snapshot.resolvedFormats.find(
+    (r) => r.format.type === "temporal_bucket" && M(r.scope, e.scope) && K(r.target, e.target)
+  );
+  return t == null ? void 0 : t.format;
+}
+function xt(e) {
+  var n;
+  const t = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
+  if (e.snapshot.resolvedFormats.forEach((i, o) => {
+    if (i.scope.attachmentIndex !== void 0)
+      throw new Error(
+        `resolvedFormats.${o}.scope.attachmentIndex is not valid for a card export`
+      );
+    if (i.scope.dashboardId !== e.expectedScope.dashboardId || i.scope.cardId !== e.expectedScope.cardId)
+      throw new Error(
+        `resolvedFormats.${o}.scope must match the executing dashboard/card`
+      );
+    if (i.target.kind === "field" && i.format.type === "temporal_bucket") {
+      const s = JSON.stringify(I(i.target));
+      if (r.has(s))
+        throw new Error(
+          `resolvedFormats.${o} duplicates export field "${i.target.fieldId}"`
+        );
+      r.add(s);
+      return;
+    }
+    if (i.target.kind !== "column")
+      throw new Error(
+        `resolvedFormats.${o}.target must identify an export column or temporal pivot field`
+      );
+    if (t.has(i.target.columnKey))
+      throw new Error(
+        `resolvedFormats.${o} duplicates export column "${i.target.columnKey}"`
+      );
+    t.add(i.target.columnKey);
+  }), !e.useFormattedValues) return;
+  if (!((n = e.visibleColumns) != null && n.length))
+    throw new Error("visibleColumns must identify every formatted export column");
+  const a = e.visibleColumns.find(
+    (i) => !t.has(i)
+  );
+  if (a)
+    throw new Error(
+      `resolvedFormats is missing visible export column "${a}"`
+    );
+}
+function T(e) {
+  return Array.from(
+    new Set(
+      (e ?? []).flatMap(
+        (t) => typeof t.id == "string" && t.id ? [t.id] : []
+      )
+    )
+  );
+}
+function St(e) {
+  const t = e.metricFields ?? [], r = T(t), a = /* @__PURE__ */ new Map();
+  return r.forEach((n) => {
+    a.set(
+      n,
+      t.filter((i) => i.id === n).length
+    );
+  }), {
+    expectedRoleFieldIds: {
+      groupby: T(e.groupByFields),
+      metric: r.length > 0 ? r : [re],
+      pivotby: T(e.pivotByFields),
+      detail: T(e.detailFields)
+    },
+    expectedMetricAliases: t.flatMap(
+      (n) => n.id && (a.get(n.id) ?? 0) > 1 ? [ie(n)] : []
+    )
+  };
+}
+class u extends Error {
+  constructor(r, a) {
+    super(`invalid_pivot_result_lifecycle: ${r}`);
+    g(this, "code", "invalid_pivot_result_lifecycle");
+    g(this, "deliveryBlocking", !0);
+    this.cause = a, this.name = "PivotResultLifecycleError";
+  }
+}
+function Ve(e) {
+  if (!Array.isArray(e) || e.some(
+    (r) => !r || typeof r != "object" || Array.isArray(r) || typeof r.key != "string" || !r.key || typeof r.name != "string" || typeof r.label != "string"
+  ))
+    throw new u(
+      "Canonical pivot columns must be an array of keyed, named result descriptors."
+    );
+  const t = e;
+  if (new Set(t.map((r) => r.key)).size !== t.length)
+    throw new u(
+      "Canonical pivot column keys must be unique."
+    );
+  for (const r of t) {
+    const a = ce(r, {
+      metadataRequired: !1
+    });
+    if (!a.ok)
+      throw new u(
+        `Canonical pivot column "${r.key}" has invalid temporal metadata: ${a.error.message}`
+      );
+  }
+  return t;
+}
+function O(e) {
+  if (!e || typeof e != "object" || Array.isArray(e) || e.version !== 1 || e.source !== "explorer" || !e.byRole || typeof e.byRole != "object" || Array.isArray(e.byRole))
+    throw new u(
+      "A loaded canonical pivot result requires its role-scoped column key map."
+    );
+  const t = e, r = /* @__PURE__ */ new Set(["groupby", "metric", "pivotby", "detail"]);
+  for (const [a, n] of Object.entries(t.byRole)) {
+    if (!r.has(a) || !n || typeof n != "object" || Array.isArray(n))
+      throw new u(
+        `Canonical pivot role map contains invalid "${a}" bindings.`
+      );
+    for (const [i, o] of Object.entries(n))
+      if (!i || !o || typeof o != "object" || Array.isArray(o) || o.role !== a || typeof o.rawKey != "string" || !o.rawKey || o.outputKey !== void 0 && (typeof o.outputKey != "string" || !o.outputKey))
+        throw new u(
+          `Canonical pivot role map contains an invalid "${a}:${i}" binding.`
+        );
+  }
+  if (t.byMetricAlias !== void 0) {
+    if (!t.byMetricAlias || typeof t.byMetricAlias != "object" || Array.isArray(t.byMetricAlias))
+      throw new u(
+        "Canonical pivot metric-alias bindings must be an object."
+      );
+    for (const [a, n] of Object.entries(
+      t.byMetricAlias
+    ))
+      if (!a || !n || typeof n != "object" || Array.isArray(n) || n.role !== "metric" || typeof n.rawKey != "string" || !n.rawKey || n.outputKey !== void 0 && (typeof n.outputKey != "string" || !n.outputKey))
+        throw new u(
+          `Canonical pivot metric-alias map contains an invalid "${a}" binding.`
+        );
+  }
+  return t;
+}
+function Ge(e) {
+  if (e === void 0) return {};
+  if (!e || typeof e != "object" || Array.isArray(e))
+    throw new u(
+      "Canonical pivot column metadata must be an object."
+    );
+  for (const [t, r] of Object.entries(e)) {
+    if (!t || !r || typeof r != "object" || Array.isArray(r))
+      throw new u(
+        `Canonical pivot column metadata contains an invalid "${t}" classification.`
+      );
+    const { isSubtotal: a, subtotalScope: n } = r;
+    if (a !== void 0 && typeof a != "boolean" || n !== void 0 && n !== "base" && n !== "pivot-value" && n !== "grand-total" || a === !0 && n !== "pivot-value" && n !== "grand-total" || (n === "pivot-value" || n === "grand-total") && a !== !0 || n === "base" && a === !0)
+      throw new u(
+        `Canonical pivot column metadata contains an incoherent "${t}" subtotal classification.`
+      );
+  }
+  return e;
+}
+function L(e, t) {
+  if (!Array.isArray(e) || e.some((r) => typeof r != "string" || !r) || new Set(e).size !== e.length)
+    throw new u(
+      `Canonical pivot contract ${t} must be an array of unique field identities.`
+    );
+  return e;
+}
+function Be(e, t) {
+  if (!e || typeof e != "object" || Array.isArray(e) || e.version !== 1)
+    throw new u(
+      "A canonical pivot result requires its versioned result contract."
+    );
+  const r = e, a = r.expectedRoleFieldIds;
+  if (!a || typeof a != "object" || Array.isArray(a))
+    throw new u(
+      "Canonical pivot contract role identities must be an object."
+    );
+  const i = Object.fromEntries(
+    [
+      "groupby",
+      "metric",
+      "pivotby",
+      "detail"
+    ].map((f) => [
+      f,
+      L(
+        a[f],
+        `expectedRoleFieldIds.${f}`
+      )
+    ])
+  ), o = L(
+    r.expectedMetricAliases,
+    "expectedMetricAliases"
+  ), s = r.columnKinds;
+  if (!s || typeof s != "object" || Array.isArray(s))
+    throw new u(
+      "Canonical pivot contract column kinds must be an object."
+    );
+  const m = /* @__PURE__ */ new Set([
+    "row",
+    "pivot_metric",
+    "value"
+  ]), l = t.map((f) => f.key), c = Object.keys(s);
+  if (c.length !== l.length || c.some(
+    (f) => !l.includes(f) || !m.has(
+      s[f]
+    )
+  ))
+    throw new u(
+      "Canonical pivot contract must classify every authoritative result column exactly once."
+    );
+  const y = Ge(
+    r.columnClassifications
+  );
+  if (Object.keys(y).some(
+    (f) => !l.includes(f)
+  ))
+    throw new u(
+      "Canonical pivot contract contains a classification for an unknown result column."
+    );
+  return {
+    version: 1,
+    expectedRoleFieldIds: i,
+    expectedMetricAliases: o,
+    columnKinds: s,
+    columnClassifications: y
+  };
+}
+function q(e, t) {
+  const r = [
+    "groupby",
+    "metric",
+    "pivotby",
+    "detail"
+  ];
+  for (const i of r) {
+    const o = new Set(t.expectedRoleFieldIds[i] ?? []), s = Object.keys(e.byRole[i] ?? {});
+    if (s.length !== o.size || s.some((m) => !o.has(m)))
+      throw new u(
+        `The role-scoped ${i} bindings do not match the authored result fields.`
+      );
+  }
+  const a = new Set(t.expectedMetricAliases), n = Object.keys(e.byMetricAlias ?? {});
+  if (n.length !== a.size || n.some((i) => !a.has(i)))
+    throw new u(
+      "The metric-alias bindings do not match the authored metric instances."
+    );
+}
+function Ue(e) {
+  if (!Array.isArray(e) || e.some(
+    (t) => !t || typeof t != "object" || Array.isArray(t)
+  ))
+    throw new u(
+      "Canonical pivot records must be an array of row objects."
+    );
+  return e;
+}
+function Ze(e, t) {
+  e.forEach((r, a) => {
+    t.forEach((n) => {
+      if (!Object.prototype.hasOwnProperty.call(r, n.key) || r[n.key] === void 0)
+        throw new u(
+          `Canonical pivot column "${n.key}" is absent from row ${a}.`
+        );
+    });
+  });
+}
+function He(e, t, r) {
+  const a = new Set(t.map((n) => n.key));
+  ["groupby", "detail"].forEach((n) => {
+    Object.entries(e.byRole[n] ?? {}).forEach(
+      ([i, o]) => {
+        const s = o.outputKey || o.rawKey;
+        if (!a.has(s) || r.columnKinds[s] !== "row")
+          throw new u(
+            `The role-scoped ${n} binding for "${i}" does not name an authoritative result column.`
+          );
+      }
+    );
+  });
+}
+function V(e, t) {
+  t.forEach((r) => {
+    const a = e.columnKinds[r.key];
+    if (a === "pivot_metric" && r.pivotIdentity === void 0)
+      throw new u(
+        `Physical pivot result column "${r.key}" is missing its identity.`
+      );
+    if (a !== "pivot_metric" && r.pivotIdentity !== void 0)
+      throw new u(
+        `Canonical pivot result column "${r.key}" carries pivot identity outside the physical pivot projection.`
+      );
+  });
+}
+function Ye(e) {
+  const t = Ue(e.records), r = Ve(e.columns), a = Be(
+    e.pivotResultContract,
+    r
+  ), n = a.expectedRoleFieldIds.pivotby ?? [];
+  if (e.pivotResultState === "loaded_empty") {
+    if (t.length !== 0)
+      throw new u(
+        "A loaded_empty pivot result cannot carry records."
+      );
+    if (r.some(
+      (m) => a.columnKinds[m.key] === "pivot_metric"
+    ))
+      throw new u(
+        "A loaded_empty pivot result cannot carry physical pivot columns."
+      );
+    V(a, r);
+    const s = O(e.columnKeyMap);
+    return q(s, a), {
+      pivotResultState: "loaded_empty",
+      records: [],
+      columns: r,
+      columnKeyMap: s,
+      pivotResultContract: a
+    };
+  }
+  if (e.pivotResultState !== "loaded_valid")
+    throw new u(
+      "A canonical pivot result must declare loaded_empty or loaded_valid."
+    );
+  if (t.length === 0)
+    throw new u(
+      "A loaded_valid pivot result must carry at least one record."
+    );
+  const i = O(e.columnKeyMap);
+  q(i, a), He(i, r, a), V(a, r);
+  const o = r.filter(
+    (s) => a.columnKinds[s.key] === "pivot_metric"
+  );
+  if (n.length > 0 && o.length === 0)
+    throw new u(
+      "A loaded_valid pivot result is missing its physical pivot columns."
+    );
+  try {
+    me(o, {
+      expectedPivotFieldIds: n,
+      columnClassifications: a.columnClassifications
+    });
+  } catch (s) {
+    throw s instanceof le ? new u(s.message, s) : s;
+  }
+  return Ze(t, r), {
+    pivotResultState: "loaded_valid",
+    records: t,
+    columns: r,
+    columnKeyMap: i,
+    pivotResultContract: a
+  };
+}
+function bt(e) {
+  const t = /* @__PURE__ */ new Set();
+  ["groupby", "detail"].forEach((i) => {
+    Object.values(e.columnKeyMap.byRole[i] ?? {}).forEach((o) => {
+      t.add(o.outputKey || o.rawKey);
+    });
+  });
+  const r = new Set(e.physicalPivotColumnKeys), a = new Set(
+    e.columns.map((i) => i.key)
+  ), n = {
+    version: 1,
+    expectedRoleFieldIds: {
+      groupby: Array.from(
+        new Set(e.expectedRoleFieldIds.groupby ?? [])
+      ),
+      metric: Array.from(
+        new Set(e.expectedRoleFieldIds.metric ?? [])
+      ),
+      pivotby: Array.from(
+        new Set(e.expectedRoleFieldIds.pivotby ?? [])
+      ),
+      detail: Array.from(
+        new Set(e.expectedRoleFieldIds.detail ?? [])
+      )
+    },
+    expectedMetricAliases: [...e.expectedMetricAliases ?? []],
+    columnKinds: Object.fromEntries(
+      e.columns.map((i) => [
+        i.key,
+        t.has(i.key) ? "row" : r.has(i.key) ? "pivot_metric" : "value"
+      ])
+    ),
+    columnClassifications: Object.fromEntries(
+      Object.entries(e.columnMetadata ?? {}).filter(
+        ([i]) => a.has(i)
+      )
+    )
+  };
+  return Ye({
+    pivotResultState: e.records.length === 0 ? "loaded_empty" : "loaded_valid",
+    pivotResultContract: n,
+    records: e.records,
+    columns: e.columns,
+    columnKeyMap: e.columnKeyMap
+  });
+}
+export {
+  Ke as A,
+  yt as B,
+  St as C,
+  u as D,
+  Ye as E,
+  bt as F,
+  ht as M,
+  j as P,
+  p as R,
+  vt as a,
+  de as b,
+  A as c,
+  B as d,
+  U as e,
+  ot as f,
+  Z as g,
+  st as h,
+  he as i,
+  mt as j,
+  Ne as k,
+  Le as l,
+  qe as m,
+  gt as n,
+  wt as o,
+  ye as p,
+  pt as q,
+  ge as r,
+  xt as s,
+  R as t,
+  lt as u,
+  ct as v,
+  ut as w,
+  dt as x,
+  Te as y,
+  ft as z
+};