react-semaphor 0.1.541 → 0.1.543

package/dist/chunks/pivot-result-lifecycle-DupbRk-R.js

@@ -0,0 +1,1155 @@
+var V = Object.defineProperty;
+var X = (e, t, o) => t in e ? V(e, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : e[t] = o;
+var p = (e, t, o) => X(e, typeof t != "symbol" ? t + "" : t, o);
+import { N as z, O as q, P as y, q as Z, H as G, E as J, i as H } from "./temporal-bucket-D7NBrrtL.js";
+import { z as d } from "zod";
+import { aG as W, r as Q, a7 as ee, o as b, t as te } from "./validators-DMHTpf7a.js";
+import { b as oe } from "./report-runtime-context-Dq8XyODK.js";
+import { S as re } from "./analytics-base-schemas-BFAoRlkU.js";
+import "./matrix-operation-contract-8OIO4gob.js";
+import { r as ne, i as se } from "./metric-comparison-DEwi9uc2.js";
+import { d as ie, P as ae } from "./pivot-result-identity-DJhXXcns.js";
+function wt(e, t) {
+  const r = me(e);
+  let n;
+  if (r.date) {
+    const l = fe(r.date, 2);
+    n = ue(l.restDateString, l.year);
+  }
+  if (!n || isNaN(n.getTime()))
+    return /* @__PURE__ */ new Date(NaN);
+  const s = n.getTime();
+  let i = 0, a;
+  if (r.time && (i = pe(r.time), isNaN(i)))
+    return /* @__PURE__ */ new Date(NaN);
+  if (r.timezone) {
+    if (a = ye(r.timezone), isNaN(a))
+      return /* @__PURE__ */ new Date(NaN);
+  } else {
+    const l = new Date(s + i), m = /* @__PURE__ */ new Date(0);
+    return m.setFullYear(
+      l.getUTCFullYear(),
+      l.getUTCMonth(),
+      l.getUTCDate()
+    ), m.setHours(
+      l.getUTCHours(),
+      l.getUTCMinutes(),
+      l.getUTCSeconds(),
+      l.getUTCMilliseconds()
+    ), m;
+  }
+  return new Date(s + i + a);
+}
+const x = {
+  dateTimeDelimiter: /[T ]/,
+  timeZoneDelimiter: /[Z ]/i,
+  timezone: /([Z+-].*)$/
+}, ce = /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/, le = /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/, de = /^([+-])(\d{2})(?::?(\d{2}))?$/;
+function me(e) {
+  const t = {}, o = e.split(x.dateTimeDelimiter);
+  let r;
+  if (o.length > 2)
+    return t;
+  if (/:/.test(o[0]) ? r = o[0] : (t.date = o[0], r = o[1], x.timeZoneDelimiter.test(t.date) && (t.date = e.split(x.timeZoneDelimiter)[0], r = e.substr(
+    t.date.length,
+    e.length
+  ))), r) {
+    const n = x.timezone.exec(r);
+    n ? (t.time = r.replace(n[1], ""), t.timezone = n[1]) : t.time = r;
+  }
+  return t;
+}
+function fe(e, t) {
+  const o = new RegExp(
+    "^(?:(\\d{4}|[+-]\\d{" + (4 + t) + "})|(\\d{2}|[+-]\\d{" + (2 + t) + "})$)"
+  ), r = e.match(o);
+  if (!r) return { year: NaN, restDateString: "" };
+  const n = r[1] ? parseInt(r[1]) : null, s = r[2] ? parseInt(r[2]) : null;
+  return {
+    year: s === null ? n : s * 100,
+    restDateString: e.slice((r[1] || r[2]).length)
+  };
+}
+function ue(e, t) {
+  if (t === null) return /* @__PURE__ */ new Date(NaN);
+  const o = e.match(ce);
+  if (!o) return /* @__PURE__ */ new Date(NaN);
+  const r = !!o[4], n = v(o[1]), s = v(o[2]) - 1, i = v(o[3]), a = v(o[4]), l = v(o[5]) - 1;
+  if (r)
+    return be(t, a, l) ? he(t, a, l) : /* @__PURE__ */ new Date(NaN);
+  {
+    const m = /* @__PURE__ */ new Date(0);
+    return !ge(t, s, i) || !ve(t, n) ? /* @__PURE__ */ new Date(NaN) : (m.setUTCFullYear(t, s, Math.max(n, i)), m);
+  }
+}
+function v(e) {
+  return e ? parseInt(e) : 1;
+}
+function pe(e) {
+  const t = e.match(le);
+  if (!t) return NaN;
+  const o = _(t[1]), r = _(t[2]), n = _(t[3]);
+  return xe(o, r, n) ? o * z + r * q + n * 1e3 : NaN;
+}
+function _(e) {
+  return e && parseFloat(e.replace(",", ".")) || 0;
+}
+function ye(e) {
+  if (e === "Z") return 0;
+  const t = e.match(de);
+  if (!t) return 0;
+  const o = t[1] === "+" ? -1 : 1, r = parseInt(t[2]), n = t[3] && parseInt(t[3]) || 0;
+  return Ee(r, n) ? o * (r * z + n * q) : NaN;
+}
+function he(e, t, o) {
+  const r = /* @__PURE__ */ new Date(0);
+  r.setUTCFullYear(e, 0, 4);
+  const n = r.getUTCDay() || 7, s = (t - 1) * 7 + o + 1 - n;
+  return r.setUTCDate(r.getUTCDate() + s), r;
+}
+const we = [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function B(e) {
+  return e % 400 === 0 || e % 4 === 0 && e % 100 !== 0;
+}
+function ge(e, t, o) {
+  return t >= 0 && t <= 11 && o >= 1 && o <= (we[t] || (B(e) ? 29 : 28));
+}
+function ve(e, t) {
+  return t >= 1 && t <= (B(e) ? 366 : 365);
+}
+function be(e, t, o) {
+  return t >= 1 && t <= 53 && o >= 0 && o <= 6;
+}
+function xe(e, t, o) {
+  return e === 24 ? t === 0 && o === 0 : o >= 0 && o < 60 && t >= 0 && t < 60 && e >= 0 && e < 25;
+}
+function Ee(e, t) {
+  return t >= 0 && t <= 59;
+}
+const Ie = ["utf-8-bom", "utf-8"], Ce = "utf-8-bom", Re = [",", ";", "	"], Se = `\r
+`, Te = "text/csv; charset=utf-8";
+function gt(e) {
+  return e == null || typeof e == "string" || typeof e == "number" ? e : typeof e == "object" ? JSON.stringify(e) : String(e);
+}
+const ke = "\uFEFF";
+function K(e) {
+  return Ie.find((t) => t === e);
+}
+function vt(e) {
+  return Re.find((t) => t === e);
+}
+function bt(e) {
+  return K(e.requested) ?? K(e.dashboardDefault) ?? Ce;
+}
+function Ae(e) {
+  return e === "utf-8-bom" ? ke : "";
+}
+function xt(e) {
+  const t = e.trimStart().charAt(0);
+  return ["=", "+", "-", "@"].includes(t) || ["	", "\r", `
+`].includes(e.charAt(0)) ? `'${e}` : e;
+}
+function _e(e, t = ",") {
+  if (e == null)
+    return "";
+  const o = String(e);
+  return o.includes(t) || o.includes('"') || o.includes(`
+`) || o.includes("\r") ? `"${o.replace(/"/g, '""')}"` : o;
+}
+function L(e, t) {
+  return e.map((o) => _e(o, t)).join(t) + Se;
+}
+function $e(e, t) {
+  return e.map((o) => L(o, t)).join("");
+}
+function Et(e) {
+  return Ae(e.encoding) + (e.header ? L(e.header, e.delimiter) : "") + $e(e.rows, e.delimiter);
+}
+const T = ["csv", "xlsx"], Fe = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", F = {
+  csv: Object.freeze({
+    format: "csv",
+    extension: "csv",
+    contentType: Te,
+    partExtension: "csv",
+    partContentType: "text/csv",
+    compactedFileName: "export.csv.gz",
+    storedEncoding: "gzip",
+    storedValue: "CSV",
+    label: "CSV"
+  }),
+  xlsx: Object.freeze({
+    format: "xlsx",
+    extension: "xlsx",
+    contentType: Fe,
+    partExtension: "xml",
+    partContentType: "application/xml",
+    compactedFileName: "export.xlsx",
+    storedEncoding: "identity",
+    storedValue: "XLSX",
+    label: "Excel"
+  })
+};
+function It(e) {
+  return T.find((t) => t === e);
+}
+function Y(e) {
+  return { ...F[e] };
+}
+function Ct(e) {
+  return e === "XLSX" ? "xlsx" : "csv";
+}
+function j(e) {
+  return e.split(";")[0].trim().toLowerCase();
+}
+function Rt(e) {
+  if (!e) return;
+  const t = j(e);
+  return T.find(
+    (o) => j(F[o].contentType) === t
+  );
+}
+function St(e) {
+  var r;
+  const t = (((r = e.title) == null ? void 0 : r.trim()) || "export").replace(/[^a-z0-9]+/gi, "_").replace(/^_+|_+$/g, "") || "export", o = (e.at ?? /* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z").replace(/:/g, "-");
+  return `${t}-${o}.${F[e.format].extension}`;
+}
+const Me = 5 * 1024 * 1024, Tt = 64 * 1024 * 1024, C = d.number().int().positive().max(Number.MAX_SAFE_INTEGER), I = d.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER), R = I.refine((e) => e > 0), Ke = (e) => !!e && e !== "." && e !== ".." && !e.includes("/") && !e.includes("\\");
+function w(e, t) {
+  const o = t.split("/");
+  if (o.length !== 5 || o[0] !== "exports" || o[1] !== e || o[2] !== "attempts" || !o.every(Ke))
+    throw new Error("Invalid Matrix export artifact namespace.");
+  return { attemptId: o[3], filename: o[4] };
+}
+function kt(e, t, o) {
+  const r = `exports/${e}/attempts/${t}/${o}`;
+  return w(e, r), r;
+}
+const At = d.object({
+  acquisition: d.literal("continuation"),
+  jobId: d.string().min(1),
+  sequence: R,
+  deadlineAt: C
+}), je = [
+  "application/json",
+  ...T.map((e) => Y(e).partContentType)
+], Ne = d.object({
+  key: d.string(),
+  content: d.string(),
+  contentType: d.enum(je),
+  encoding: d.literal("gzip-base64").optional()
+  // Transport-only compression: JSON (layout, sheet layout) and Excel rows. CSV travels as it always has.
+}).refine((e) => !e.encoding || e.contentType === "application/json" || e.contentType === Y("xlsx").partContentType, "Unsupported Matrix artifact encoding."), De = d.discriminatedUnion("kind", [
+  d.object({ kind: d.literal("work"), sequence: R, checkpointKey: d.string(), objects: d.array(Ne).min(2).max(4), deadlineAt: C }),
+  d.object({ kind: d.literal("committed"), sequence: R, done: d.boolean(), deadlineAt: C })
+]);
+function Oe(e) {
+  const t = JSON.stringify(e);
+  if (t === void 0 || new TextEncoder().encode(t).byteLength > Me)
+    throw new RangeError("Matrix export batch exceeds its transport byte limit.");
+}
+function _t(e, t) {
+  const o = De.parse(e);
+  if (Oe(e), o.deadlineAt !== t.deadlineAt) throw new Error("Matrix deadline does not match the job.");
+  if (o.sequence !== t.sequence + (o.kind === "committed" ? 1 : 0))
+    throw new Error("Invalid Matrix batch sequence.");
+  if (o.kind === "work") {
+    w(t.jobId, o.checkpointKey);
+    for (const r of o.objects)
+      w(t.jobId, r.key);
+  }
+  return o;
+}
+const Ue = d.object({
+  acquisition: d.literal("continuation"),
+  deadlineAt: C,
+  chunks: d.array(d.object({ chunkNumber: R, dataKey: d.string() })).min(1),
+  totalRows: I,
+  totalBytes: I,
+  fileKey: d.string().min(1).optional(),
+  fileSize: I.optional(),
+  /** The file the job writes; absent means CSV (manifests from before Excel). */
+  format: d.enum(T).optional(),
+  /** Excel only: the sheet layout the layout batch stored, which compaction wraps the rows in. */
+  sheetKey: d.string().min(1).optional()
+}).refine((e) => e.fileKey === void 0 == (e.fileSize === void 0), "Incomplete published Matrix artifact.").refine((e) => e.format === "xlsx" == (e.sheetKey !== void 0), "An Excel Matrix manifest names its sheet layout, and only it does.");
+function $t(e, t, o) {
+  const r = Ue.parse(e);
+  if (r.deadlineAt !== o) throw new Error("Matrix deadline does not match the job.");
+  return r.chunks.forEach((n, s) => {
+    if (n.chunkNumber !== s + 1) throw new Error("Invalid committed Matrix chunk order.");
+    w(t, n.dataKey);
+  }), r.fileKey !== void 0 && w(t, r.fileKey), r.sheetKey !== void 0 && w(t, r.sheetKey), r;
+}
+function Ft(e, t) {
+  return t.levelLabels[e.id] ?? e.field.label ?? e.field.name;
+}
+function Mt(e, t) {
+  return t.measureLabels[e.id] ?? (e.kind === "aggregate" ? e.field.label ?? e.field.name : e.definition.label);
+}
+function Kt(e) {
+  return te.parse(Pe(e));
+}
+function Pe(e) {
+  const t = W.parse(e), o = (r) => ({
+    grand: { visible: !0, position: "after" },
+    levels: Object.fromEntries(
+      r.map((n) => [
+        n.id,
+        { visible: !0, position: "before" }
+      ])
+    )
+  });
+  return Q.parse({
+    version: 1,
+    spec: t,
+    presentation: {
+      layout: { kind: "compact" },
+      absence: { emptyText: "—", nullText: "" },
+      levelLabels: {},
+      measureLabels: {},
+      levelFormats: {},
+      measureFormats: {},
+      totals: { rows: o(t.rows), columns: o(t.columns) }
+    },
+    defaultView: {
+      rows: { depth: 0, overrides: [] },
+      columns: { depth: t.columns.length > 1 ? 1 : 0, overrides: [] }
+    }
+  });
+}
+function ze(e, t) {
+  const o = new Map(e.map((r) => [b(r), r]));
+  for (const r of t ?? []) o.set(b(r), r);
+  return [...o.values()];
+}
+function jt(e) {
+  const { spec: t, presentation: o, defaults: r, session: n } = ee.parse(e), s = new Map(
+    ze(t.sorts, n == null ? void 0 : n.sorts).map((a) => [b(a), a])
+  );
+  for (const a of ["rows", "columns"])
+    for (const l of t[a]) {
+      const m = {
+        axis: a,
+        levelId: l.id,
+        scope: { kind: "level" },
+        target: { kind: "member" },
+        direction: "asc",
+        nulls: "last"
+      };
+      s.has(b(m)) || s.set(b(m), m);
+    }
+  const i = (a, l) => ({
+    depth: Math.min(a.depth, Math.max(0, l - 1)),
+    // Leaf toggles are valid but have no effect. Collapsed ancestors retain dormant overrides.
+    overrides: a.overrides.filter(
+      (m) => m.path.length < l
+    )
+  });
+  return {
+    spec: { ...t, sorts: [...s.values()] },
+    presentation: o,
+    view: {
+      rows: i((n == null ? void 0 : n.rows) ?? r.rows, t.rows.length),
+      columns: i(
+        (n == null ? void 0 : n.columns) ?? r.columns,
+        t.columns.length
+      ),
+      sorts: (n == null ? void 0 : n.sorts) ?? []
+    }
+  };
+}
+class N extends Error {
+  constructor(o) {
+    super(
+      `invalid_presentation_execution_snapshot: ${o} Resave this report before running it again.`
+    );
+    p(this, "code", "invalid_presentation_execution_snapshot");
+    p(this, "deliveryBlocking", !0);
+    this.name = "PresentationExecutionSnapshotError";
+  }
+}
+class Nt extends Error {
+  constructor(o) {
+    super(
+      `missing_resolved_raw_temporal_format: Column "${o}" has no captured presentation. Resave this report before running it again.`
+    );
+    p(this, "code", "missing_resolved_raw_temporal_format");
+    p(this, "deliveryBlocking", !0);
+    this.name = "MissingResolvedRawTemporalFormatError";
+  }
+}
+function h(e, t, o) {
+  const r = new Set(t), n = Object.keys(e).find((s) => !r.has(s));
+  if (n)
+    throw new Error(`${o} contains unknown property "${n}"`);
+}
+function qe(e, t = "scope") {
+  if (!y(e))
+    throw new Error(`${t} must be an object`);
+  h(
+    e,
+    ["dashboardId", "cardId", "attachmentIndex"],
+    t
+  );
+  const o = typeof e.dashboardId == "string" ? e.dashboardId.trim() : "";
+  if (!o)
+    throw new Error(`${t}.dashboardId is required`);
+  const r = typeof e.cardId == "string" ? e.cardId.trim() : void 0;
+  if (e.cardId !== void 0 && !r)
+    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: o,
+    ...r ? { cardId: r } : {},
+    ...typeof n == "number" ? { attachmentIndex: n } : {}
+  };
+}
+function g(e, t, o, r) {
+  if (e.kind !== t) return;
+  h(e, ["kind", o], r);
+  const n = e[o];
+  if (typeof n != "string" || !n.trim())
+    throw new Error(`${r}.${o} is required`);
+  return n;
+}
+function $(e, t) {
+  if (!y(e))
+    throw new Error(`${t} must be an object`);
+  const o = g(e, "metric", "metricId", t);
+  if (o) return { kind: "metric", metricId: o };
+  const r = g(e, "column", "columnKey", t);
+  if (r) return { kind: "column", columnKey: r };
+  const n = g(
+    e,
+    "matrix_measure",
+    "measureId",
+    t
+  );
+  if (n) return { kind: "matrix_measure", measureId: n };
+  throw new Error(`${t} is not a valid numeric presentation target`);
+}
+const Be = [
+  "type",
+  "inputUnit",
+  "outputStyle",
+  "largestUnit",
+  "smallestUnit",
+  "maxUnits",
+  "prefix",
+  "suffix",
+  "negativeStyle"
+];
+function Le(e) {
+  return e === "millisecond" || e === "second" || e === "minute" || e === "hour" || e === "day";
+}
+const Ye = ["type", "locale", "pattern", "timezone", "sourceTimezone"];
+function Ve(e, t) {
+  if (h(e, Ye, t), typeof e.locale != "string" || !e.locale.trim())
+    throw new Error(`${t}.locale must be a non-empty string`);
+  for (const o of ["pattern", "timezone", "sourceTimezone"])
+    if (e[o] !== void 0 && typeof e[o] != "string")
+      throw new Error(`${t}.${o} must be a string`);
+  return {
+    type: "date",
+    locale: e.locale,
+    ...typeof e.pattern == "string" ? { pattern: e.pattern } : {},
+    ...typeof e.timezone == "string" ? { timezone: e.timezone } : {},
+    ...typeof e.sourceTimezone == "string" ? { sourceTimezone: e.sourceTimezone } : {}
+  };
+}
+function Xe(e, t) {
+  h(e, Be, t);
+  for (const s of ["inputUnit", "largestUnit", "smallestUnit"])
+    if (e[s] !== void 0 && !Le(e[s]))
+      throw new Error(`${t}.${s} must be a duration unit`);
+  const o = e.outputStyle;
+  if (o !== void 0 && o !== "compact" && o !== "digital" && o !== "long")
+    throw new Error(`${t}.outputStyle must be compact, digital, or long`);
+  const r = e.maxUnits;
+  if (r !== void 0 && (typeof r != "number" || !Number.isInteger(r) || r < 0 || r > 10))
+    throw new Error(`${t}.maxUnits must be an integer from 0 to 10`);
+  for (const s of ["prefix", "suffix"])
+    if (e[s] !== void 0 && typeof e[s] != "string")
+      throw new Error(`${t}.${s} must be a string`);
+  const n = e.negativeStyle;
+  if (n !== void 0 && n !== "minus" && n !== "parentheses")
+    throw new Error(`${t}.negativeStyle must be minus or parentheses`);
+  return {
+    type: "duration",
+    ...e.inputUnit !== void 0 ? { inputUnit: e.inputUnit } : {},
+    ...o !== void 0 ? { outputStyle: o } : {},
+    ...e.largestUnit !== void 0 ? { largestUnit: e.largestUnit } : {},
+    ...e.smallestUnit !== void 0 ? { smallestUnit: e.smallestUnit } : {},
+    ...r !== void 0 ? { maxUnits: r } : {},
+    ...e.prefix !== void 0 ? { prefix: e.prefix } : {},
+    ...e.suffix !== void 0 ? { suffix: e.suffix } : {},
+    ...n !== void 0 ? { negativeStyle: n } : {}
+  };
+}
+function Ze(e, t) {
+  if (!y(e))
+    throw new Error(`${t} must be an object`);
+  if (e.kind === "field") {
+    h(e, ["kind", "fieldId", "role"], t);
+    const n = typeof e.fieldId == "string" ? e.fieldId.trim() : "";
+    if (!n)
+      throw new Error(`${t}.fieldId is required`);
+    const s = e.role;
+    if (s !== void 0 && s !== "groupby" && s !== "pivotby")
+      throw new Error(`${t}.role must be groupby or pivotby`);
+    return {
+      kind: "field",
+      fieldId: n,
+      ...s ? { role: s } : {}
+    };
+  }
+  const o = g(e, "column", "columnKey", t);
+  if (o) return { kind: "column", columnKey: o };
+  const r = g(
+    e,
+    "matrix_axis",
+    "axisInstanceId",
+    t
+  );
+  if (r) return { kind: "matrix_axis", axisInstanceId: r };
+  throw new Error(`${t} is not a valid temporal bucket presentation target`);
+}
+function Ge(e, t) {
+  if (!y(e))
+    throw new Error(`${t} must be an object`);
+  const o = g(e, "column", "columnKey", t);
+  if (!o)
+    throw new Error(`${t} must identify a column`);
+  return { kind: "column", columnKey: o };
+}
+function Je(e) {
+  return [
+    e.dashboardId,
+    e.cardId ?? null,
+    e.attachmentIndex ?? null
+  ];
+}
+function S(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 k(e, t) {
+  return e.dashboardId === t.dashboardId && e.cardId === t.cardId && e.attachmentIndex === t.attachmentIndex;
+}
+function A(e, t) {
+  const o = S(e), r = S(t);
+  return o.length === r.length && o.every((n, s) => n === r[s]);
+}
+function He(e) {
+  if (!Array.isArray(e))
+    throw new Error("resolvedFormats must be an array");
+  const t = /* @__PURE__ */ new Set();
+  return e.map((o, r) => {
+    var l, m;
+    const n = `resolvedFormats.${r}`;
+    if (!y(o))
+      throw new Error(`${n} must be an object`);
+    h(o, ["scope", "target", "format"], n);
+    const s = qe(o.scope, `${n}.scope`);
+    if (!y(o.format))
+      throw new Error(`${n}.format must be an object`);
+    let i;
+    switch (o.format.type) {
+      case "temporal_bucket": {
+        const f = J(o.format);
+        if (!f.ok)
+          throw new Error(
+            `${n}.format is invalid: ${((l = f.issues[0]) == null ? void 0 : l.message) ?? "invalid value"}`
+          );
+        i = {
+          scope: s,
+          target: Ze(o.target, `${n}.target`),
+          format: f.value
+        };
+        break;
+      }
+      case "raw_temporal":
+        i = {
+          scope: s,
+          target: Ge(o.target, `${n}.target`),
+          format: G(o.format)
+        };
+        break;
+      case "number":
+      case "currency":
+      case "percent":
+      case "scientific": {
+        const f = Z(o.format);
+        if (!f.ok)
+          throw new Error(
+            `${n}.format is invalid: ${((m = f.issues[0]) == null ? void 0 : m.message) ?? "invalid value"}`
+          );
+        i = {
+          scope: s,
+          target: $(o.target, `${n}.target`),
+          format: f.value
+        };
+        break;
+      }
+      case "date": {
+        const f = $(o.target, `${n}.target`);
+        if (f.kind !== "column")
+          throw new Error(`${n}.target must identify a column for a date format`);
+        i = {
+          scope: s,
+          target: f,
+          format: Ve(o.format, `${n}.format`)
+        };
+        break;
+      }
+      case "duration":
+        i = {
+          scope: s,
+          target: $(o.target, `${n}.target`),
+          format: Xe(
+            o.format,
+            `${n}.format`
+          )
+        };
+        break;
+      default:
+        throw new Error(`${n}.format.type is unsupported`);
+    }
+    const a = JSON.stringify([
+      ...Je(i.scope),
+      ...S(i.target)
+    ]);
+    if (t.has(a))
+      throw new Error(
+        `${n} duplicates a scoped presentation target`
+      );
+    return t.add(a), i;
+  });
+}
+function We(e) {
+  try {
+    if (!y(e))
+      throw new Error("presentation execution snapshot must be an object");
+    if (h(
+      e,
+      ["version", "reportContext", "resolvedFormats"],
+      "presentation execution snapshot"
+    ), e.version !== 1)
+      throw new Error("presentation execution snapshot version must be 1");
+    const t = oe(e.reportContext);
+    if (!t.ok) {
+      const o = t.issues[0];
+      throw new Error(
+        `presentation execution snapshot reportContext is invalid: ${o != null && o.path && o.path !== "$" ? `${o.path}: ` : ""}${(o == null ? void 0 : o.message) ?? "invalid value"}`
+      );
+    }
+    return {
+      version: 1,
+      reportContext: t.value,
+      resolvedFormats: He(e.resolvedFormats)
+    };
+  } catch (t) {
+    throw t instanceof N ? t : new N(
+      t instanceof Error ? t.message : "Snapshot is invalid."
+    );
+  }
+}
+function Dt(e) {
+  return We({
+    version: 1,
+    reportContext: e.reportContext,
+    resolvedFormats: [...e.resolvedFormats]
+  });
+}
+function Ot(e) {
+  const t = Qe(e);
+  return H(t) ? t : void 0;
+}
+function Qe(e) {
+  const t = e.snapshot.resolvedFormats.find(
+    (o) => o.format.type !== "temporal_bucket" && o.format.type !== "raw_temporal" && o.format.type !== "date" && k(o.scope, e.scope) && A(o.target, e.target)
+  );
+  return t == null ? void 0 : t.format;
+}
+function Ut(e) {
+  const t = e.snapshot.resolvedFormats.find(
+    (o) => o.format.type === "date" && k(o.scope, e.scope) && A(o.target, e.target)
+  );
+  return t == null ? void 0 : t.format;
+}
+function Pt(e) {
+  const t = e.snapshot.resolvedFormats.find(
+    (o) => o.format.type === "raw_temporal" && k(o.scope, e.scope) && A(o.target, e.target)
+  );
+  return t == null ? void 0 : t.format;
+}
+function zt(e) {
+  const t = e.snapshot.resolvedFormats.find(
+    (o) => o.format.type === "temporal_bucket" && k(o.scope, e.scope) && A(o.target, e.target)
+  );
+  return t == null ? void 0 : t.format;
+}
+function qt(e) {
+  var n;
+  const t = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set();
+  if (e.snapshot.resolvedFormats.forEach((s, i) => {
+    if (s.scope.attachmentIndex !== void 0)
+      throw new Error(
+        `resolvedFormats.${i}.scope.attachmentIndex is not valid for a card export`
+      );
+    if (s.scope.dashboardId !== e.expectedScope.dashboardId || s.scope.cardId !== e.expectedScope.cardId)
+      throw new Error(
+        `resolvedFormats.${i}.scope must match the executing dashboard/card`
+      );
+    if (s.target.kind === "field" && s.format.type === "temporal_bucket") {
+      const a = JSON.stringify(S(s.target));
+      if (o.has(a))
+        throw new Error(
+          `resolvedFormats.${i} duplicates export field "${s.target.fieldId}"`
+        );
+      o.add(a);
+      return;
+    }
+    if (s.target.kind !== "column")
+      throw new Error(
+        `resolvedFormats.${i}.target must identify an export column or temporal pivot field`
+      );
+    if (t.has(s.target.columnKey))
+      throw new Error(
+        `resolvedFormats.${i} duplicates export column "${s.target.columnKey}"`
+      );
+    t.add(s.target.columnKey);
+  }), !e.useFormattedValues) return;
+  if (!((n = e.visibleColumns) != null && n.length))
+    throw new Error("visibleColumns must identify every formatted export column");
+  const r = e.visibleColumns.find(
+    (s) => !t.has(s)
+  );
+  if (r)
+    throw new Error(
+      `resolvedFormats is missing visible export column "${r}"`
+    );
+}
+function E(e) {
+  return Array.from(
+    new Set(
+      (e ?? []).flatMap(
+        (t) => typeof t.id == "string" && t.id ? [t.id] : []
+      )
+    )
+  );
+}
+function et(e) {
+  const t = /* @__PURE__ */ new Map();
+  return e.forEach((o) => {
+    o.id && t.set(o.id, (t.get(o.id) ?? 0) + 1);
+  }), e.flatMap(
+    (o) => o.id && (t.get(o.id) ?? 0) > 1 ? [ne(o)] : []
+  );
+}
+function Bt(e) {
+  const t = e.metricFields ?? [], o = E(t);
+  return {
+    expectedRoleFieldIds: {
+      groupby: E(e.groupByFields),
+      metric: o.length > 0 ? o : [re],
+      pivotby: E(e.pivotByFields),
+      detail: E(e.detailFields)
+    },
+    expectedMetricAliases: et(t)
+  };
+}
+class c extends Error {
+  constructor(o, r) {
+    super(`invalid_pivot_result_lifecycle: ${o}`);
+    p(this, "code", "invalid_pivot_result_lifecycle");
+    p(this, "deliveryBlocking", !0);
+    this.cause = r, this.name = "PivotResultLifecycleError";
+  }
+}
+function tt(e) {
+  if (!Array.isArray(e) || e.some(
+    (o) => !o || typeof o != "object" || Array.isArray(o) || typeof o.key != "string" || !o.key || typeof o.name != "string" || typeof o.label != "string"
+  ))
+    throw new c(
+      "Canonical pivot columns must be an array of keyed, named result descriptors."
+    );
+  const t = e;
+  if (new Set(t.map((o) => o.key)).size !== t.length)
+    throw new c(
+      "Canonical pivot column keys must be unique."
+    );
+  for (const o of t) {
+    const r = se(o, {
+      metadataRequired: !1
+    });
+    if (!r.ok)
+      throw new c(
+        `Canonical pivot column "${o.key}" has invalid temporal metadata: ${r.error.message}`
+      );
+  }
+  return t;
+}
+function D(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 c(
+      "A loaded canonical pivot result requires its role-scoped column key map."
+    );
+  const t = e, o = /* @__PURE__ */ new Set(["groupby", "metric", "pivotby", "detail"]);
+  for (const [r, n] of Object.entries(t.byRole)) {
+    if (!o.has(r) || !n || typeof n != "object" || Array.isArray(n))
+      throw new c(
+        `Canonical pivot role map contains invalid "${r}" bindings.`
+      );
+    for (const [s, i] of Object.entries(n))
+      if (!s || !i || typeof i != "object" || Array.isArray(i) || i.role !== r || typeof i.rawKey != "string" || !i.rawKey || i.outputKey !== void 0 && (typeof i.outputKey != "string" || !i.outputKey))
+        throw new c(
+          `Canonical pivot role map contains an invalid "${r}:${s}" binding.`
+        );
+  }
+  if (t.byMetricAlias !== void 0) {
+    if (!t.byMetricAlias || typeof t.byMetricAlias != "object" || Array.isArray(t.byMetricAlias))
+      throw new c(
+        "Canonical pivot metric-alias bindings must be an object."
+      );
+    for (const [r, n] of Object.entries(
+      t.byMetricAlias
+    ))
+      if (!r || !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 c(
+          `Canonical pivot metric-alias map contains an invalid "${r}" binding.`
+        );
+  }
+  return t;
+}
+function ot(e) {
+  if (e === void 0) return {};
+  if (!e || typeof e != "object" || Array.isArray(e))
+    throw new c(
+      "Canonical pivot column metadata must be an object."
+    );
+  for (const [t, o] of Object.entries(e)) {
+    if (!t || !o || typeof o != "object" || Array.isArray(o))
+      throw new c(
+        `Canonical pivot column metadata contains an invalid "${t}" classification.`
+      );
+    const { isSubtotal: r, subtotalScope: n } = o;
+    if (r !== void 0 && typeof r != "boolean" || n !== void 0 && n !== "base" && n !== "pivot-value" && n !== "grand-total" || r === !0 && n !== "pivot-value" && n !== "grand-total" || (n === "pivot-value" || n === "grand-total") && r !== !0 || n === "base" && r === !0)
+      throw new c(
+        `Canonical pivot column metadata contains an incoherent "${t}" subtotal classification.`
+      );
+  }
+  return e;
+}
+function O(e, t) {
+  if (!Array.isArray(e) || e.some((o) => typeof o != "string" || !o) || new Set(e).size !== e.length)
+    throw new c(
+      `Canonical pivot contract ${t} must be an array of unique field identities.`
+    );
+  return e;
+}
+function rt(e, t) {
+  if (!e || typeof e != "object" || Array.isArray(e) || e.version !== 1)
+    throw new c(
+      "A canonical pivot result requires its versioned result contract."
+    );
+  const o = e, r = o.expectedRoleFieldIds;
+  if (!r || typeof r != "object" || Array.isArray(r))
+    throw new c(
+      "Canonical pivot contract role identities must be an object."
+    );
+  const s = Object.fromEntries(
+    [
+      "groupby",
+      "metric",
+      "pivotby",
+      "detail"
+    ].map((u) => [
+      u,
+      O(
+        r[u],
+        `expectedRoleFieldIds.${u}`
+      )
+    ])
+  ), i = O(
+    o.expectedMetricAliases,
+    "expectedMetricAliases"
+  ), a = o.columnKinds;
+  if (!a || typeof a != "object" || Array.isArray(a))
+    throw new c(
+      "Canonical pivot contract column kinds must be an object."
+    );
+  const l = /* @__PURE__ */ new Set([
+    "row",
+    "pivot_metric",
+    "value"
+  ]), m = t.map((u) => u.key), f = Object.keys(a);
+  if (f.length !== m.length || f.some(
+    (u) => !m.includes(u) || !l.has(
+      a[u]
+    )
+  ))
+    throw new c(
+      "Canonical pivot contract must classify every authoritative result column exactly once."
+    );
+  const M = ot(
+    o.columnClassifications
+  );
+  if (Object.keys(M).some(
+    (u) => !m.includes(u)
+  ))
+    throw new c(
+      "Canonical pivot contract contains a classification for an unknown result column."
+    );
+  return {
+    version: 1,
+    expectedRoleFieldIds: s,
+    expectedMetricAliases: i,
+    columnKinds: a,
+    columnClassifications: M
+  };
+}
+function U(e, t) {
+  const o = [
+    "groupby",
+    "metric",
+    "pivotby",
+    "detail"
+  ];
+  for (const s of o) {
+    const i = new Set(t.expectedRoleFieldIds[s] ?? []), a = Object.keys(e.byRole[s] ?? {});
+    if (a.length !== i.size || a.some((l) => !i.has(l)))
+      throw new c(
+        `The role-scoped ${s} bindings do not match the authored result fields.`
+      );
+  }
+  const r = new Set(t.expectedMetricAliases), n = Object.keys(e.byMetricAlias ?? {});
+  if (n.length !== r.size || n.some((s) => !r.has(s)))
+    throw new c(
+      "The metric-alias bindings do not match the authored metric instances."
+    );
+}
+function nt(e) {
+  if (!Array.isArray(e) || e.some(
+    (t) => !t || typeof t != "object" || Array.isArray(t)
+  ))
+    throw new c(
+      "Canonical pivot records must be an array of row objects."
+    );
+  return e;
+}
+function st(e, t) {
+  e.forEach((o, r) => {
+    t.forEach((n) => {
+      if (!Object.prototype.hasOwnProperty.call(o, n.key) || o[n.key] === void 0)
+        throw new c(
+          `Canonical pivot column "${n.key}" is absent from row ${r}.`
+        );
+    });
+  });
+}
+function it(e, t, o) {
+  const r = new Set(t.map((n) => n.key));
+  ["groupby", "detail"].forEach((n) => {
+    Object.entries(e.byRole[n] ?? {}).forEach(
+      ([s, i]) => {
+        const a = i.outputKey || i.rawKey;
+        if (!r.has(a) || o.columnKinds[a] !== "row")
+          throw new c(
+            `The role-scoped ${n} binding for "${s}" does not name an authoritative result column.`
+          );
+      }
+    );
+  });
+}
+function P(e, t) {
+  t.forEach((o) => {
+    const r = e.columnKinds[o.key];
+    if (r === "pivot_metric" && o.pivotIdentity === void 0)
+      throw new c(
+        `Physical pivot result column "${o.key}" is missing its identity.`
+      );
+    if (r !== "pivot_metric" && o.pivotIdentity !== void 0)
+      throw new c(
+        `Canonical pivot result column "${o.key}" carries pivot identity outside the physical pivot projection.`
+      );
+  });
+}
+function at(e) {
+  const t = nt(e.records), o = tt(e.columns), r = rt(
+    e.pivotResultContract,
+    o
+  ), n = r.expectedRoleFieldIds.pivotby ?? [];
+  if (e.pivotResultState === "loaded_empty") {
+    if (t.length !== 0)
+      throw new c(
+        "A loaded_empty pivot result cannot carry records."
+      );
+    if (o.some(
+      (l) => r.columnKinds[l.key] === "pivot_metric"
+    ))
+      throw new c(
+        "A loaded_empty pivot result cannot carry physical pivot columns."
+      );
+    P(r, o);
+    const a = D(e.columnKeyMap);
+    return U(a, r), {
+      pivotResultState: "loaded_empty",
+      records: [],
+      columns: o,
+      columnKeyMap: a,
+      pivotResultContract: r
+    };
+  }
+  if (e.pivotResultState !== "loaded_valid")
+    throw new c(
+      "A canonical pivot result must declare loaded_empty or loaded_valid."
+    );
+  if (t.length === 0)
+    throw new c(
+      "A loaded_valid pivot result must carry at least one record."
+    );
+  const s = D(e.columnKeyMap);
+  U(s, r), it(s, o, r), P(r, o);
+  const i = o.filter(
+    (a) => r.columnKinds[a.key] === "pivot_metric"
+  );
+  if (n.length > 0 && i.length === 0)
+    throw new c(
+      "A loaded_valid pivot result is missing its physical pivot columns."
+    );
+  try {
+    ie(i, {
+      expectedPivotFieldIds: n,
+      columnClassifications: r.columnClassifications
+    });
+  } catch (a) {
+    throw a instanceof ae ? new c(a.message, a) : a;
+  }
+  return st(t, o), {
+    pivotResultState: "loaded_valid",
+    records: t,
+    columns: o,
+    columnKeyMap: s,
+    pivotResultContract: r
+  };
+}
+function Lt(e) {
+  const t = /* @__PURE__ */ new Set();
+  ["groupby", "detail"].forEach((s) => {
+    Object.values(e.columnKeyMap.byRole[s] ?? {}).forEach((i) => {
+      t.add(i.outputKey || i.rawKey);
+    });
+  });
+  const o = new Set(e.physicalPivotColumnKeys), r = new Set(
+    e.columns.map((s) => s.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((s) => [
+        s.key,
+        t.has(s.key) ? "row" : o.has(s.key) ? "pivot_metric" : "value"
+      ])
+    ),
+    columnClassifications: Object.fromEntries(
+      Object.entries(e.columnMetadata ?? {}).filter(
+        ([s]) => r.has(s)
+      )
+    )
+  };
+  return at({
+    pivotResultState: e.records.length === 0 ? "loaded_empty" : "loaded_valid",
+    pivotResultContract: n,
+    records: e.records,
+    columns: e.columns,
+    columnKeyMap: e.columnKeyMap
+  });
+}
+export {
+  Pe as $,
+  De as A,
+  Oe as B,
+  Ie as C,
+  Ce as D,
+  T as E,
+  _t as F,
+  Ue as G,
+  $t as H,
+  qe as I,
+  He as J,
+  We as K,
+  Dt as L,
+  Nt as M,
+  Ot as N,
+  Ut as O,
+  N as P,
+  zt as Q,
+  qt as R,
+  et as S,
+  Bt as T,
+  c as U,
+  at as V,
+  Lt as W,
+  Fe as X,
+  Ft as Y,
+  Mt as Z,
+  Kt as _,
+  Qe as a,
+  ze as a0,
+  jt as a1,
+  wt as a2,
+  Re as b,
+  L as c,
+  Se as d,
+  Te as e,
+  Pt as f,
+  vt as g,
+  Ae as h,
+  _e as i,
+  xt as j,
+  $e as k,
+  Et as l,
+  It as m,
+  Y as n,
+  Ct as o,
+  K as p,
+  Rt as q,
+  bt as r,
+  St as s,
+  gt as t,
+  Me as u,
+  Tt as v,
+  C as w,
+  w as x,
+  kt as y,
+  At as z
+};