react-semaphor 0.1.526 → 0.1.527

package/dist/chunks/matrix-operation-contract-BV02rLhu.js

@@ -0,0 +1,809 @@
+import { z as e } from "zod";
+import { a5 as p, $ as T, aa as k, bl as E, B as m, a6 as te, bf as x, bm as se, aX as re, a0 as ne, b0 as oe, b1 as ie, b4 as ce, b5 as le, aQ as S, aV as A, aK as ue, a_ as me, a$ as M, aH as de, aG as pe, aW as he, aN as ge, aO as ye, w as z, aS as fe, s as be, q as B, E as Se, A as Ie, m as we } from "./validators-CQcG0EPN.js";
+const j = {
+  answerSummary: "string",
+  responseDetail: "responseDetail",
+  mode: "string",
+  comparisonKind: "string",
+  executionResult: "executionResult",
+  compiledQuery: "unknown",
+  data: "unknown",
+  resultSets: "record",
+  analysisWarnings: "unknownArray",
+  columns: "unknownArray",
+  records: "recordArray",
+  rowCount: "number",
+  rowLimitExceeded: "boolean",
+  output: "string",
+  querySpec: "unknown",
+  metadata: "record",
+  validation: "validationResult",
+  coverage: "coverage",
+  diagnosticFeedback: "diagnosticFeedback",
+  missingFields: "stringArray",
+  warnings: "unknownArray",
+  comparison: "unknown",
+  population: "population",
+  comparisons: "recordArray",
+  fieldsUsed: "compactExecutionFieldArray",
+  primary: "recordArray",
+  contributors: "recordArray",
+  segments: "recordArray",
+  periodChanges: "recordArray",
+  changes: "recordArray",
+  largestNegativeChanges: "recordArray",
+  largestPositiveChanges: "recordArray",
+  drivers: "recordArray",
+  absoluteDeltaDrivers: "recordArray",
+  largestNegativeDrivers: "recordArray",
+  largestPositiveDrivers: "recordArray",
+  periodRows: "recordArray",
+  sql: "unknown",
+  omitted: "stringArray"
+}, ia = Object.freeze({
+  coordinates: 2e4,
+  responseBytes: 5 * 1024 * 1024
+}), y = e.string().uuid(), u = e.string().min(1), ke = e.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+function l(a, t, s) {
+  a.addIssue({ code: "custom", path: t, message: s });
+}
+function h(a, t, s) {
+  new Set(a).size !== a.length && l(t, s, "Duplicate identity.");
+}
+const ve = e.object({
+  id: u,
+  axis: T,
+  parent: p,
+  position: e.union([
+    e.object({ kind: e.literal("first") }).strict(),
+    e.object({ kind: e.enum(["after", "before"]), cursor: u }).strict()
+  ]),
+  size: ke
+}).strict(), P = e.object({
+  paths: e.array(p).readonly(),
+  pageIds: e.array(u).readonly()
+}).strict(), xe = e.object({
+  id: u,
+  rows: P,
+  columns: P,
+  measureIds: e.array(y).min(1).readonly()
+}).strict(), D = e.object({
+  pages: e.array(ve).readonly(),
+  blocks: e.array(xe).readonly()
+}).strict().superRefine((a, t) => {
+  !a.pages.length && !a.blocks.length && l(t, [], "Request at least one page or block."), h(
+    [...a.pages, ...a.blocks].map((s) => s.id),
+    t,
+    []
+  );
+  for (const s of a.blocks) {
+    h(s.measureIds, t, ["blocks", s.id, "measureIds"]);
+    for (const r of ["rows", "columns"])
+      for (const n of s[r].pageIds)
+        a.pages.some(
+          (i) => i.id === n && i.axis === r
+        ) || l(
+          t,
+          ["blocks", s.id, r],
+          "Page reference must name a page on this axis in this operation."
+        );
+  }
+}), ca = e.object({ spec: k, request: D }).strict().superRefine(({ spec: a, request: t }, s) => {
+  for (const r of t.pages)
+    E(
+      a,
+      r.axis,
+      r.parent,
+      s,
+      ["pages", r.id],
+      !0
+    ), r.parent.length >= a[r.axis].length && l(
+      s,
+      ["pages", r.id],
+      "Cannot request children of a leaf or empty axis."
+    );
+  for (const r of t.blocks) {
+    r.measureIds.some((n) => !a.measures.some((i) => i.id === n)) && l(s, ["blocks", r.id], "Unknown block measure.");
+    for (const n of ["rows", "columns"])
+      for (const i of r[n].paths)
+        E(a, n, i, s, ["blocks", r.id, n]);
+  }
+}), Ae = e.object({
+  requestId: u,
+  axis: T,
+  parent: p,
+  members: e.array(e.object({ path: p }).strict()).readonly(),
+  before: u.nullable(),
+  after: u.nullable(),
+  exactCount: e.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional()
+}).strict().superRefine((a, t) => {
+  a.parent.some((r) => r.member.kind === "others") && l(t, ["parent"], "Others has no children.");
+  const s = a.members.filter(
+    ({ path: r }) => {
+      var n;
+      return ((n = r[r.length - 1]) == null ? void 0 : n.member.kind) === "others";
+    }
+  );
+  s.length > 1 && l(t, ["members"], "A page may contain Others only once."), s.length && (a.members[a.members.length - 1] !== s[0] && l(t, ["members"], "Others must be the last page member."), a.after !== null && l(t, ["after"], "Others must end the branch.")), new Set(
+    a.members.map(
+      (r) => {
+        var n;
+        return (n = r.path[r.path.length - 1]) == null ? void 0 : n.levelId;
+      }
+    )
+  ).size > 1 && l(t, ["members"], "One page must contain one child level."), h(
+    a.members.map((r) => m(r.path)),
+    t,
+    ["members"]
+  );
+  for (const r of a.members)
+    (r.path.length !== a.parent.length + 1 || m(r.path.slice(0, -1)) !== m(a.parent)) && l(t, ["members"], "Page members must be immediate children.");
+}), L = e.object({
+  rowPaths: e.array(p).readonly(),
+  columnPaths: e.array(p).readonly(),
+  measureIds: e.array(y).readonly()
+}).strict();
+function W(a, t) {
+  const s = a.rowPaths.map(m), r = a.columnPaths.map(m);
+  return h(s, t, ["coverage", "rowPaths"]), h(r, t, ["coverage", "columnPaths"]), h(a.measureIds, t, ["coverage", "measureIds"]), { rows: s, columns: r };
+}
+const je = e.object({
+  requestId: u,
+  coverage: L,
+  cells: e.array(
+    te.extend({ value: x }).strict()
+  ).readonly()
+}).strict().superRefine((a, t) => {
+  const { rows: s, columns: r } = W(a.coverage, t), n = new Set(s), i = new Set(r), o = new Set(a.coverage.measureIds);
+  h(
+    a.cells.map(
+      (c) => JSON.stringify([
+        m(c.rowPath),
+        m(c.columnPath),
+        c.measureId
+      ])
+    ),
+    t,
+    ["cells"]
+  );
+  for (const c of a.cells)
+    (!n.has(m(c.rowPath)) || !i.has(m(c.columnPath)) || !o.has(c.measureId)) && l(t, ["cells"], "Cell is outside certified coverage.");
+}), I = e.number().int().nonnegative(), Re = e.object({
+  requestId: u,
+  coverage: L,
+  values: e.array(
+    e.tuple([I, I, I, x]).readonly()
+  ).readonly()
+}).strict().superRefine((a, t) => {
+  W(a.coverage, t);
+  const { rowPaths: s, columnPaths: r, measureIds: n } = a.coverage, i = /* @__PURE__ */ new Set();
+  for (const [o, c, d] of a.values) {
+    if (o >= s.length || c >= r.length || d >= n.length) {
+      l(t, ["values"], "Cell is outside certified coverage.");
+      continue;
+    }
+    const g = `${o},${c},${d}`;
+    i.has(g) && l(t, ["values"], "Duplicate identity."), i.add(g);
+  }
+}), _ = e.object({
+  id: y,
+  column: re,
+  nativeDataType: u,
+  semanticFormat: se.optional()
+}).strict(), K = e.object({
+  levels: e.array(_).readonly(),
+  measures: e.array(_).readonly()
+}).strict(), R = e.object({
+  code: e.enum([
+    "invalid_request",
+    "unsupported_capability",
+    "stale_cursor",
+    "forbidden",
+    "budget_exceeded",
+    "source_truncated",
+    "execution_failed",
+    "cancelled"
+  ]),
+  message: u,
+  /** Technical cause for dashboard owners; never shown as the primary copy. */
+  detail: u.optional(),
+  retryable: e.boolean(),
+  scope: e.union([
+    e.object({ kind: e.literal("operation") }).strict(),
+    e.object({ kind: e.enum(["page", "block"]), requestId: u }).strict()
+  ])
+}).strict(), Ce = e.object({
+  dialect: e.enum(["postgres", "clickhouse", "duckdb"]),
+  aggregates: e.array(ne).readonly()
+}).strict();
+function U(a) {
+  return e.object({
+    queryIdentity: u,
+    descriptors: K,
+    capabilities: Ce,
+    pages: e.array(Ae).readonly(),
+    blocks: e.array(a).readonly(),
+    failures: e.array(R).readonly()
+  }).strict().superRefine((t, s) => {
+    const r = new Set(
+      t.descriptors.levels.map((o) => o.id)
+    ), n = new Set(
+      t.descriptors.measures.map((o) => o.id)
+    ), i = t.pages.flatMap((o) => [
+      o.parent,
+      ...o.members.map((c) => c.path)
+    ]);
+    for (const o of t.blocks)
+      i.push(...o.coverage.rowPaths, ...o.coverage.columnPaths), o.coverage.measureIds.some((c) => !n.has(c)) && l(
+        s,
+        ["blocks", o.requestId],
+        "Coverage references an unknown measure descriptor."
+      );
+    i.some((o) => o.some((c) => !r.has(c.levelId))) && l(
+      s,
+      ["descriptors"],
+      "Acquired paths require level descriptors."
+    ), h(
+      [...t.descriptors.levels, ...t.descriptors.measures].map(
+        (o) => o.id
+      ),
+      s,
+      ["descriptors"]
+    ), h(
+      [...t.pages, ...t.blocks].map((o) => o.requestId),
+      s,
+      []
+    ), h(
+      t.failures.map(
+        (o) => o.scope.kind === "operation" ? "operation" : o.scope.requestId
+      ),
+      s,
+      ["failures"]
+    );
+    for (const o of t.failures)
+      if (o.scope.kind === "operation")
+        l(
+          s,
+          ["failures"],
+          "Operation failure cannot accompany acquired data."
+        );
+      else {
+        const c = o.scope.requestId;
+        [...t.pages, ...t.blocks].some(
+          (d) => d.requestId === c
+        ) && l(
+          s,
+          ["failures"],
+          "A requested unit cannot both succeed and fail."
+        );
+      }
+  });
+}
+const $ = U(
+  je
+), Ee = U(
+  Re
+);
+function V(a) {
+  return e.union([
+    e.object({
+      status: e.enum(["success", "partial"]),
+      window: a
+    }).strict(),
+    e.object({ status: e.literal("failed"), failure: R }).strict()
+  ]).superRefine((t, s) => {
+    const r = t;
+    if (r.status === "failed") return;
+    const { window: n } = r;
+    !n.pages.length && !n.blocks.length && l(
+      s,
+      ["window"],
+      "A window outcome requires successful acquired work."
+    ), r.status === "success" != (n.failures.length === 0) && l(s, ["status"], "Status must match failure coverage.");
+  });
+}
+const la = V(
+  $
+), ua = V(
+  Ee
+);
+function Pe(a) {
+  const { rowPaths: t, columnPaths: s, measureIds: r } = a.coverage, n = (d) => new Map(d.map((g, f) => [g, f])), i = n(t.map(m)), o = n(s.map(m)), c = n(r);
+  return {
+    requestId: a.requestId,
+    coverage: a.coverage,
+    values: a.cells.map((d) => {
+      const g = i.get(m(d.rowPath)), f = o.get(m(d.columnPath)), C = c.get(d.measureId);
+      if (g === void 0 || f === void 0 || C === void 0)
+        throw new Error("Cell is outside certified coverage.");
+      return [g, f, C, d.value];
+    })
+  };
+}
+function _e(a) {
+  const { rowPaths: t, columnPaths: s, measureIds: r } = a.coverage;
+  return {
+    requestId: a.requestId,
+    coverage: a.coverage,
+    cells: a.values.map(([n, i, o, c]) => ({
+      rowPath: t[n],
+      columnPath: s[i],
+      measureId: r[o],
+      value: c
+    }))
+  };
+}
+function qe(a) {
+  return { ...a, blocks: a.blocks.map(Pe) };
+}
+function ma(a) {
+  return { ...a, blocks: a.blocks.map(_e) };
+}
+function da(a) {
+  return a.status === "failed" ? a : { status: a.status, window: qe(a.window) };
+}
+const J = e.object({
+  kind: e.literal("matrix"),
+  window: $
+}).strict(), Z = e.enum(["member", "subtotal", "grand_total"]), Fe = e.discriminatedUnion("kind", [
+  e.object({ kind: e.literal("hierarchy"), label: e.string() }).strict(),
+  e.object({ kind: e.literal("level"), levelId: y, label: e.string() }).strict(),
+  e.object({
+    kind: e.literal("measure"),
+    measureId: y,
+    columnPath: p,
+    role: Z,
+    label: e.string()
+  }).strict()
+]), Ne = e.object({
+  columns: e.array(Fe).readonly(),
+  descriptors: K
+}).strict(), q = e.union([
+  e.object({
+    kind: e.literal("value"),
+    value: x.refine(
+      (a) => a !== null
+    )
+  }).strict(),
+  e.object({ kind: e.enum(["null", "empty"]) }).strict()
+]), Oe = e.discriminatedUnion("kind", [
+  e.object({
+    kind: e.literal("layout"),
+    rowPath: p,
+    role: Z,
+    values: e.array(q).readonly()
+  }).strict(),
+  e.object({
+    kind: e.literal("flat"),
+    rowPath: p,
+    columnPath: p,
+    values: e.array(q).readonly()
+  }).strict()
+]), pa = e.discriminatedUnion("kind", [
+  e.object({
+    kind: e.literal("layout"),
+    layout: Ne,
+    next: u
+  }).strict(),
+  e.object({
+    kind: e.literal("rows"),
+    rows: e.array(Oe).readonly(),
+    next: u.nullable()
+  }).strict()
+]), Te = e.union([
+  oe,
+  ie,
+  ce,
+  le,
+  J
+]), Me = e.object({
+  status: e.enum([
+    "not_required",
+    "resolved",
+    "missing",
+    "ambiguous",
+    "fanout_risk",
+    "unknown"
+  ]),
+  requiredSources: e.array(S).optional(),
+  relationshipsUsed: e.array(e.string()).optional(),
+  missingSources: e.array(e.string()).optional(),
+  warnings: e.array(e.string()).optional(),
+  message: e.string().optional(),
+  recommendedNextStep: e.string().optional(),
+  joinPlanSummary: e.object({
+    baseSource: S.optional(),
+    joinedSources: e.array(S).optional(),
+    joinCount: e.number().optional()
+  }).passthrough().optional(),
+  fanoutRisk: e.object({
+    status: e.enum(["none", "warning", "error", "unknown"]),
+    message: e.string().optional()
+  }).passthrough().optional()
+}).passthrough(), F = e.enum([
+  "ambiguous_fields",
+  "empty_result",
+  "missing_grounded_fields",
+  "missing_relationship",
+  "no_grounded_query",
+  "partial_result",
+  "presentation_incomplete",
+  "query_validation_failed",
+  "unsafe_join"
+]), X = e.object({
+  version: e.literal(1),
+  status: e.enum(["answered", "partial", "blocked"]),
+  summary: e.string(),
+  answered: e.array(
+    e.object({
+      slotId: e.string().optional(),
+      queryId: e.string().optional(),
+      summary: e.string(),
+      evidenceIds: e.array(e.string()).optional(),
+      fieldsUsed: e.array(A).optional()
+    }).passthrough()
+  ),
+  blocked: e.array(
+    e.object({
+      slotId: e.string().optional(),
+      queryId: e.string().optional(),
+      reasonCode: F,
+      message: e.string(),
+      missingFields: e.array(e.string()).optional(),
+      availableFields: e.array(e.string()).optional(),
+      ambiguousFields: e.array(e.string()).optional(),
+      missingRelationships: e.array(e.string()).optional(),
+      evidenceIds: e.array(e.string()).optional(),
+      neededFromUser: e.array(e.string()).optional(),
+      recommendedNextStep: e.string().optional()
+    }).passthrough()
+  ),
+  semanticModelRecommendations: e.array(
+    e.object({
+      reasonCode: F,
+      message: e.string(),
+      recommendedNextStep: e.string().optional()
+    }).passthrough()
+  ).optional()
+}).passthrough(), Q = e.object({
+  scope: e.literal("filtered_query"),
+  measures: e.record(ue)
+}).passthrough(), G = e.object({
+  answeredObligations: e.array(e.string()),
+  missingObligations: e.array(e.string()),
+  warnings: e.array(me).optional()
+}).passthrough(), H = e.object({
+  intentId: e.string().optional(),
+  queryId: e.string().optional(),
+  status: e.enum(["answered", "partial", "failed"]),
+  resultShape: e.enum([
+    "metric",
+    "records",
+    "inputOptions",
+    "sql",
+    "matrix",
+    "period_change",
+    "analysis"
+  ]).optional(),
+  intent: e.unknown().optional(),
+  compiledQuery: e.unknown().optional(),
+  fieldsUsed: e.array(A).optional(),
+  result: Te.optional(),
+  validation: M,
+  coverage: G.optional(),
+  missingFields: e.array(e.string()).optional(),
+  warnings: e.array(e.string()).optional(),
+  relationshipDiagnostics: Me.optional(),
+  diagnosticFeedback: X.optional(),
+  population: Q.optional(),
+  metadata: e.record(e.string(), e.unknown()).optional()
+}).passthrough(), ze = H;
+function Be(a) {
+  switch (a) {
+    case "boolean":
+      return e.boolean().optional();
+    case "compactExecutionFieldArray":
+      return e.array(he).optional();
+    case "coverage":
+      return G.optional();
+    case "diagnosticFeedback":
+      return X.optional();
+    case "executionFieldArray":
+      return e.array(A).optional();
+    case "executionResult":
+      return ze.optional();
+    case "number":
+      return e.number().finite().optional();
+    case "population":
+      return Q.optional();
+    case "record":
+      return pe.optional();
+    case "recordArray":
+      return de.optional();
+    case "responseDetail":
+      return e.enum(["compact", "standard", "debug"]).optional();
+    case "string":
+      return e.string().optional();
+    case "stringArray":
+      return e.array(e.string()).optional();
+    case "unknown":
+      return e.unknown().optional();
+    case "unknownArray":
+      return e.array(e.unknown()).optional();
+    case "validationResult":
+      return M.optional();
+  }
+}
+const De = Object.fromEntries(
+  Object.entries(j).map(
+    ([a, t]) => [a, Be(t)]
+  )
+), Le = e.object(De).strict(), We = new Set(
+  Object.keys(j)
+);
+function ha() {
+  return Object.keys(
+    j
+  );
+}
+function Ke(a) {
+  return We.has(a);
+}
+function ga(a) {
+  if (!a || typeof a != "object" || Array.isArray(a))
+    throw new Error("Semaphor analyze result must be an object.");
+  const s = Object.keys(a).filter(
+    (r) => !Ke(r)
+  );
+  if (s.length)
+    throw new Error(
+      `Semaphor analyze result contains unsupported top-level field(s): ${s.join(", ")}.`
+    );
+  return Le.parse(a);
+}
+const Y = 100, b = "selection:";
+function ee(a) {
+  return [
+    B(a.source),
+    Se(a.name),
+    a.sourceField ?? ""
+  ].join("::");
+}
+function ya(a) {
+  return `${b}${a}`;
+}
+function Ue(a) {
+  return a.startsWith(b) && a.length > b.length;
+}
+function fa(a) {
+  return Ue(a) ? a.slice(b.length) : void 0;
+}
+function ae(a) {
+  if (!a) return "";
+  const t = a.calendar.fiscalCalendar;
+  return JSON.stringify([
+    a.granularity,
+    a.calendar.tz,
+    a.calendar.weekStart,
+    t ? [t.kind, t.yearStartMonth] : null
+  ]);
+}
+function $e(a) {
+  return JSON.stringify([
+    ee(a.field),
+    a.operator,
+    a.operator === "isNull" ? null : a.value,
+    ae(a.temporalBucket)
+  ]);
+}
+function N(a) {
+  return JSON.stringify(a.conditions.map($e).sort());
+}
+function v(a) {
+  return JSON.stringify([
+    B(a.field.source),
+    a.field.name,
+    a.operator,
+    a.operator === "isNull" ? null : a.value,
+    ae(a.temporalBucket)
+  ]);
+}
+function O(a) {
+  return JSON.stringify(
+    a.conditions.map(v).sort()
+  );
+}
+function ba(a) {
+  const t = a.map((s) => s.id);
+  if (new Set(t).size !== t.length)
+    throw new Error("Data App selections require one active selection per id.");
+  return a.map((s) => ({
+    ...s,
+    tuples: s.tuples.map((r) => ({
+      ...r,
+      conditions: [...r.conditions].sort(
+        (n, i) => w(
+          v(n),
+          v(i)
+        )
+      )
+    })).sort(
+      (r, n) => w(
+        O(r),
+        O(n)
+      )
+    )
+  })).sort((s, r) => w(s.id, r.id));
+}
+function w(a, t) {
+  return a < t ? -1 : a > t ? 1 : 0;
+}
+function Sa(a, t) {
+  return N(a) === N(t);
+}
+const Ve = "(Blank)";
+function Ia(a) {
+  return a.conditions.map((t) => t.label ? t.label : t.operator === "isNull" || t.value === null ? Ve : String(t.value)).join(" · ");
+}
+const Je = e.union([
+  ge,
+  ye
+]), Ze = e.object({
+  name: e.string().min(1),
+  source: Je,
+  dataType: e.enum(["string", "number", "boolean", "date", "datetime"]),
+  sourceField: e.string().min(1).optional()
+}).strict(), Xe = e.object({
+  field: Ze,
+  operator: e.enum(["=", "isNull"]),
+  value: e.union([e.string(), e.number().finite(), e.null()]),
+  label: e.string().optional(),
+  temporalBucket: z.optional()
+}).strict().superRefine((a, t) => {
+  a.operator === "isNull" != (a.value === null) && t.addIssue({
+    code: e.ZodIssueCode.custom,
+    message: "isNull carries a null value, and only isNull does.",
+    path: ["value"]
+  });
+}), Qe = e.object({
+  conditions: e.array(Xe).min(1)
+}).strict().superRefine((a, t) => {
+  const s = a.conditions.map((r) => ee(r.field));
+  new Set(s).size !== s.length && t.addIssue({
+    code: e.ZodIssueCode.custom,
+    message: "A tuple holds one condition per field.",
+    path: ["conditions"]
+  });
+}), wa = e.object({
+  kind: e.literal("selection"),
+  sourceCardId: e.string().min(1),
+  tuples: e.array(Qe).min(1).max(Y)
+}).strict(), Ge = e.object({
+  field: fe,
+  operator: e.enum(["=", "isNull"]),
+  value: e.union([e.string(), e.number().finite(), e.null()]),
+  temporalBucket: z.optional()
+}).strict().superRefine((a, t) => {
+  a.operator === "isNull" != (a.value === null) && t.addIssue({
+    code: e.ZodIssueCode.custom,
+    message: "isNull carries a null value, and only isNull does.",
+    path: ["value"]
+  });
+}), He = e.object({
+  conditions: e.array(Ge).min(1)
+}).strict().superRefine((a, t) => {
+  for (let s = 0; s < a.conditions.length; s += 1) {
+    const r = a.conditions[s];
+    a.conditions.findIndex(
+      (i, o) => o < s && be(i.field, r.field)
+    ) !== -1 && t.addIssue({
+      code: e.ZodIssueCode.custom,
+      message: "A selection tuple can contain only one condition per field.",
+      path: ["conditions", s, "field"]
+    });
+  }
+}), ka = e.object({
+  id: e.string().min(1),
+  tuples: e.array(He).min(1).max(Y)
+}).strict(), Ye = e.object({ key: e.string().min(1), nativeText: e.string().nullable() }).strict(), ea = e.object({
+  executionInstant: e.string().refine((a) => Ie(a) !== null, {
+    message: "executionInstant must be an ISO instant"
+  }),
+  dataAnchors: e.array(Ye).default([])
+}).strict().refine(
+  (a) => new Set(a.dataAnchors.map((t) => t.key)).size === a.dataAnchors.length,
+  { message: "dataAnchors keys must be unique", path: ["dataAnchors"] }
+);
+function va(a) {
+  if (a == null) return;
+  const t = ea.safeParse(a);
+  return t.success ? t.data : void 0;
+}
+const aa = e.object({
+  intent: we,
+  matrixWindowRequest: D
+}).strict(), ta = e.object({
+  runtimeFilters: k.innerType().shape.filters,
+  runtimeSorts: k.innerType().shape.sorts.optional()
+});
+function xa(a) {
+  return ta.parse(a);
+}
+const sa = {
+  // A window executes a governed statement set, not one compiled query.
+  compiledQuery: e.never().optional(),
+  intent: aa.shape.intent,
+  resultShape: e.literal("matrix"),
+  result: J.optional(),
+  metadata: e.object({ rowLimitExceeded: e.boolean(), matrixFailure: R.optional() }).passthrough()
+}, ra = H.extend(sa), Aa = ra.superRefine((a, t) => {
+  a.status === "failed" == !!a.result && t.addIssue({ code: "custom", message: "Only answered or partial Matrix execution carries a window." }), a.result && a.status === "partial" != a.result.window.failures.length > 0 && t.addIssue({ code: "custom", message: "Matrix execution status must match acquired window failures." });
+});
+export {
+  _e as $,
+  Sa as A,
+  Ia as B,
+  Ze as C,
+  Xe as D,
+  Qe as E,
+  wa as F,
+  Ge as G,
+  He as H,
+  ea as I,
+  va as J,
+  ve as K,
+  P as L,
+  ia as M,
+  xe as N,
+  ca as O,
+  Ae as P,
+  je as Q,
+  Re as R,
+  j as S,
+  _ as T,
+  R as U,
+  Ce as V,
+  $ as W,
+  Ee as X,
+  la as Y,
+  ua as Z,
+  Pe as _,
+  ka as a,
+  qe as a0,
+  ma as a1,
+  da as a2,
+  Fe as a3,
+  Ne as a4,
+  q as a5,
+  Oe as a6,
+  pa as a7,
+  ta as a8,
+  xa as a9,
+  Aa as aa,
+  aa as ab,
+  Me as b,
+  ba as c,
+  X as d,
+  Q as e,
+  G as f,
+  ha as g,
+  H as h,
+  Ke as i,
+  ze as j,
+  De as k,
+  Le as l,
+  D as m,
+  J as n,
+  Y as o,
+  ga as p,
+  ee as q,
+  ya as r,
+  Te as s,
+  Ue as t,
+  fa as u,
+  ae as v,
+  $e as w,
+  N as x,
+  v as y,
+  O as z
+};