react-semaphor 0.1.527 → 0.1.528

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

@@ -1,809 +0,0 @@
-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
-};