react-semaphor 0.1.468 → 0.1.470

package/dist/chunks/matrix-result-contract-DoU9diAh.js

@@ -0,0 +1,822 @@
+var P = Object.defineProperty;
+var R = (e, t, a) => t in e ? P(e, t, { enumerable: !0, configurable: !0, writable: !0, value: a }) : e[t] = a;
+var g = (e, t, a) => R(e, typeof t != "symbol" ? t + "" : t, a);
+import { p as j } from "./temporal-bucket-CUKJktCl.js";
+import { a6 as K } from "./validators-B5t1s8oh.js";
+import { v as O } from "./temporal-bucket-contract-Cno9TlYr.js";
+function w(e) {
+  const t = E(e);
+  return t.length > 0 ? t.join(".") : void 0;
+}
+function q(e) {
+  const t = w(
+    e.qualifiedName
+  ), a = (t == null ? void 0 : t.split(".")) || [];
+  if (a.length === 0) return {};
+  const r = {};
+  let s = a.length - 1;
+  for (let i = e.capabilities.prefixLevels.length - 1; i >= 0 && s >= 0; i -= 1, s -= 1)
+    A(
+      r,
+      e.capabilities.prefixLevels[i],
+      a[s]
+    );
+  return r;
+}
+function $(e) {
+  return !e.left.tableName || !e.right.tableName ? !1 : e.capabilities.prefixLevels.every((t) => {
+    const a = p(e.left, t), r = p(e.right, t);
+    return !a || !r || a === r;
+  });
+}
+function ce(e) {
+  return e.capabilities.prefixLevels.every((t) => {
+    const a = p(e.requested, t);
+    return a ? p(e.allowed, t) === a : !0;
+  });
+}
+function v(e, t = {}) {
+  const a = T(e), r = {
+    connectionId: t.connectionId,
+    connectionType: e,
+    path: ["database", "schema", "table"],
+    labels: {
+      database: "Database",
+      schema: "Schema",
+      table: "Table"
+    },
+    prefixLevels: ["database", "schema", "table"],
+    dialect: "postgres",
+    supportsFilterClause: !0
+  };
+  return a.includes("postgres") ? {
+    ...r,
+    prefixLevels: ["schema", "table"],
+    dialect: "postgres"
+  } : a.includes("mysql") ? {
+    ...r,
+    prefixLevels: ["database", "table"],
+    dialect: "mysql",
+    supportsFilterClause: !1
+  } : a.includes("mssql") || a.includes("sqlserver") ? {
+    ...r,
+    dialect: "mssql",
+    supportsFilterClause: !1
+  } : a.includes("redshift") ? {
+    ...r,
+    prefixLevels: ["schema", "table"],
+    dialect: "redshift"
+  } : a.includes("snowflake") ? {
+    ...r,
+    dialect: "snowflake"
+  } : a.includes("clickhouse") ? {
+    connectionId: t.connectionId,
+    connectionType: e,
+    path: ["database", "table"],
+    labels: {
+      database: "Database",
+      table: "Table"
+    },
+    prefixLevels: ["database", "table"],
+    dialect: "clickhouse",
+    supportsFilterClause: !1
+  } : a === "s3" || a === "api" ? {
+    connectionId: t.connectionId,
+    connectionType: e,
+    path: ["table"],
+    labels: {
+      table: a === "api" ? "API Table" : "File Table"
+    },
+    prefixLevels: ["table"],
+    dialect: "duckdb",
+    supportsFilterClause: !0
+  } : a === "googlesheets" || a === "fileupload" ? {
+    connectionId: t.connectionId,
+    connectionType: e,
+    path: ["table"],
+    labels: {
+      table: "Table"
+    },
+    prefixLevels: ["table"],
+    dialect: "postgres",
+    supportsFilterClause: !0
+  } : a === "s3tables" ? {
+    ...r,
+    labels: {
+      database: "Database",
+      schema: "Namespace",
+      table: "Table"
+    },
+    dialect: "duckdb"
+  } : a === "bigquery" ? {
+    ...r,
+    labels: {
+      database: "Project",
+      schema: "Dataset",
+      table: "Table"
+    },
+    prefixLevels: ["schema", "table"],
+    dialect: "bigquery",
+    supportsFilterClause: !1
+  } : r;
+}
+function de(e) {
+  const t = T(e);
+  switch (t) {
+    case "mysql":
+    case "bigquery":
+    case "redshift":
+    case "snowflake":
+    case "clickhouse":
+    case "duckdb":
+    case "sqlite":
+      return t;
+    case "mssql":
+    case "sqlserver":
+      return "mssql";
+    case "postgres":
+    case "postgresql":
+      return "postgres";
+    default:
+      return "unknown";
+  }
+}
+function ue(e) {
+  return e.capabilities.prefixLevels.every(
+    (t) => !!p(e.source, t)
+  );
+}
+function fe(e) {
+  const t = e.quoteIdentifier ?? F;
+  return e.capabilities.prefixLevels.map((a) => p(e.source, a)).filter((a) => !!a).map((a) => t(a, e.capabilities.dialect)).join(".");
+}
+function p(e, t) {
+  return t === "database" ? e.databaseName : t === "schema" ? e.schemaName : e.tableName;
+}
+function A(e, t, a) {
+  t === "database" ? e.databaseName = a : t === "schema" ? e.schemaName = a : e.tableName = a;
+}
+function E(e) {
+  const t = e == null ? void 0 : e.trim();
+  if (!t) return [];
+  const a = t.split(".").map((r) => {
+    const s = r.trim();
+    return s.length >= 2 && s.startsWith('"') && s.endsWith('"') ? s.slice(1, -1) : s;
+  });
+  return a.some((r) => !r) ? [] : a;
+}
+function F(e, t) {
+  return t === "mysql" || t === "bigquery" || t === "clickhouse" || t === "duckdb" ? `\`${e.replace(/`/g, "``")}\`` : t === "mssql" ? `[${e.replace(/]/g, "]]")}]` : `"${e.replace(/"/g, '""')}"`;
+}
+function T(e) {
+  if (typeof e != "string")
+    return "";
+  const t = [];
+  for (const a of e.trim().toLowerCase())
+    V(a) && t.push(a);
+  return t.join("");
+}
+function V(e) {
+  const t = e.charCodeAt(0);
+  return t >= 48 && t <= 57 || t >= 97 && t <= 122;
+}
+function m(e) {
+  return typeof e == "string" && e.trim() ? e.trim() : void 0;
+}
+function I(e) {
+  return e && typeof e == "object" && !Array.isArray(e) ? e : void 0;
+}
+function G(e) {
+  const t = I(e);
+  return !t || !m(t.name) || t.type === "model" ? !1 : t.type === "dataset" ? t.datasetType === "physical" : !0;
+}
+function y(e) {
+  const t = I(e);
+  if (!t) return {};
+  const a = m(t.table) || m(t.name);
+  return {
+    ...m(t.database) ? { databaseName: m(t.database) } : {},
+    ...m(t.schema) ? { schemaName: m(t.schema) } : {},
+    ...a ? { tableName: a } : {}
+  };
+}
+function me(e) {
+  const t = e.entities.filter(G), a = Q(e), r = z({
+    entities: t,
+    connectionType: e.connectionType
+  });
+  if (!r) return { kind: "incompatible_capabilities" };
+  const s = D({
+    hints: e.qualifiedHints || [],
+    coordinateHint: e.coordinateHint,
+    capabilities: r
+  });
+  if (s.kind !== "valid")
+    return { kind: s.kind };
+  const i = s.coordinates, n = i ? t.filter(
+    (c) => $({
+      left: y(c),
+      right: i,
+      capabilities: r
+    })
+  ) : t;
+  if (i && n.length === 0)
+    return {
+      kind: "not_found",
+      basis: "qualified",
+      coordinates: i
+    };
+  if (i && n.length === 1) {
+    const c = n[0];
+    return {
+      kind: "resolved",
+      basis: "qualified",
+      entity: c,
+      coordinates: Y(
+        y(c),
+        i
+      )
+    };
+  }
+  const l = N([
+    ...e.bareHints || [],
+    ...s.bareHints,
+    i == null ? void 0 : i.tableName
+  ]);
+  if (l.size > 0) {
+    const c = n.filter((u) => {
+      const h = X(u);
+      return Array.from(l).some((d) => h.has(d));
+    });
+    if (c.length === 1) {
+      const u = c[0];
+      return {
+        kind: "resolved",
+        basis: "bare",
+        entity: u,
+        coordinates: y(u)
+      };
+    }
+    return c.length > 1 ? { kind: "ambiguous", basis: "bare" } : { kind: "not_found", basis: "bare" };
+  }
+  if (i)
+    return { kind: "ambiguous", basis: "qualified" };
+  if (a)
+    return { kind: "not_found", basis: a };
+  if (t.length === 1) {
+    const c = t[0];
+    return {
+      kind: "resolved",
+      basis: "unqualified",
+      entity: c,
+      coordinates: y(c)
+    };
+  }
+  return { kind: "unqualified" };
+}
+function Q(e) {
+  const t = (e.qualifiedHints || []).map(m).filter((r) => !!r);
+  return Object.values(e.coordinateHint || {}).some(
+    (r) => !!m(r)
+  ) || t.some((r) => r.includes(".")) ? "qualified" : [...t, ...e.bareHints || []].some(
+    (r) => !!m(r)
+  ) ? "bare" : void 0;
+}
+function z(e) {
+  var r;
+  const t = m(e.connectionType);
+  if (t)
+    return v(t);
+  const a = e.entities.flatMap((s) => {
+    var l;
+    const i = m((l = I(s)) == null ? void 0 : l.connectionType);
+    if (!i) return [];
+    const n = v(i);
+    return [
+      {
+        capabilities: n,
+        signature: `${n.dialect}:${n.prefixLevels.join(".")}`
+      }
+    ];
+  });
+  if (!(new Set(a.map((s) => s.signature)).size > 1))
+    return ((r = a[0]) == null ? void 0 : r.capabilities) || v(void 0);
+}
+function D(e) {
+  const t = [], a = [];
+  for (const u of e.hints) {
+    const h = m(u);
+    if (!h) continue;
+    if (!h.includes(".")) {
+      a.push(h);
+      continue;
+    }
+    const d = w(h);
+    if (!d) return { kind: "malformed" };
+    t.push(d);
+  }
+  const r = J(e.coordinateHint);
+  if (r.kind === "malformed") return r;
+  const s = Array.from(new Set(t)).map(
+    (u) => q({
+      qualifiedName: u,
+      capabilities: e.capabilities
+    })
+  );
+  if (!U(s, e.capabilities))
+    return { kind: "conflicting" };
+  const i = [...new Set(t)].sort(
+    (u, h) => h.split(".").length - u.split(".").length
+  )[0], n = i ? q({
+    qualifiedName: i,
+    capabilities: e.capabilities
+  }) : void 0, l = W(
+    r.coordinates,
+    e.capabilities
+  ), c = !!(l.tableName && (l.databaseName || l.schemaName));
+  return n && c && !$({
+    left: n,
+    right: l,
+    capabilities: e.capabilities
+  }) ? { kind: "conflicting" } : {
+    kind: "valid",
+    coordinates: n ? c ? { ...n, ...l } : n : c ? l : void 0,
+    bareHints: [
+      ...a,
+      ...!c && l.tableName ? [l.tableName] : []
+    ]
+  };
+}
+function J(e) {
+  const t = {};
+  for (const [a, r] of Object.entries(e || {})) {
+    const s = m(r);
+    if (!s) continue;
+    const i = w(s);
+    if (!i) return { kind: "malformed" };
+    t[a] = i;
+  }
+  return { kind: "valid", coordinates: t };
+}
+function W(e, t) {
+  return {
+    ...t.prefixLevels.includes("database") && e.databaseName ? { databaseName: e.databaseName } : {},
+    ...t.prefixLevels.includes("schema") && e.schemaName ? { schemaName: e.schemaName } : {},
+    ...e.tableName ? { tableName: e.tableName } : {}
+  };
+}
+function U(e, t) {
+  return e.every(
+    (a, r) => e.slice(r + 1).every(
+      (s) => $({
+        left: a,
+        right: s,
+        capabilities: t
+      })
+    )
+  );
+}
+function N(e) {
+  return new Set(
+    e.map(m).map(w).filter((t) => !!t)
+  );
+}
+function X(e) {
+  const t = I(e);
+  return t ? N([
+    m(t.name),
+    m(t.table),
+    m(t.id)
+  ]) : /* @__PURE__ */ new Set();
+}
+function Y(e, t) {
+  return {
+    ...t,
+    ...e
+  };
+}
+class H extends Error {
+  constructor(a) {
+    super(a.message);
+    g(this, "code");
+    g(this, "path");
+    this.name = "MatrixResultContractError", this.code = a.code, this.path = a.path;
+  }
+}
+function he(e) {
+  var c, u, h;
+  const t = ie(e);
+  if (t !== 2)
+    throw new H({
+      code: "unsupported_matrix_result_version",
+      message: `Canonical Matrix results require schemaVersion 2; received ${String(t)}.`,
+      path: "schemaVersion"
+    });
+  const a = K.safeParse(e);
+  if (!a.success) {
+    const d = a.error.issues[0];
+    throw o(
+      (d == null ? void 0 : d.message) || "Canonical Matrix result has an invalid shape.",
+      d == null ? void 0 : d.path.join(".")
+    );
+  }
+  const r = a.data, s = {
+    row: S(r.axes.rows.levels, "axes.rows.levels"),
+    column: S(
+      r.axes.columns.levels,
+      "axes.columns.levels"
+    )
+  };
+  re(r), B(r, "row"), B(r, "column");
+  const i = /* @__PURE__ */ new Set([
+    ...r.axes.rows.nodeIds,
+    ...r.axes.columns.nodeIds
+  ]), n = /* @__PURE__ */ new Set();
+  for (const [d, f] of Object.entries(r.nodesById)) {
+    if (f.id !== d)
+      throw o(
+        "Matrix node directory key must equal node.id.",
+        `nodesById.${d}.id`
+      );
+    if (!i.has(d))
+      throw o(
+        "Matrix node directory cannot contain nodes omitted from both axes.",
+        `nodesById.${d}`
+      );
+    Z(f, s[f.axis], `nodesById.${d}`);
+    const b = JSON.stringify([
+      f.axis,
+      f.path,
+      f.isSubtotal === !0,
+      f.isGrandTotal === !0
+    ]);
+    if (n.has(b))
+      throw o(
+        "Matrix nodes must have unique canonical path and total-role identity.",
+        `nodesById.${d}`
+      );
+    n.add(b), ae(r, f, `nodesById.${d}`);
+  }
+  const l = /* @__PURE__ */ new Set();
+  for (const [d, f] of r.cells.entries()) {
+    if (!((c = r.nodesById[f.rowId]) != null && c.axis) || ((u = r.nodesById[f.rowId]) == null ? void 0 : u.axis) !== "row")
+      throw o(
+        "Matrix cell rowId must reference a row node.",
+        `cells.${d}.rowId`
+      );
+    if (f.columnId && ((h = r.nodesById[f.columnId]) == null ? void 0 : h.axis) !== "column")
+      throw o(
+        "Matrix cell columnId must reference a column node.",
+        `cells.${d}.columnId`
+      );
+    if (!r.measuresById[f.measureId])
+      throw o(
+        "Matrix cell measureId must reference a measure.",
+        `cells.${d}.measureId`
+      );
+    const b = ee(
+      r.nodesById[f.rowId],
+      f.columnId ? r.nodesById[f.columnId] : void 0
+    );
+    if (f.role !== b)
+      throw o(
+        "Matrix cell role must match its referenced row and column total roles.",
+        `cells.${d}.role`
+      );
+    const k = JSON.stringify([
+      f.rowId,
+      f.columnId ?? null,
+      f.measureId
+    ]);
+    if (l.has(k))
+      throw o(
+        "Matrix result cannot contain duplicate physical cell addresses.",
+        `cells.${d}`
+      );
+    l.add(k);
+  }
+  return te(r, s), r;
+}
+function S(e, t) {
+  var r;
+  const a = /* @__PURE__ */ new Map();
+  for (const [s, i] of e.entries()) {
+    const n = `${t}.${s}`;
+    if (a.has(i.instanceId))
+      throw o(
+        "Matrix axis level ids must be unique.",
+        `${n}.instanceId`
+      );
+    a.set(i.instanceId, i);
+    const l = i.field.role === "date" || i.field.dataType === "date" || i.field.dataType === "datetime", c = i.field.dataType === "string" || i.field.dataType === "number" || i.field.dataType === "boolean";
+    if (l && !i.grain)
+      throw o(
+        "Temporal Matrix axis level is missing its explicit grain.",
+        `${n}.grain`
+      );
+    if (c && i.grain)
+      throw o(
+        "Non-temporal Matrix axis level cannot carry a grain.",
+        `${n}.grain`
+      );
+    if (i.grain) {
+      if (!i.temporalBucket)
+        throw o(
+          "Temporal Matrix axis level is missing governed bucket metadata.",
+          `${n}.temporalBucket`
+        );
+      const u = O(i.temporalBucket);
+      if (!u.ok || ((r = u.value) == null ? void 0 : r.granularity) !== i.grain)
+        throw o(
+          "Matrix axis grain and temporal metadata must agree.",
+          `${n}.temporalBucket`
+        );
+    } else if (i.temporalBucket)
+      throw o(
+        "Non-temporal Matrix axis levels cannot carry temporal bucket metadata.",
+        n
+      );
+  }
+  return a;
+}
+function B(e, t) {
+  var s;
+  const a = t === "row" ? e.axes.rows : e.axes.columns, r = /* @__PURE__ */ new Set();
+  for (const [i, n] of a.nodeIds.entries()) {
+    if (r.has(n))
+      throw o(
+        "Matrix axis node ids must be unique.",
+        `axes.${t === "row" ? "rows" : "columns"}.nodeIds.${i}`
+      );
+    if (r.add(n), ((s = e.nodesById[n]) == null ? void 0 : s.axis) !== t)
+      throw o(
+        "Matrix axis node id references the wrong axis.",
+        `axes.${t === "row" ? "rows" : "columns"}.nodeIds.${i}`
+      );
+  }
+}
+function Z(e, t, a) {
+  if (e.isGrandTotal) {
+    if (e.isSubtotal)
+      throw o(
+        "Matrix nodes cannot be both subtotal and grand total.",
+        a
+      );
+    if (e.path.length !== 0)
+      throw o(
+        "Matrix grand-total nodes must have an empty member path.",
+        `${a}.path`
+      );
+    return;
+  }
+  if (!e.path.length || e.level !== e.path.length - 1)
+    throw o(
+      "Ordinary and subtotal Matrix nodes require a level-aligned non-empty path.",
+      a
+    );
+  const r = [...t.values()];
+  if (e.path.length > r.length)
+    throw o(
+      "Matrix node path exceeds its authored axis depth.",
+      `${a}.path`
+    );
+  if (e.isSubtotal && e.path.length >= r.length)
+    throw o(
+      "Matrix subtotal nodes must identify a proper authored-axis prefix.",
+      `${a}.path`
+    );
+  e.path.forEach((l, c) => {
+    const u = r[c];
+    if (l.instanceId === "__matrix_remaining__" && l.fieldKey === "__matrix_remaining__" && l.value === "__matrix_remaining__") {
+      if (c !== e.path.length - 1)
+        throw o(
+          "Matrix remaining-member identity must be the terminal path segment.",
+          `${a}.path.${c}`
+        );
+      if (typeof l.label != "string")
+        throw o(
+          "Matrix remaining-member paths require their explicit display label.",
+          `${a}.path.${c}.label`
+        );
+      return;
+    }
+    if (!u || l.instanceId !== u.instanceId || l.fieldKey !== u.fieldKey)
+      throw o(
+        "Matrix member path must follow authored axis order and identity.",
+        `${a}.path.${c}`
+      );
+    L(l, u, `${a}.path.${c}`);
+  });
+  const s = e.path[e.path.length - 1], i = s.instanceId === "__matrix_remaining__" && s.fieldKey === "__matrix_remaining__" && s.value === "__matrix_remaining__";
+  if (!M(e.value, s.value))
+    throw o(
+      "Matrix node value must equal its final canonical path member.",
+      `${a}.value`
+    );
+  const n = r[e.path.length - 1];
+  if (n != null && n.temporalBucket && !e.isSubtotal && !i && e.label !== void 0)
+    throw o(
+      "Temporal Matrix nodes cannot transport display labels.",
+      `${a}.label`
+    );
+  if ((!(n != null && n.temporalBucket) || i) && typeof e.label != "string")
+    throw o(
+      "Non-temporal Matrix nodes require a display label.",
+      `${a}.label`
+    );
+}
+function ee(e, t) {
+  return e.isGrandTotal && (t != null && t.isGrandTotal) ? "matrixGrandTotal" : e.isGrandTotal ? "rowGrandTotal" : t != null && t.isGrandTotal ? "columnGrandTotal" : e.isSubtotal && (t != null && t.isSubtotal) ? "subtotalIntersection" : e.isSubtotal ? "rowSubtotal" : t != null && t.isSubtotal ? "columnSubtotal" : "value";
+}
+function L(e, t, a) {
+  if (t.temporalBucket) {
+    if (e.label !== void 0)
+      throw o(
+        "Temporal Matrix path members cannot transport display labels.",
+        `${a}.label`
+      );
+    if (e.value !== null && typeof e.value != "string")
+      throw o(
+        "Temporal Matrix member values must be canonical strings or null.",
+        `${a}.value`
+      );
+    const r = j(
+      e.value,
+      t.temporalBucket
+    );
+    if (!r.ok)
+      throw o(r.error.message, `${a}.value`);
+  } else if (typeof e.label != "string")
+    throw o(
+      "Non-temporal Matrix path members require a display label.",
+      `${a}.label`
+    );
+}
+function te(e, t) {
+  const a = [...t.row.values()];
+  if (e.layout.rowHeaderLevels.length !== a.length)
+    throw o(
+      "Matrix row-header layout must describe every row-axis level exactly once.",
+      "layout.rowHeaderLevels"
+    );
+  e.layout.rowHeaderLevels.forEach((s, i) => {
+    var n;
+    if (s.fieldInstanceId !== ((n = a[i]) == null ? void 0 : n.instanceId))
+      throw o(
+        "Matrix row-header layout must follow authored row-axis order.",
+        `layout.rowHeaderLevels.${i}.fieldInstanceId`
+      );
+  });
+  for (const [s, i] of e.layout.columnHeaderRows.entries())
+    for (const [n, l] of i.cells.entries()) {
+      if (C(
+        l.columnPath,
+        t.column,
+        `layout.columnHeaderRows.${s}.cells.${n}.columnPath`
+      ), l.measureInstanceId && !e.measuresById[l.measureInstanceId])
+        throw o(
+          "Matrix header measureInstanceId must reference a measure.",
+          `layout.columnHeaderRows.${s}.cells.${n}.measureInstanceId`
+        );
+      if (l.role === "columnHeader" && l.label !== void 0)
+        throw o(
+          "Matrix member headers cannot transport composed display labels.",
+          `layout.columnHeaderRows.${s}.cells.${n}.label`
+        );
+    }
+  const r = /* @__PURE__ */ new Set();
+  for (const [s, i] of e.layout.columns.entries()) {
+    if (r.has(i.id))
+      throw o(
+        "Matrix layout column ids must be unique.",
+        `layout.columns.${s}.id`
+      );
+    if (r.add(i.id), C(
+      i.columnPath,
+      t.column,
+      `layout.columns.${s}.columnPath`
+    ), i.role === "value" && i.columnPath.length > 0 && i.label !== void 0)
+      throw o(
+        "Matrix value columns with member paths cannot transport composed display labels.",
+        `layout.columns.${s}.label`
+      );
+    if (!e.measuresById[i.measureInstanceId])
+      throw o(
+        "Matrix layout column measureInstanceId must reference a measure.",
+        `layout.columns.${s}.measureInstanceId`
+      );
+    if (i.columnNodeId) {
+      const n = e.nodesById[i.columnNodeId];
+      if ((n == null ? void 0 : n.axis) !== "column" || !M(n.path, i.columnPath))
+        throw o(
+          "Matrix layout column must match its referenced column node path.",
+          `layout.columns.${s}.columnNodeId`
+        );
+    } else if (t.column.size > 0)
+      throw o(
+        "Matrix columns with an authored column axis require a columnNodeId.",
+        `layout.columns.${s}.columnNodeId`
+      );
+  }
+}
+function C(e, t, a) {
+  const r = [...t.values()];
+  if (e.length > r.length)
+    throw o(
+      "Matrix layout path exceeds its authored axis depth.",
+      a
+    );
+  e.forEach((s, i) => {
+    const n = r[i];
+    if (!n || s.instanceId !== n.instanceId || s.fieldKey !== n.fieldKey)
+      throw o(
+        "Matrix layout path must follow authored axis order and identity.",
+        `${a}.${i}`
+      );
+    L(s, n, `${a}.${i}`);
+  });
+}
+function ae(e, t, a) {
+  if (!t.parentId) return;
+  const r = e.nodesById[t.parentId];
+  if (!r)
+    throw o(
+      "Matrix parentId must reference an existing node.",
+      `${a}.parentId`
+    );
+  if (r.axis !== t.axis || r.path.length !== t.path.length - 1 || !M(r.path, t.path.slice(0, -1)))
+    throw o(
+      "Matrix parentId must reference the immediate same-axis path prefix.",
+      `${a}.parentId`
+    );
+}
+function re(e) {
+  for (const [t, a] of [
+    ["rows", e.axes.rows],
+    ["columns", e.axes.columns]
+  ]) {
+    const r = t === "rows" ? "row" : "column";
+    a.levels.forEach((s, i) => {
+      const n = e.fieldsById[s.instanceId];
+      if (!n || n.instanceId !== s.instanceId || n.fieldKey !== s.fieldKey || n.role !== r || !_(n.field, s.field))
+        throw o(
+          "Matrix axis level must have one matching role-scoped field descriptor.",
+          `axes.${t}.levels.${i}`
+        );
+    });
+  }
+  for (const [t, a] of Object.entries(e.measuresById)) {
+    if (a.instanceId !== t)
+      throw o(
+        "Matrix measure directory key must equal measure.instanceId.",
+        `measuresById.${t}.instanceId`
+      );
+    const r = e.fieldsById[t];
+    if (!r || r.instanceId !== t || r.fieldKey !== a.fieldKey || r.role !== "measure" || !_(r.field, a.field))
+      throw o(
+        "Matrix measure must have one matching field descriptor.",
+        `measuresById.${t}`
+      );
+  }
+}
+function ie(e) {
+  return e && typeof e == "object" ? e.schemaVersion : void 0;
+}
+function M(e, t) {
+  return JSON.stringify(e) === JSON.stringify(t);
+}
+function _(e, t) {
+  return x(e) === x(t);
+}
+function x(e) {
+  if (Array.isArray(e))
+    return `[${e.map(x).join(",")}]`;
+  if (e && typeof e == "object") {
+    const t = e;
+    return `{${Object.keys(t).filter((a) => t[a] !== void 0).sort().map(
+      (a) => `${JSON.stringify(a)}:${x(t[a])}`
+    ).join(",")}}`;
+  }
+  return e === void 0 ? "undefined" : JSON.stringify(e);
+}
+function o(e, t) {
+  return new H({
+    code: "invalid_matrix_result_contract",
+    message: e,
+    path: t
+  });
+}
+export {
+  H as M,
+  ce as a,
+  ue as b,
+  w as c,
+  fe as d,
+  he as e,
+  v as g,
+  G as i,
+  de as n,
+  q as p,
+  me as r,
+  $ as s
+};