react-semaphor 0.1.537 → 0.1.539

package/dist/chunks/pivot-result-lifecycle-8qCDmpKc.js

@@ -0,0 +1,804 @@
+var M = Object.defineProperty;
+var F = (e, o, t) => o in e ? M(e, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[o] = t;
+var u = (e, o, t) => F(e, typeof o != "symbol" ? o + "" : o, t);
+import { z as l } from "zod";
+import { m as T, o as P, i as O } from "./raw-temporal-D61lr48Y.js";
+import { b as U } from "./report-runtime-context-B984Nq1E.js";
+import { g as p, b as q } from "./temporal-bucket-D8JF7zKz.js";
+import { S as N } from "./analytics-base-schemas-BFAoRlkU.js";
+import "./validators-Ej1DdCXa.js";
+import "./matrix-operation-contract-B8PBF1Gd.js";
+import { r as B } from "./metric-comparison-CojWeLqx.js";
+import { a as z } from "./temporal-bucket-contract-DaOajRC7.js";
+import { d as D, P as J } from "./pivot-result-identity-D6hhcRXi.js";
+const X = 5 * 1024 * 1024, x = l.number().int().positive().max(Number.MAX_SAFE_INTEGER), g = l.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER), I = g.refine((e) => e > 0), G = (e) => !!e && e !== "." && e !== ".." && !e.includes("/") && !e.includes("\\");
+function v(e, o) {
+  const t = o.split("/");
+  if (t.length !== 5 || t[0] !== "exports" || t[1] !== e || t[2] !== "attempts" || !t.every(G))
+    throw new Error("Invalid Matrix export artifact namespace.");
+  return { attemptId: t[3], filename: t[4] };
+}
+function Ee(e, o, t) {
+  const r = `exports/${e}/attempts/${o}/${t}`;
+  return v(e, r), r;
+}
+const $e = l.object({
+  acquisition: l.literal("continuation"),
+  jobId: l.string().min(1),
+  sequence: I,
+  deadlineAt: x
+}), L = l.object({
+  key: l.string(),
+  content: l.string(),
+  contentType: l.enum(["text/csv", "application/json"]),
+  encoding: l.literal("gzip-base64").optional()
+}).refine((e) => !e.encoding || e.contentType === "application/json", "Unsupported Matrix artifact encoding."), V = l.discriminatedUnion("kind", [
+  l.object({ kind: l.literal("work"), sequence: I, checkpointKey: l.string(), objects: l.array(L).min(2).max(3), deadlineAt: x }),
+  l.object({ kind: l.literal("committed"), sequence: I, done: l.boolean(), deadlineAt: x })
+]);
+function Y(e) {
+  const o = JSON.stringify(e);
+  if (o === void 0 || new TextEncoder().encode(o).byteLength > X)
+    throw new RangeError("Matrix export batch exceeds its transport byte limit.");
+}
+function Se(e, o) {
+  const t = V.parse(e);
+  if (Y(e), t.deadlineAt !== o.deadlineAt) throw new Error("Matrix deadline does not match the job.");
+  if (t.sequence !== o.sequence + (t.kind === "committed" ? 1 : 0))
+    throw new Error("Invalid Matrix batch sequence.");
+  if (t.kind === "work") {
+    v(o.jobId, t.checkpointKey);
+    for (const r of t.objects)
+      v(o.jobId, r.key);
+  }
+  return t;
+}
+const H = l.object({
+  acquisition: l.literal("continuation"),
+  deadlineAt: x,
+  chunks: l.array(l.object({ chunkNumber: I, dataKey: l.string() })).min(1),
+  totalRows: g,
+  totalBytes: g,
+  fileKey: l.string().min(1).optional(),
+  fileSize: g.optional()
+}).refine((e) => e.fileKey === void 0 == (e.fileSize === void 0), "Incomplete published Matrix artifact.");
+function _e(e, o, t) {
+  const r = H.parse(e);
+  if (r.deadlineAt !== t) throw new Error("Matrix deadline does not match the job.");
+  return r.chunks.forEach((n, i) => {
+    if (n.chunkNumber !== i + 1) throw new Error("Invalid committed Matrix chunk order.");
+    v(o, n.dataKey);
+  }), r.fileKey !== void 0 && v(o, r.fileKey), r;
+}
+class $ extends Error {
+  constructor(t) {
+    super(
+      `invalid_presentation_execution_snapshot: ${t} Resave this report before running it again.`
+    );
+    u(this, "code", "invalid_presentation_execution_snapshot");
+    u(this, "deliveryBlocking", !0);
+    this.name = "PresentationExecutionSnapshotError";
+  }
+}
+class Ce extends Error {
+  constructor(t) {
+    super(
+      `missing_resolved_raw_temporal_format: Column "${t}" has no captured presentation. Resave this report before running it again.`
+    );
+    u(this, "code", "missing_resolved_raw_temporal_format");
+    u(this, "deliveryBlocking", !0);
+    this.name = "MissingResolvedRawTemporalFormatError";
+  }
+}
+function w(e, o, t) {
+  const r = new Set(o), n = Object.keys(e).find((i) => !r.has(i));
+  if (n)
+    throw new Error(`${t} contains unknown property "${n}"`);
+}
+function Q(e, o = "scope") {
+  if (!p(e))
+    throw new Error(`${o} must be an object`);
+  w(
+    e,
+    ["dashboardId", "cardId", "attachmentIndex"],
+    o
+  );
+  const t = typeof e.dashboardId == "string" ? e.dashboardId.trim() : "";
+  if (!t)
+    throw new Error(`${o}.dashboardId is required`);
+  const r = typeof e.cardId == "string" ? e.cardId.trim() : void 0;
+  if (e.cardId !== void 0 && !r)
+    throw new Error(`${o}.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(
+      `${o}.attachmentIndex must be a non-negative integer`
+    );
+  return {
+    dashboardId: t,
+    ...r ? { cardId: r } : {},
+    ...typeof n == "number" ? { attachmentIndex: n } : {}
+  };
+}
+function h(e, o, t, r) {
+  if (e.kind !== o) return;
+  w(e, ["kind", t], r);
+  const n = typeof e[t] == "string" ? e[t].trim() : "";
+  if (!n)
+    throw new Error(`${r}.${t} is required`);
+  return n;
+}
+function S(e, o) {
+  if (!p(e))
+    throw new Error(`${o} must be an object`);
+  const t = h(e, "metric", "metricId", o);
+  if (t) return { kind: "metric", metricId: t };
+  const r = h(e, "column", "columnKey", o);
+  if (r) return { kind: "column", columnKey: r };
+  const n = h(
+    e,
+    "matrix_measure",
+    "measureId",
+    o
+  );
+  if (n) return { kind: "matrix_measure", measureId: n };
+  throw new Error(`${o} is not a valid numeric presentation target`);
+}
+const W = [
+  "type",
+  "inputUnit",
+  "outputStyle",
+  "largestUnit",
+  "smallestUnit",
+  "maxUnits",
+  "prefix",
+  "suffix",
+  "negativeStyle"
+];
+function Z(e) {
+  return e === "millisecond" || e === "second" || e === "minute" || e === "hour" || e === "day";
+}
+function ee(e, o) {
+  w(e, W, o);
+  for (const i of ["inputUnit", "largestUnit", "smallestUnit"])
+    if (e[i] !== void 0 && !Z(e[i]))
+      throw new Error(`${o}.${i} must be a duration unit`);
+  const t = e.outputStyle;
+  if (t !== void 0 && t !== "compact" && t !== "digital" && t !== "long")
+    throw new Error(`${o}.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(`${o}.maxUnits must be an integer from 0 to 10`);
+  for (const i of ["prefix", "suffix"])
+    if (e[i] !== void 0 && typeof e[i] != "string")
+      throw new Error(`${o}.${i} must be a string`);
+  const n = e.negativeStyle;
+  if (n !== void 0 && n !== "minus" && n !== "parentheses")
+    throw new Error(`${o}.negativeStyle must be minus or parentheses`);
+  return {
+    type: "duration",
+    ...e.inputUnit !== void 0 ? { inputUnit: e.inputUnit } : {},
+    ...t !== void 0 ? { outputStyle: t } : {},
+    ...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 te(e, o) {
+  if (!p(e))
+    throw new Error(`${o} must be an object`);
+  if (e.kind === "field") {
+    w(e, ["kind", "fieldId", "role"], o);
+    const n = typeof e.fieldId == "string" ? e.fieldId.trim() : "";
+    if (!n)
+      throw new Error(`${o}.fieldId is required`);
+    const i = e.role;
+    if (i !== void 0 && i !== "groupby" && i !== "pivotby")
+      throw new Error(`${o}.role must be groupby or pivotby`);
+    return {
+      kind: "field",
+      fieldId: n,
+      ...i ? { role: i } : {}
+    };
+  }
+  const t = h(e, "column", "columnKey", o);
+  if (t) return { kind: "column", columnKey: t };
+  const r = h(
+    e,
+    "matrix_axis",
+    "axisInstanceId",
+    o
+  );
+  if (r) return { kind: "matrix_axis", axisInstanceId: r };
+  throw new Error(`${o} is not a valid temporal bucket presentation target`);
+}
+function oe(e, o) {
+  if (!p(e))
+    throw new Error(`${o} must be an object`);
+  const t = h(e, "column", "columnKey", o);
+  if (!t)
+    throw new Error(`${o} must identify a column`);
+  return { kind: "column", columnKey: t };
+}
+function re(e) {
+  return [
+    e.dashboardId,
+    e.cardId ?? null,
+    e.attachmentIndex ?? null
+  ];
+}
+function k(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 A(e, o) {
+  return e.dashboardId === o.dashboardId && e.cardId === o.cardId && e.attachmentIndex === o.attachmentIndex;
+}
+function R(e, o) {
+  const t = k(e), r = k(o);
+  return t.length === r.length && t.every((n, i) => n === r[i]);
+}
+function ne(e) {
+  if (!Array.isArray(e))
+    throw new Error("resolvedFormats must be an array");
+  const o = /* @__PURE__ */ new Set();
+  return e.map((t, r) => {
+    var f, y;
+    const n = `resolvedFormats.${r}`;
+    if (!p(t))
+      throw new Error(`${n} must be an object`);
+    w(t, ["scope", "target", "format"], n);
+    const i = Q(t.scope, `${n}.scope`);
+    if (!p(t.format))
+      throw new Error(`${n}.format must be an object`);
+    let s;
+    switch (t.format.type) {
+      case "temporal_bucket": {
+        const d = q(t.format);
+        if (!d.ok)
+          throw new Error(
+            `${n}.format is invalid: ${((f = d.issues[0]) == null ? void 0 : f.message) ?? "invalid value"}`
+          );
+        s = {
+          scope: i,
+          target: te(t.target, `${n}.target`),
+          format: d.value
+        };
+        break;
+      }
+      case "raw_temporal":
+        s = {
+          scope: i,
+          target: oe(t.target, `${n}.target`),
+          format: P(t.format)
+        };
+        break;
+      case "number":
+      case "currency":
+      case "percent":
+      case "scientific": {
+        const d = T(t.format);
+        if (!d.ok)
+          throw new Error(
+            `${n}.format is invalid: ${((y = d.issues[0]) == null ? void 0 : y.message) ?? "invalid value"}`
+          );
+        s = {
+          scope: i,
+          target: S(t.target, `${n}.target`),
+          format: d.value
+        };
+        break;
+      }
+      case "duration":
+        s = {
+          scope: i,
+          target: S(t.target, `${n}.target`),
+          format: ee(
+            t.format,
+            `${n}.format`
+          )
+        };
+        break;
+      default:
+        throw new Error(`${n}.format.type is unsupported`);
+    }
+    const c = JSON.stringify([
+      ...re(s.scope),
+      ...k(s.target)
+    ]);
+    if (o.has(c))
+      throw new Error(
+        `${n} duplicates a scoped presentation target`
+      );
+    return o.add(c), s;
+  });
+}
+function ie(e) {
+  try {
+    if (!p(e))
+      throw new Error("presentation execution snapshot must be an object");
+    if (w(
+      e,
+      ["version", "reportContext", "resolvedFormats"],
+      "presentation execution snapshot"
+    ), e.version !== 1)
+      throw new Error("presentation execution snapshot version must be 1");
+    const o = U(e.reportContext);
+    if (!o.ok) {
+      const t = o.issues[0];
+      throw new Error(
+        `presentation execution snapshot reportContext is invalid: ${t != null && t.path && t.path !== "$" ? `${t.path}: ` : ""}${(t == null ? void 0 : t.message) ?? "invalid value"}`
+      );
+    }
+    return {
+      version: 1,
+      reportContext: o.value,
+      resolvedFormats: ne(e.resolvedFormats)
+    };
+  } catch (o) {
+    throw o instanceof $ ? o : new $(
+      o instanceof Error ? o.message : "Snapshot is invalid."
+    );
+  }
+}
+function Ke(e) {
+  return ie({
+    version: 1,
+    reportContext: e.reportContext,
+    resolvedFormats: [...e.resolvedFormats]
+  });
+}
+function je(e) {
+  const o = se(e);
+  return O(o) ? o : void 0;
+}
+function se(e) {
+  const o = e.snapshot.resolvedFormats.find(
+    (t) => t.format.type !== "temporal_bucket" && t.format.type !== "raw_temporal" && A(t.scope, e.scope) && R(t.target, e.target)
+  );
+  return o == null ? void 0 : o.format;
+}
+function Me(e) {
+  const o = e.snapshot.resolvedFormats.find(
+    (t) => t.format.type === "raw_temporal" && A(t.scope, e.scope) && R(t.target, e.target)
+  );
+  return o == null ? void 0 : o.format;
+}
+function Fe(e) {
+  const o = e.snapshot.resolvedFormats.find(
+    (t) => t.format.type === "temporal_bucket" && A(t.scope, e.scope) && R(t.target, e.target)
+  );
+  return o == null ? void 0 : o.format;
+}
+function Te(e) {
+  var n;
+  const o = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set();
+  if (e.snapshot.resolvedFormats.forEach((i, s) => {
+    if (i.scope.attachmentIndex !== void 0)
+      throw new Error(
+        `resolvedFormats.${s}.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.${s}.scope must match the executing dashboard/card`
+      );
+    if (i.target.kind === "field" && i.format.type === "temporal_bucket") {
+      const c = JSON.stringify(k(i.target));
+      if (t.has(c))
+        throw new Error(
+          `resolvedFormats.${s} duplicates export field "${i.target.fieldId}"`
+        );
+      t.add(c);
+      return;
+    }
+    if (i.target.kind !== "column")
+      throw new Error(
+        `resolvedFormats.${s}.target must identify an export column or temporal pivot field`
+      );
+    if (o.has(i.target.columnKey))
+      throw new Error(
+        `resolvedFormats.${s} duplicates export column "${i.target.columnKey}"`
+      );
+    o.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 r = e.visibleColumns.find(
+    (i) => !o.has(i)
+  );
+  if (r)
+    throw new Error(
+      `resolvedFormats is missing visible export column "${r}"`
+    );
+}
+function b(e) {
+  return Array.from(
+    new Set(
+      (e ?? []).flatMap(
+        (o) => typeof o.id == "string" && o.id ? [o.id] : []
+      )
+    )
+  );
+}
+function ae(e) {
+  const o = /* @__PURE__ */ new Map();
+  return e.forEach((t) => {
+    t.id && o.set(t.id, (o.get(t.id) ?? 0) + 1);
+  }), e.flatMap(
+    (t) => t.id && (o.get(t.id) ?? 0) > 1 ? [B(t)] : []
+  );
+}
+function Pe(e) {
+  const o = e.metricFields ?? [], t = b(o);
+  return {
+    expectedRoleFieldIds: {
+      groupby: b(e.groupByFields),
+      metric: t.length > 0 ? t : [N],
+      pivotby: b(e.pivotByFields),
+      detail: b(e.detailFields)
+    },
+    expectedMetricAliases: ae(o)
+  };
+}
+class a extends Error {
+  constructor(t, r) {
+    super(`invalid_pivot_result_lifecycle: ${t}`);
+    u(this, "code", "invalid_pivot_result_lifecycle");
+    u(this, "deliveryBlocking", !0);
+    this.cause = r, this.name = "PivotResultLifecycleError";
+  }
+}
+function ce(e) {
+  if (!Array.isArray(e) || e.some(
+    (t) => !t || typeof t != "object" || Array.isArray(t) || typeof t.key != "string" || !t.key || typeof t.name != "string" || typeof t.label != "string"
+  ))
+    throw new a(
+      "Canonical pivot columns must be an array of keyed, named result descriptors."
+    );
+  const o = e;
+  if (new Set(o.map((t) => t.key)).size !== o.length)
+    throw new a(
+      "Canonical pivot column keys must be unique."
+    );
+  for (const t of o) {
+    const r = z(t, {
+      metadataRequired: !1
+    });
+    if (!r.ok)
+      throw new a(
+        `Canonical pivot column "${t.key}" has invalid temporal metadata: ${r.error.message}`
+      );
+  }
+  return o;
+}
+function _(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 a(
+      "A loaded canonical pivot result requires its role-scoped column key map."
+    );
+  const o = e, t = /* @__PURE__ */ new Set(["groupby", "metric", "pivotby", "detail"]);
+  for (const [r, n] of Object.entries(o.byRole)) {
+    if (!t.has(r) || !n || typeof n != "object" || Array.isArray(n))
+      throw new a(
+        `Canonical pivot role map contains invalid "${r}" bindings.`
+      );
+    for (const [i, s] of Object.entries(n))
+      if (!i || !s || typeof s != "object" || Array.isArray(s) || s.role !== r || typeof s.rawKey != "string" || !s.rawKey || s.outputKey !== void 0 && (typeof s.outputKey != "string" || !s.outputKey))
+        throw new a(
+          `Canonical pivot role map contains an invalid "${r}:${i}" binding.`
+        );
+  }
+  if (o.byMetricAlias !== void 0) {
+    if (!o.byMetricAlias || typeof o.byMetricAlias != "object" || Array.isArray(o.byMetricAlias))
+      throw new a(
+        "Canonical pivot metric-alias bindings must be an object."
+      );
+    for (const [r, n] of Object.entries(
+      o.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 a(
+          `Canonical pivot metric-alias map contains an invalid "${r}" binding.`
+        );
+  }
+  return o;
+}
+function le(e) {
+  if (e === void 0) return {};
+  if (!e || typeof e != "object" || Array.isArray(e))
+    throw new a(
+      "Canonical pivot column metadata must be an object."
+    );
+  for (const [o, t] of Object.entries(e)) {
+    if (!o || !t || typeof t != "object" || Array.isArray(t))
+      throw new a(
+        `Canonical pivot column metadata contains an invalid "${o}" classification.`
+      );
+    const { isSubtotal: r, subtotalScope: n } = t;
+    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 a(
+        `Canonical pivot column metadata contains an incoherent "${o}" subtotal classification.`
+      );
+  }
+  return e;
+}
+function C(e, o) {
+  if (!Array.isArray(e) || e.some((t) => typeof t != "string" || !t) || new Set(e).size !== e.length)
+    throw new a(
+      `Canonical pivot contract ${o} must be an array of unique field identities.`
+    );
+  return e;
+}
+function de(e, o) {
+  if (!e || typeof e != "object" || Array.isArray(e) || e.version !== 1)
+    throw new a(
+      "A canonical pivot result requires its versioned result contract."
+    );
+  const t = e, r = t.expectedRoleFieldIds;
+  if (!r || typeof r != "object" || Array.isArray(r))
+    throw new a(
+      "Canonical pivot contract role identities must be an object."
+    );
+  const i = Object.fromEntries(
+    [
+      "groupby",
+      "metric",
+      "pivotby",
+      "detail"
+    ].map((m) => [
+      m,
+      C(
+        r[m],
+        `expectedRoleFieldIds.${m}`
+      )
+    ])
+  ), s = C(
+    t.expectedMetricAliases,
+    "expectedMetricAliases"
+  ), c = t.columnKinds;
+  if (!c || typeof c != "object" || Array.isArray(c))
+    throw new a(
+      "Canonical pivot contract column kinds must be an object."
+    );
+  const f = /* @__PURE__ */ new Set([
+    "row",
+    "pivot_metric",
+    "value"
+  ]), y = o.map((m) => m.key), d = Object.keys(c);
+  if (d.length !== y.length || d.some(
+    (m) => !y.includes(m) || !f.has(
+      c[m]
+    )
+  ))
+    throw new a(
+      "Canonical pivot contract must classify every authoritative result column exactly once."
+    );
+  const E = le(
+    t.columnClassifications
+  );
+  if (Object.keys(E).some(
+    (m) => !y.includes(m)
+  ))
+    throw new a(
+      "Canonical pivot contract contains a classification for an unknown result column."
+    );
+  return {
+    version: 1,
+    expectedRoleFieldIds: i,
+    expectedMetricAliases: s,
+    columnKinds: c,
+    columnClassifications: E
+  };
+}
+function K(e, o) {
+  const t = [
+    "groupby",
+    "metric",
+    "pivotby",
+    "detail"
+  ];
+  for (const i of t) {
+    const s = new Set(o.expectedRoleFieldIds[i] ?? []), c = Object.keys(e.byRole[i] ?? {});
+    if (c.length !== s.size || c.some((f) => !s.has(f)))
+      throw new a(
+        `The role-scoped ${i} bindings do not match the authored result fields.`
+      );
+  }
+  const r = new Set(o.expectedMetricAliases), n = Object.keys(e.byMetricAlias ?? {});
+  if (n.length !== r.size || n.some((i) => !r.has(i)))
+    throw new a(
+      "The metric-alias bindings do not match the authored metric instances."
+    );
+}
+function me(e) {
+  if (!Array.isArray(e) || e.some(
+    (o) => !o || typeof o != "object" || Array.isArray(o)
+  ))
+    throw new a(
+      "Canonical pivot records must be an array of row objects."
+    );
+  return e;
+}
+function fe(e, o) {
+  e.forEach((t, r) => {
+    o.forEach((n) => {
+      if (!Object.prototype.hasOwnProperty.call(t, n.key) || t[n.key] === void 0)
+        throw new a(
+          `Canonical pivot column "${n.key}" is absent from row ${r}.`
+        );
+    });
+  });
+}
+function ue(e, o, t) {
+  const r = new Set(o.map((n) => n.key));
+  ["groupby", "detail"].forEach((n) => {
+    Object.entries(e.byRole[n] ?? {}).forEach(
+      ([i, s]) => {
+        const c = s.outputKey || s.rawKey;
+        if (!r.has(c) || t.columnKinds[c] !== "row")
+          throw new a(
+            `The role-scoped ${n} binding for "${i}" does not name an authoritative result column.`
+          );
+      }
+    );
+  });
+}
+function j(e, o) {
+  o.forEach((t) => {
+    const r = e.columnKinds[t.key];
+    if (r === "pivot_metric" && t.pivotIdentity === void 0)
+      throw new a(
+        `Physical pivot result column "${t.key}" is missing its identity.`
+      );
+    if (r !== "pivot_metric" && t.pivotIdentity !== void 0)
+      throw new a(
+        `Canonical pivot result column "${t.key}" carries pivot identity outside the physical pivot projection.`
+      );
+  });
+}
+function pe(e) {
+  const o = me(e.records), t = ce(e.columns), r = de(
+    e.pivotResultContract,
+    t
+  ), n = r.expectedRoleFieldIds.pivotby ?? [];
+  if (e.pivotResultState === "loaded_empty") {
+    if (o.length !== 0)
+      throw new a(
+        "A loaded_empty pivot result cannot carry records."
+      );
+    if (t.some(
+      (f) => r.columnKinds[f.key] === "pivot_metric"
+    ))
+      throw new a(
+        "A loaded_empty pivot result cannot carry physical pivot columns."
+      );
+    j(r, t);
+    const c = _(e.columnKeyMap);
+    return K(c, r), {
+      pivotResultState: "loaded_empty",
+      records: [],
+      columns: t,
+      columnKeyMap: c,
+      pivotResultContract: r
+    };
+  }
+  if (e.pivotResultState !== "loaded_valid")
+    throw new a(
+      "A canonical pivot result must declare loaded_empty or loaded_valid."
+    );
+  if (o.length === 0)
+    throw new a(
+      "A loaded_valid pivot result must carry at least one record."
+    );
+  const i = _(e.columnKeyMap);
+  K(i, r), ue(i, t, r), j(r, t);
+  const s = t.filter(
+    (c) => r.columnKinds[c.key] === "pivot_metric"
+  );
+  if (n.length > 0 && s.length === 0)
+    throw new a(
+      "A loaded_valid pivot result is missing its physical pivot columns."
+    );
+  try {
+    D(s, {
+      expectedPivotFieldIds: n,
+      columnClassifications: r.columnClassifications
+    });
+  } catch (c) {
+    throw c instanceof J ? new a(c.message, c) : c;
+  }
+  return fe(o, t), {
+    pivotResultState: "loaded_valid",
+    records: o,
+    columns: t,
+    columnKeyMap: i,
+    pivotResultContract: r
+  };
+}
+function Oe(e) {
+  const o = /* @__PURE__ */ new Set();
+  ["groupby", "detail"].forEach((i) => {
+    Object.values(e.columnKeyMap.byRole[i] ?? {}).forEach((s) => {
+      o.add(s.outputKey || s.rawKey);
+    });
+  });
+  const t = new Set(e.physicalPivotColumnKeys), r = 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,
+        o.has(i.key) ? "row" : t.has(i.key) ? "pivot_metric" : "value"
+      ])
+    ),
+    columnClassifications: Object.fromEntries(
+      Object.entries(e.columnMetadata ?? {}).filter(
+        ([i]) => r.has(i)
+      )
+    )
+  };
+  return pe({
+    pivotResultState: e.records.length === 0 ? "loaded_empty" : "loaded_valid",
+    pivotResultContract: n,
+    records: e.records,
+    columns: e.columns,
+    columnKeyMap: e.columnKeyMap
+  });
+}
+export {
+  X as M,
+  $ as P,
+  Ee as a,
+  $e as b,
+  V as c,
+  Y as d,
+  Se as e,
+  se as f,
+  H as g,
+  _e as h,
+  Ce as i,
+  Q as j,
+  ne as k,
+  ie as l,
+  x as m,
+  Ke as n,
+  je as o,
+  v as p,
+  Me as q,
+  Fe as r,
+  ae as s,
+  Pe as t,
+  a as u,
+  Te as v,
+  pe as w,
+  Oe as x
+};