react-semaphor 0.1.507 → 0.1.508

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

@@ -0,0 +1,1802 @@
+import { z as r } from "zod";
+import { K as g, E as se, U as B, ba as L, S as v, M as Ce, b2 as te, bb as je, aL as qe, F as Ee, m as Fe, l as xe, b0 as Ke, aQ as Ne, aR as Oe, aU as Be, aV as Te, aE as q, aJ as P, ax as Me, aO as De, aP as ie, av as Pe, at as m, au as Ve, aK as Ue, aB as ze, aC as Le, v as re, aG as Ge, k as Qe, q as ne, ah as He } from "./validators-BDYzZFgs.js";
+const V = {
+  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"
+}, gt = Object.freeze({ coordinates: 2e4 }), w = r.string().uuid(), p = r.string().min(1), We = r.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+function c(t, s, e) {
+  t.addIssue({ code: "custom", path: s, message: e });
+}
+function y(t, s, e) {
+  new Set(t).size !== t.length && c(s, e, "Duplicate identity.");
+}
+const Ye = r.object({
+  id: p,
+  axis: se,
+  parent: g,
+  position: r.union([
+    r.object({ kind: r.literal("first") }).strict(),
+    r.object({ kind: r.enum(["after", "before"]), cursor: p }).strict()
+  ]),
+  size: We
+}).strict(), G = r.object({
+  paths: r.array(g).readonly(),
+  pageIds: r.array(p).readonly()
+}).strict(), Je = r.object({
+  id: p,
+  rows: G,
+  columns: G,
+  measureIds: r.array(w).min(1).readonly()
+}).strict(), ae = r.object({
+  pages: r.array(Ye).readonly(),
+  blocks: r.array(Je).readonly()
+}).strict().superRefine((t, s) => {
+  !t.pages.length && !t.blocks.length && c(s, [], "Request at least one page or block."), y(
+    [...t.pages, ...t.blocks].map((e) => e.id),
+    s,
+    []
+  );
+  for (const e of t.blocks) {
+    y(e.measureIds, s, ["blocks", e.id, "measureIds"]);
+    for (const i of ["rows", "columns"])
+      for (const n of e[i].pageIds)
+        t.pages.some(
+          (a) => a.id === n && a.axis === i
+        ) || c(
+          s,
+          ["blocks", e.id, i],
+          "Page reference must name a page on this axis in this operation."
+        );
+  }
+}), bt = r.object({ spec: B, request: ae }).strict().superRefine(({ spec: t, request: s }, e) => {
+  for (const i of s.pages)
+    L(
+      t,
+      i.axis,
+      i.parent,
+      e,
+      ["pages", i.id],
+      !0
+    ), i.parent.length >= t[i.axis].length && c(
+      e,
+      ["pages", i.id],
+      "Cannot request children of a leaf or empty axis."
+    );
+  for (const i of s.blocks) {
+    i.measureIds.some((n) => !t.measures.some((a) => a.id === n)) && c(e, ["blocks", i.id], "Unknown block measure.");
+    for (const n of ["rows", "columns"])
+      for (const a of i[n].paths)
+        L(t, n, a, e, ["blocks", i.id, n]);
+  }
+}), Ze = r.object({
+  requestId: p,
+  axis: se,
+  parent: g,
+  members: r.array(r.object({ path: g }).strict()).readonly(),
+  before: p.nullable(),
+  after: p.nullable(),
+  exactCount: r.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional()
+}).strict().superRefine((t, s) => {
+  t.parent.some((i) => i.member.kind === "others") && c(s, ["parent"], "Others has no children.");
+  const e = t.members.filter(
+    ({ path: i }) => {
+      var n;
+      return ((n = i[i.length - 1]) == null ? void 0 : n.member.kind) === "others";
+    }
+  );
+  e.length > 1 && c(s, ["members"], "A page may contain Others only once."), e.length && (t.members[t.members.length - 1] !== e[0] && c(s, ["members"], "Others must be the last page member."), t.after !== null && c(s, ["after"], "Others must end the branch.")), new Set(
+    t.members.map(
+      (i) => {
+        var n;
+        return (n = i.path[i.path.length - 1]) == null ? void 0 : n.levelId;
+      }
+    )
+  ).size > 1 && c(s, ["members"], "One page must contain one child level."), y(
+    t.members.map((i) => v(i.path)),
+    s,
+    ["members"]
+  );
+  for (const i of t.members)
+    (i.path.length !== t.parent.length + 1 || v(i.path.slice(0, -1)) !== v(t.parent)) && c(s, ["members"], "Page members must be immediate children.");
+}), Xe = r.object({
+  requestId: p,
+  coverage: r.object({
+    rowPaths: r.array(g).readonly(),
+    columnPaths: r.array(g).readonly(),
+    measureIds: r.array(w).readonly()
+  }).strict(),
+  cells: r.array(
+    Ce.extend({ value: te }).strict()
+  ).readonly()
+}).strict().superRefine((t, s) => {
+  const e = t.coverage.rowPaths.map(v), i = t.coverage.columnPaths.map(v);
+  y(e, s, ["coverage", "rowPaths"]), y(i, s, ["coverage", "columnPaths"]), y(t.coverage.measureIds, s, ["coverage", "measureIds"]);
+  const n = new Set(e), a = new Set(i), l = new Set(t.coverage.measureIds);
+  y(
+    t.cells.map(
+      (u) => JSON.stringify([
+        v(u.rowPath),
+        v(u.columnPath),
+        u.measureId
+      ])
+    ),
+    s,
+    ["cells"]
+  );
+  for (const u of t.cells)
+    (!n.has(v(u.rowPath)) || !a.has(v(u.columnPath)) || !l.has(u.measureId)) && c(s, ["cells"], "Cell is outside certified coverage.");
+}), Q = r.object({
+  id: w,
+  column: qe,
+  nativeDataType: p,
+  semanticFormat: je.optional()
+}).strict(), oe = r.object({
+  levels: r.array(Q).readonly(),
+  measures: r.array(Q).readonly()
+}).strict(), U = r.object({
+  code: r.enum([
+    "invalid_request",
+    "unsupported_capability",
+    "stale_cursor",
+    "forbidden",
+    "budget_exceeded",
+    "source_truncated",
+    "execution_failed",
+    "cancelled"
+  ]),
+  message: p,
+  /** Technical cause for dashboard owners; never shown as the primary copy. */
+  detail: p.optional(),
+  retryable: r.boolean(),
+  scope: r.union([
+    r.object({ kind: r.literal("operation") }).strict(),
+    r.object({ kind: r.enum(["page", "block"]), requestId: p }).strict()
+  ])
+}).strict(), es = r.object({
+  dialect: r.enum(["postgres", "clickhouse", "duckdb"]),
+  aggregates: r.array(Ee).readonly()
+}).strict(), ue = r.object({
+  queryIdentity: p,
+  descriptors: oe,
+  capabilities: es,
+  pages: r.array(Ze).readonly(),
+  blocks: r.array(Xe).readonly(),
+  failures: r.array(U).readonly()
+}).strict().superRefine((t, s) => {
+  const e = new Set(
+    t.descriptors.levels.map((a) => a.id)
+  ), i = new Set(
+    t.descriptors.measures.map((a) => a.id)
+  ), n = t.pages.flatMap((a) => [
+    a.parent,
+    ...a.members.map((l) => l.path)
+  ]);
+  for (const a of t.blocks)
+    n.push(...a.coverage.rowPaths, ...a.coverage.columnPaths), a.coverage.measureIds.some((l) => !i.has(l)) && c(
+      s,
+      ["blocks", a.requestId],
+      "Coverage references an unknown measure descriptor."
+    );
+  n.some((a) => a.some((l) => !e.has(l.levelId))) && c(s, ["descriptors"], "Acquired paths require level descriptors."), y(
+    [...t.descriptors.levels, ...t.descriptors.measures].map(
+      (a) => a.id
+    ),
+    s,
+    ["descriptors"]
+  ), y(
+    [...t.pages, ...t.blocks].map((a) => a.requestId),
+    s,
+    []
+  ), y(
+    t.failures.map(
+      (a) => a.scope.kind === "operation" ? "operation" : a.scope.requestId
+    ),
+    s,
+    ["failures"]
+  );
+  for (const a of t.failures)
+    if (a.scope.kind === "operation")
+      c(
+        s,
+        ["failures"],
+        "Operation failure cannot accompany acquired data."
+      );
+    else {
+      const l = a.scope.requestId;
+      [...t.pages, ...t.blocks].some(
+        (u) => u.requestId === l
+      ) && c(
+        s,
+        ["failures"],
+        "A requested unit cannot both succeed and fail."
+      );
+    }
+}), vt = r.union([
+  r.object({
+    status: r.enum(["success", "partial"]),
+    window: ue
+  }).strict(),
+  r.object({ status: r.literal("failed"), failure: U }).strict()
+]).superRefine((t, s) => {
+  if (t.status === "failed") return;
+  const { window: e } = t;
+  !e.pages.length && !e.blocks.length && c(
+    s,
+    ["window"],
+    "A window outcome requires successful acquired work."
+  ), t.status === "success" != (e.failures.length === 0) && c(s, ["status"], "Status must match failure coverage.");
+}), le = r.object({
+  kind: r.literal("matrix"),
+  window: ue
+}).strict(), de = r.enum(["member", "subtotal", "grand_total"]), ss = r.discriminatedUnion("kind", [
+  r.object({ kind: r.literal("hierarchy"), label: r.string() }).strict(),
+  r.object({ kind: r.literal("level"), levelId: w, label: r.string() }).strict(),
+  r.object({
+    kind: r.literal("measure"),
+    measureId: w,
+    columnPath: g,
+    role: de,
+    label: r.string()
+  }).strict()
+]), ts = r.object({
+  columns: r.array(ss).readonly(),
+  descriptors: oe
+}).strict(), H = r.union([
+  r.object({
+    kind: r.literal("value"),
+    value: te.refine(
+      (t) => t !== null
+    )
+  }).strict(),
+  r.object({ kind: r.enum(["null", "empty"]) }).strict()
+]), is = r.discriminatedUnion("kind", [
+  r.object({
+    kind: r.literal("layout"),
+    rowPath: g,
+    role: de,
+    values: r.array(H).readonly()
+  }).strict(),
+  r.object({
+    kind: r.literal("flat"),
+    rowPath: g,
+    columnPath: g,
+    values: r.array(H).readonly()
+  }).strict()
+]), St = r.discriminatedUnion("kind", [
+  r.object({
+    kind: r.literal("layout"),
+    layout: ts,
+    next: p
+  }).strict(),
+  r.object({
+    kind: r.literal("rows"),
+    rows: r.array(is).readonly(),
+    next: p.nullable()
+  }).strict()
+]), ce = r.object({
+  intent: Fe,
+  matrixWindowRequest: ae
+}).strict(), T = "semaphor-data-app-codegen-summary/v1", $t = "semaphor-data-app-codegen-summary-validator/v2", rs = /* @__PURE__ */ new Set([
+  "metric",
+  "records",
+  "matrix",
+  "analysis",
+  "sql_fallback"
+]), ns = /* @__PURE__ */ new Set([
+  "semaphor.metric",
+  "semaphor.records",
+  "semaphor.matrix",
+  "semaphor.analysis",
+  "semaphor.sql"
+]), as = /* @__PURE__ */ new Set([
+  "SUM",
+  "COUNT",
+  "AVG",
+  "MIN",
+  "MAX",
+  "MEDIAN",
+  "DISTINCT"
+]), os = /* @__PURE__ */ new Set([
+  "absolute_delta",
+  "largest_negative",
+  "largest_positive",
+  "positive_and_negative",
+  "all"
+]), pe = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "measures",
+  "primaryMeasure",
+  "dateField",
+  "timeGrain",
+  "dimensions",
+  "comparison",
+  "orderBy",
+  "filters",
+  "relationshipHint",
+  "limit",
+  "derivedFields"
+]), us = /* @__PURE__ */ new Set([
+  ...pe,
+  "analysis",
+  "timeWindow",
+  "filters",
+  "driverMode",
+  "includePopulation",
+  "calendarContext",
+  "chartTitle",
+  "chartType"
+]), ls = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "fields",
+  "dateField",
+  "timeGrain",
+  "timeWindow",
+  "filters",
+  "orderBy",
+  "relationshipHint",
+  "limit",
+  "pagination",
+  "totals",
+  "derivedFields"
+]), ds = /* @__PURE__ */ new Set([
+  "source",
+  "id",
+  "label",
+  "sql",
+  "defaultParameters",
+  "pythonCode",
+  "fields",
+  "limit",
+  "pagination",
+  "rationale"
+]), cs = /* @__PURE__ */ new Set([
+  "kpi",
+  "line_chart",
+  "bar_chart",
+  "stacked_bar_chart",
+  "pie_chart",
+  "donut_chart",
+  "area_chart",
+  "table",
+  "matrix",
+  "narrative",
+  "text_block",
+  "custom"
+]), ps = /* @__PURE__ */ new Set([
+  "missing_measure",
+  "missing_dimension",
+  "missing_date",
+  "missing_relationship",
+  "missing_semantic_role",
+  "missing_current_app_state",
+  "raw_identifier_filter_options",
+  "unsupported_change_intent",
+  "ambiguous_field_grounding",
+  "bounded_intent_unavailable",
+  "invalid_bounded_intent_output",
+  "latest_snapshot_selector_not_modeled",
+  "unsupported_grain",
+  "requires_sql_escape_hatch",
+  "unsupported_sdk_capability"
+]);
+function kt(t) {
+  return me(t).ok;
+}
+function me(t) {
+  const s = [];
+  if (!t || typeof t != "object")
+    return { ok: !1, issues: ["Summary must be an object."] };
+  const e = t;
+  return e.schemaVersion !== T && s.push(
+    `schemaVersion must be ${T}.`
+  ), (typeof e.title != "string" || !e.title.trim()) && s.push("title is required."), Array.isArray(e.sources) || s.push("sources must be an array."), Array.isArray(e.inputs) || s.push("inputs must be an array."), Array.isArray(e.views) || s.push("views must be an array."), Array.isArray(e.filterContracts) || s.push("filterContracts must be an array."), (!e.implementationChecklist || typeof e.implementationChecklist != "object") && s.push("implementationChecklist must be an object."), e.implementationChecklist && typeof e.implementationChecklist == "object" && s.push(
+    ...fs(e.implementationChecklist)
+  ), Array.isArray(e.sources) && e.sources.forEach((i, n) => {
+    s.push(...C(i, `sources.${n}`));
+  }), Array.isArray(e.inputs) && e.inputs.forEach((i, n) => {
+    s.push(...ys(i, `inputs.${n}`));
+  }), Array.isArray(e.views) && e.views.forEach((i, n) => {
+    s.push(...hs(i, `views.${n}`));
+  }), Array.isArray(e.filterContracts) && e.filterContracts.forEach((i, n) => {
+    s.push(
+      ..._s(i, `filterContracts.${n}`)
+    );
+  }), e.unsupportedInsights !== void 0 && (Array.isArray(e.unsupportedInsights) ? e.unsupportedInsights.forEach((i, n) => {
+    s.push(
+      ...Ps(
+        i,
+        `unsupportedInsights.${n}`
+      )
+    );
+  }) : s.push("unsupportedInsights must be an array.")), s.push(...ms(e)), { ok: s.length === 0, issues: s };
+}
+function ms(t) {
+  const s = Array.isArray(t.unsupportedInsights) && t.unsupportedInsights.some(
+    (l) => {
+      var u;
+      return W.has((u = o(l)) == null ? void 0 : u.reason);
+    }
+  ), e = Array.isArray(t.views) && t.views.some((l) => {
+    var d;
+    const u = o((d = o(l)) == null ? void 0 : d.computation);
+    return (u == null ? void 0 : u.kind) === "unsupported" && W.has(u.reason);
+  });
+  if (!s && !e)
+    return [];
+  const i = [], n = o(t.validation);
+  (n == null ? void 0 : n.status) !== "blocked" && i.push(
+    "validation.status must be blocked when semantic model repair gaps are present."
+  );
+  const a = o(t.nextRequiredTool);
+  return (a == null ? void 0 : a.name) !== "semaphor_propose_semantic_model_change" && i.push(
+    "nextRequiredTool.name must be semaphor_propose_semantic_model_change when semantic model repair gaps are present."
+  ), i;
+}
+const W = /* @__PURE__ */ new Set([
+  "missing_relationship",
+  "raw_identifier_filter_options"
+]);
+function C(t, s) {
+  const e = o(t);
+  return e ? e.kind === "semantic" ? typeof e.domainId == "string" && e.domainId.trim() && typeof e.datasetName == "string" && e.datasetName.trim() ? [] : [`${s} must include sourceKey or a supported source identity.`] : typeof e.sourceKey == "string" && e.sourceKey.trim() ? [] : e.kind === "physical" && typeof e.tableName == "string" && e.tableName.trim() && typeof e.connectionId == "string" && e.connectionId.trim() ? [] : e.kind === "sql" && typeof e.connectionId == "string" && e.connectionId.trim() ? [] : [`${s} must include sourceKey or a supported source identity.`] : [`${s} must be an object.`];
+}
+function fs(t) {
+  const s = o(t);
+  if (!s)
+    return ["implementationChecklist must be an object."];
+  const e = [], i = [
+    "requiredDevtools",
+    "requiredInputOptions",
+    "filterScopeByInput",
+    "bindingsByView",
+    "validationCommands",
+    "browserSmokeChecks"
+  ];
+  for (const a of i)
+    a in s || e.push(`implementationChecklist.${a} is required.`);
+  const n = o(s.requiredDevtools);
+  return n ? typeof n.mountRootDevtools != "boolean" && e.push(
+    "implementationChecklist.requiredDevtools.mountRootDevtools must be a boolean."
+  ) : e.push("implementationChecklist.requiredDevtools must be an object."), Array.isArray(s.requiredInputOptions) || e.push(
+    "implementationChecklist.requiredInputOptions must be an array."
+  ), Array.isArray(s.filterScopeByInput) || e.push("implementationChecklist.filterScopeByInput must be an array."), o(s.bindingsByView) || e.push("implementationChecklist.bindingsByView must be an object."), h(s.validationCommands) || e.push(
+    "implementationChecklist.validationCommands must be an array of strings."
+  ), h(s.browserSmokeChecks) || e.push(
+    "implementationChecklist.browserSmokeChecks must be an array of strings."
+  ), e;
+}
+function ys(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  return (typeof e.id != "string" || !e.id.trim()) && i.push(`${s}.id is required.`), e.fieldRef && i.push(...f(e.fieldRef, `${s}.fieldRef`)), i.push(...ye(e.optionQuery, `${s}.optionQuery`)), h(e.appliesToViewIds) || i.push(`${s}.appliesToViewIds must be an array of strings.`), e.bindings !== void 0 && !Array.isArray(e.bindings) && i.push(`${s}.bindings must be an array.`), Array.isArray(e.bindings) && e.bindings.forEach((n, a) => {
+    const l = o(n);
+    if (!l) {
+      i.push(`${s}.bindings.${a} must be an object.`);
+      return;
+    }
+    h(l.appliesToViewIds) || i.push(
+      `${s}.bindings.${a}.appliesToViewIds must be an array of strings.`
+    ), i.push(
+      ...f(
+        l.fieldRef,
+        `${s}.bindings.${a}.fieldRef`
+      )
+    );
+  }), i;
+}
+function hs(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  if ((typeof e.id != "string" || !e.id.trim()) && i.push(`${s}.id is required.`), e.visualSpec !== void 0 && i.push(...Ks(e.visualSpec, `${s}.visualSpec`)), e.computation !== void 0 && i.push(
+    ...Ds(e.computation, `${s}.computation`)
+  ), xs(e))
+    return i.push(...E(e, `${s}`)), e.fields !== void 0 && (Array.isArray(e.fields) ? e.fields.forEach((d, b) => {
+      i.push(
+        ...f(d, `${s}.fields.${b}`)
+      );
+    }) : i.push(`${s}.fields must be an array.`)), e.queryKind !== void 0 && i.push(`${s}.queryKind is not allowed for non-executable views.`), e.sdkBuilder !== void 0 && i.push(
+      `${s}.sdkBuilder is not allowed for non-executable views.`
+    ), e.sdkSpec !== void 0 && i.push(`${s}.sdkSpec is not allowed for non-executable views.`), i;
+  if (!Array.isArray(e.fields))
+    return i.push(`${s}.fields must be an array.`), (e.sdkSpec !== void 0 || e.sdkBuilder !== void 0) && i.push(`${s}.fields must be an array for executable views.`), i.push(...E(e, `${s}`)), i;
+  e.fields.forEach((d, b) => {
+    i.push(...f(d, `${s}.fields.${b}`));
+  }), k(e.queryKind) || i.push(`${s}.queryKind must be a supported codegen query kind.`), e.sdkBuilder !== void 0 && !ge(e.sdkBuilder) && i.push(`${s}.sdkBuilder must be a supported SDK builder.`), e.metricBindingKeys !== void 0 && (Array.isArray(e.metricBindingKeys) ? e.metricBindingKeys.some(
+    (d) => typeof d != "string" || d.trim().length === 0
+  ) && i.push(`${s}.metricBindingKeys must be an array of strings.`) : i.push(`${s}.metricBindingKeys must be an array of strings.`));
+  const n = o(e.sdkSpec), a = (n == null ? void 0 : n.builder) === "semaphor.metric";
+  a && (!Array.isArray(e.metricBindingKeys) || e.metricBindingKeys.length === 0) && i.push(`${s}.metricBindingKeys is required for metric views.`);
+  const l = gs(e);
+  a && Array.isArray(e.metricBindingKeys) && l && JSON.stringify(e.metricBindingKeys) !== JSON.stringify(l) && i.push(
+    `${s}.metricBindingKeys must match the generated metric field binding keys in order.`
+  );
+  const u = o(e.computation);
+  return (u == null ? void 0 : u.kind) === "server_query" && k(e.queryKind) && k(u.queryKind) && u.queryKind !== e.queryKind && i.push(`${s}.computation.queryKind must match queryKind.`), i.push(
+    ...Rs({
+      value: e.sdkSpec,
+      path: `${s}.sdkSpec`,
+      queryKind: typeof e.queryKind == "string" ? e.queryKind : void 0,
+      sdkBuilder: typeof e.sdkBuilder == "string" ? e.sdkBuilder : void 0
+    }),
+    ...E(e, `${s}`)
+  ), i;
+}
+function gs(t) {
+  const s = o(t.sdkSpec);
+  if ((s == null ? void 0 : s.builder) !== "semaphor.metric")
+    return;
+  const e = o(s.spec);
+  if (!e)
+    return;
+  const n = [
+    e.primaryMeasure,
+    ...Array.isArray(e.measures) ? e.measures : []
+  ].map(bs).filter(
+    (a) => !!a
+  );
+  return Array.from(
+    new Map(n.map((a) => [a.identity, a.bindingKey])).values()
+  );
+}
+function bs(t) {
+  const s = o(t);
+  if (!s || typeof s.name != "string" || !s.name.trim())
+    return;
+  const e = vs(s);
+  return e ? {
+    identity: JSON.stringify({
+      source: e,
+      name: s.name,
+      aggregate: fe(s)
+    }),
+    bindingKey: Ss(s)
+  } : void 0;
+}
+function vs(t) {
+  if (typeof t.sourceKey == "string" && t.sourceKey.trim())
+    return { sourceKey: t.sourceKey };
+  const s = o(t.source);
+  if (s)
+    return {
+      kind: s.kind,
+      domainId: s.domainId,
+      datasetId: s.datasetId,
+      datasetName: s.datasetName,
+      name: s.name
+    };
+}
+function Ss(t) {
+  return typeof t.sourceKey == "string" && t.sourceKey.trim() ? [t.sourceKey, fe(t), t.name].filter(Boolean).join(":") : Ke(t);
+}
+function fe(t) {
+  return xe(t);
+}
+function E(t, s) {
+  var b;
+  const e = o((b = o(t.visualSpec)) == null ? void 0 : b.tableBehavior), i = o(t.sdkSpec), n = o(i == null ? void 0 : i.spec), a = typeof (i == null ? void 0 : i.builder) == "string" ? i.builder : void 0, l = a === "semaphor.records" ? o(n == null ? void 0 : n.totals) : void 0, u = [];
+  if (!e)
+    return l && u.push(
+      `${s}.sdkSpec.spec.totals is only allowed when tableBehavior.totals.mode is server.`
+    ), u;
+  const d = o(e.totals);
+  return d ? (d.mode === "server" && (a !== "semaphor.records" && u.push(
+    `${s}.visualSpec.tableBehavior.totals.mode server is only supported for semaphor.records views.`
+  ), !l || l.mode !== "server" ? u.push(
+    `${s}.sdkSpec.spec.totals.mode must be server when tableBehavior.totals.mode is server.`
+  ) : u.push(
+    ...$s({
+      left: d.measures,
+      right: l.measures,
+      leftPath: `${s}.visualSpec.tableBehavior.totals.measures`,
+      rightPath: `${s}.sdkSpec.spec.totals.measures`
+    })
+  )), d.mode !== "server" && l && u.push(
+    `${s}.sdkSpec.spec.totals is only allowed when tableBehavior.totals.mode is server.`
+  ), a === "semaphor.sql" && d.mode !== "none" && u.push(
+    `${s}.visualSpec.tableBehavior.totals.mode must be none for semaphor.sql views.`
+  ), a === "semaphor.sql" && o(n == null ? void 0 : n.totals) && u.push(
+    `${s}.sdkSpec.spec.totals is not supported for semaphor.sql.`
+  ), u) : (l && u.push(
+    `${s}.sdkSpec.spec.totals is only allowed when tableBehavior.totals.mode is server.`
+  ), u);
+}
+function $s({
+  left: t,
+  right: s,
+  leftPath: e,
+  rightPath: i
+}) {
+  if (!Array.isArray(t) || !Array.isArray(s))
+    return [`${i} must match ${e}.`];
+  const n = [];
+  return t.length !== s.length ? (n.push(`${i} must match ${e}.`), n) : (t.forEach((a, l) => {
+    ks(o(a), o(s[l])) || n.push(`${i}.${l} must match ${e}.${l}.`);
+  }), n);
+}
+function ks(t, s) {
+  return !t || !s ? !1 : t.name === s.name && (t.role || "measure") === (s.role || "measure") && Y(t) === Y(s) && ws(t, s);
+}
+function Y(t) {
+  return typeof t.aggregate == "string" ? t.aggregate.toUpperCase() : "SUM";
+}
+function ws(t, s) {
+  const e = o(t.source), i = o(s.source);
+  if (Is(e, i))
+    return !1;
+  const n = J(t), a = J(s);
+  if (n.size > 0 || a.size > 0) {
+    for (const l of n)
+      if (a.has(l))
+        return !0;
+    return !1;
+  }
+  return !e || !i || e.kind !== i.kind ? !1 : e.kind === "semantic" ? e.domainId === i.domainId && e.datasetName === i.datasetName && (e.datasetId === void 0 || i.datasetId === void 0 || e.datasetId === i.datasetId) : e.kind === "physical" ? e.connectionId === i.connectionId && e.tableName === i.tableName : e.kind === "sql" ? e.connectionId === i.connectionId : !1;
+}
+function Is(t, s) {
+  if (!t || !s || t.kind !== "semantic" || s.kind !== "semantic")
+    return !1;
+  const e = typeof t.datasetId == "string" ? t.datasetId.trim() : "", i = typeof s.datasetId == "string" ? s.datasetId.trim() : "";
+  return !!(e && i && e !== i);
+}
+function J(t) {
+  const s = typeof t.sourceKey == "string" ? t.sourceKey.trim() : "";
+  return s ? /* @__PURE__ */ new Set([s]) : As(o(t.source));
+}
+function As(t) {
+  const s = /* @__PURE__ */ new Set();
+  if (!t)
+    return s;
+  const e = typeof t.sourceKey == "string" ? t.sourceKey.trim() : "";
+  if (e && s.add(e), t.kind === "semantic") {
+    const i = typeof t.domainId == "string" ? t.domainId : "", n = typeof t.datasetName == "string" ? t.datasetName : "", a = typeof t.datasetId == "string" ? t.datasetId : "";
+    i && a && s.add(`semantic:${i}:datasetId:${a}`), i && n && s.add(`semantic:${i}:datasetName:${n}`);
+  }
+  if (t.kind === "physical") {
+    const i = typeof t.connectionId == "string" ? t.connectionId : "", n = typeof t.tableName == "string" ? t.tableName : "", a = typeof t.databaseName == "string" ? t.databaseName : "", l = typeof t.schemaName == "string" ? t.schemaName : "";
+    i && n && (s.add(
+      ["physical", i, a, l, n].join(
+        ":"
+      )
+    ), s.add(`physical:${i}:${n}`));
+  }
+  if (t.kind === "sql") {
+    const i = typeof t.connectionId == "string" ? t.connectionId : "", n = typeof t.dialect == "string" ? t.dialect : "", a = typeof t.label == "string" ? t.label : "";
+    i && (s.add(["sql", i, n, a].join(":")), s.add(`sql:${i}`));
+  }
+  return s;
+}
+function _s(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  if (e.fieldRef && i.push(
+    ...f(e.fieldRef, `${s}.fieldRef`)
+  ), (typeof e.inputId != "string" || !e.inputId.trim()) && i.push(`${s}.inputId is required.`), i.push(
+    ...ye(e.optionQuery, `${s}.optionQuery`)
+  ), h(e.appliesToViewIds) || i.push(`${s}.appliesToViewIds must be an array of strings.`), h(e.notAppliedToViewIds) || i.push(`${s}.notAppliedToViewIds must be an array of strings.`), !Array.isArray(e.bindings))
+    i.push(`${s}.bindings must be an array.`);
+  else {
+    const n = h(e.appliesToViewIds) ? new Set(e.appliesToViewIds) : void 0, a = h(
+      e.notAppliedToViewIds
+    ) ? new Set(e.notAppliedToViewIds) : void 0;
+    e.bindings.forEach((l, u) => {
+      const d = o(l);
+      if (!d) {
+        i.push(`${s}.bindings.${u} must be an object.`);
+        return;
+      }
+      typeof d.viewId != "string" || !d.viewId ? i.push(`${s}.bindings.${u}.viewId is required.`) : (n && !n.has(d.viewId) && i.push(
+        `${s}.bindings.${u}.viewId must be included in appliesToViewIds.`
+      ), a != null && a.has(d.viewId) && i.push(
+        `${s}.bindings.${u}.viewId must not be listed in notAppliedToViewIds.`
+      )), i.push(
+        ...f(
+          d.fieldRef,
+          `${s}.bindings.${u}.fieldRef`
+        )
+      );
+    });
+  }
+  return i;
+}
+function ye(t, s) {
+  if (t === void 0)
+    return [];
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [
+    ...S(
+      e.valueFieldRef,
+      `${s}.valueFieldRef`
+    ),
+    ...S(
+      e.labelFieldRef,
+      `${s}.labelFieldRef`
+    ),
+    ...S(
+      e.filterFieldRef,
+      `${s}.filterFieldRef`
+    )
+  ];
+  if (e.builder !== "semaphor.inputOptions" && i.push(`${s}.builder must be semaphor.inputOptions.`), typeof e.sourceKey != "string" && e.source === void 0 && i.push(`${s} must include source or sourceKey.`), e.source !== void 0) {
+    const n = o(e.source);
+    !n || n.kind !== "semantic" && n.kind !== "physical" ? i.push(`${s}.source.kind must be semantic or physical.`) : i.push(...C(e.source, `${s}.source`));
+  }
+  return o(e.valueFieldRef) || i.push(`${s}.valueFieldRef is required.`), o(e.labelFieldRef) || i.push(`${s}.labelFieldRef is required.`), e.limit !== void 0 && (typeof e.limit != "number" || !Number.isInteger(e.limit) || e.limit <= 0) && i.push(`${s}.limit must be a positive integer.`), i;
+}
+function Rs(t) {
+  var n;
+  const s = o(t.value);
+  if (!s)
+    return [`${t.path} is required for executable views.`];
+  const e = [];
+  if (!ge(s.builder))
+    return e.push(`${t.path}.builder must be a supported SDK builder.`), e;
+  t.sdkBuilder && s.builder !== t.sdkBuilder && e.push(`${t.path}.builder must match sdkBuilder.`), t.queryKind && k(t.queryKind) && s.builder !== Fs(t.queryKind) && e.push(`${t.path}.builder must match queryKind.`);
+  const i = o(s.spec);
+  if (!i)
+    return e.push(`${t.path}.spec must be an object.`), e;
+  switch (s.builder) {
+    case "semaphor.metric":
+      e.push(
+        ...A(
+          i,
+          pe,
+          `${t.path}.spec`
+        ),
+        ..._(i, t.path),
+        ...F(i.measures, `${t.path}.spec.measures`),
+        ...S(
+          i.primaryMeasure,
+          `${t.path}.spec.primaryMeasure`
+        ),
+        ...S(
+          i.dateField,
+          `${t.path}.spec.dateField`
+        ),
+        ...x(
+          i.dimensions,
+          `${t.path}.spec.dimensions`
+        ),
+        ...K(i.orderBy, `${t.path}.spec.orderBy`),
+        ...N(i.filters, `${t.path}.spec.filters`)
+      );
+      break;
+    case "semaphor.analysis":
+      e.push(
+        ...A(
+          i,
+          us,
+          `${t.path}.spec`
+        ),
+        ..._(i, t.path),
+        ...F(i.measures, `${t.path}.spec.measures`),
+        ...S(
+          i.primaryMeasure,
+          `${t.path}.spec.primaryMeasure`
+        ),
+        ...S(
+          i.dateField,
+          `${t.path}.spec.dateField`
+        ),
+        ...x(
+          i.dimensions,
+          `${t.path}.spec.dimensions`
+        ),
+        ...K(i.orderBy, `${t.path}.spec.orderBy`),
+        ...N(i.filters, `${t.path}.spec.filters`),
+        ...Cs(i, `${t.path}.spec`)
+      );
+      break;
+    case "semaphor.records":
+      e.push(
+        ...A(
+          i,
+          ls,
+          `${t.path}.spec`
+        ),
+        ..._(i, t.path),
+        ...F(i.fields, `${t.path}.spec.fields`),
+        ...S(
+          i.dateField,
+          `${t.path}.spec.dateField`
+        ),
+        ...K(i.orderBy, `${t.path}.spec.orderBy`),
+        ...N(i.filters, `${t.path}.spec.filters`),
+        ...js(
+          i.totals,
+          `${t.path}.spec.totals`
+        )
+      );
+      break;
+    case "semaphor.matrix": {
+      const { id: a, label: l, matrixWindowRequest: u, ...d } = i;
+      for (const [I, j] of Object.entries({ id: a, label: l }))
+        j !== void 0 && (typeof j != "string" || !j.trim()) && e.push(`${t.path}.spec.${I} must be a nonempty string.`);
+      const b = ce.safeParse({
+        intent: { ...d, kind: "matrix" },
+        matrixWindowRequest: u
+      });
+      b.success || e.push(...b.error.issues.map((I) => `${t.path}.spec.${I.path.join(".")}: ${I.message}`));
+      break;
+    }
+    case "semaphor.sql":
+      e.push(
+        ...A(
+          i,
+          ds,
+          `${t.path}.spec`
+        ),
+        ..._(i, t.path)
+      ), ((n = o(i.source)) == null ? void 0 : n.kind) !== "sql" && e.push(`${t.path}.spec.source.kind must be sql.`), (typeof i.sql != "string" || !i.sql.trim()) && e.push(`${t.path}.spec.sql is required.`), e.push(
+        ...x(
+          i.fields,
+          `${t.path}.spec.fields`
+        )
+      );
+      break;
+  }
+  return e;
+}
+function Cs(t, s) {
+  const e = [];
+  if (t.driverMode !== void 0 && !os.has(t.driverMode) && e.push(`${s}.driverMode must be a supported analysis driver mode.`), t.includePopulation !== void 0 && typeof t.includePopulation != "boolean" && e.push(`${s}.includePopulation must be a boolean.`), t.calendarContext !== void 0) {
+    const i = o(t.calendarContext);
+    if (!i)
+      e.push(`${s}.calendarContext must be an object.`);
+    else {
+      i.tz !== void 0 && typeof i.tz != "string" && e.push(`${s}.calendarContext.tz must be a string.`), i.weekStart !== void 0 && (typeof i.weekStart != "number" || !Number.isInteger(i.weekStart) || i.weekStart < 0 || i.weekStart > 6) && e.push(
+        `${s}.calendarContext.weekStart must be an integer between 0 and 6.`
+      );
+      const n = i.anchor;
+      if (n !== void 0 && n !== "now") {
+        const a = o(n);
+        (!a || typeof a.iso != "string" || !a.iso.trim()) && e.push(`${s}.calendarContext.anchor must be now or { iso }.`);
+      }
+    }
+  }
+  return e;
+}
+function js(t, s) {
+  if (t === void 0)
+    return [];
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  return e.mode !== "server" && i.push(`${s}.mode must be server.`), !Array.isArray(e.measures) || e.measures.length === 0 ? i.push(`${s}.measures must include at least one measure.`) : e.measures.forEach((n, a) => {
+    var l;
+    i.push(
+      ...be(
+        n,
+        `${s}.measures.${a}`
+      )
+    ), ((l = o(n)) == null ? void 0 : l.role) !== "measure" && i.push(`${s}.measures.${a}.role must be measure.`);
+  }), i;
+}
+function A(t, s, e) {
+  const i = [];
+  return Object.keys(t).forEach((n) => {
+    s.has(n) || i.push(`${e}.${n} is not supported for this SDK builder.`);
+  }), i;
+}
+function _(t, s) {
+  return o(t.source) ? C(t.source, `${s}.spec.source`) : [`${s}.spec.source must be an object.`];
+}
+function F(t, s) {
+  const e = Es(t, s);
+  return Array.isArray(t) && t.forEach((i, n) => {
+    e.push(...f(i, `${s}.${n}`));
+  }), e;
+}
+function x(t, s) {
+  if (t === void 0)
+    return [];
+  if (!Array.isArray(t))
+    return [`${s} must be an array.`];
+  const e = [];
+  return t.forEach((i, n) => {
+    e.push(...f(i, `${s}.${n}`));
+  }), e;
+}
+function K(t, s) {
+  if (t === void 0)
+    return [];
+  const e = o(t);
+  return e ? [
+    ...f(e.field, `${s}.field`),
+    ...qs(e.direction, `${s}.direction`)
+  ] : [`${s} must be an object.`];
+}
+function qs(t, s) {
+  return t === "asc" || t === "desc" ? [] : [`${s} must be asc or desc.`];
+}
+function N(t, s) {
+  if (t === void 0)
+    return [];
+  if (!Array.isArray(t))
+    return [`${s} must be an array.`];
+  const e = [];
+  return t.forEach((i, n) => {
+    const a = o(i);
+    if (!a) {
+      e.push(`${s}.${n} must be an object.`);
+      return;
+    }
+    e.push(
+      ...f(a.field, `${s}.${n}.field`)
+    );
+  }), e;
+}
+function Es(t, s) {
+  return !Array.isArray(t) || t.length === 0 ? [`${s} must be a non-empty array.`] : [];
+}
+function Fs(t) {
+  switch (t) {
+    case "metric":
+      return "semaphor.metric";
+    case "records":
+      return "semaphor.records";
+    case "matrix":
+      return "semaphor.matrix";
+    case "analysis":
+      return "semaphor.analysis";
+    case "sql_fallback":
+      return "semaphor.sql";
+  }
+}
+function xs(t) {
+  const s = o(t.computation), e = o(t.visualSpec);
+  return (s == null ? void 0 : s.kind) === "presentation_only" || (s == null ? void 0 : s.kind) === "derived" || (s == null ? void 0 : s.kind) === "unsupported" || t.visual === "text_block" || (e == null ? void 0 : e.visualType) === "text_block";
+}
+function Ks(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  return cs.has(e.visualType) || i.push(`${s}.visualType must be a supported visual type.`), e.limit !== void 0 && (typeof e.limit != "number" || !Number.isInteger(e.limit) || e.limit <= 0) && i.push(`${s}.limit must be a positive integer.`), e.tableBehavior !== void 0 && i.push(
+    ...Ns(
+      e.tableBehavior,
+      `${s}.tableBehavior`
+    )
+  ), i;
+}
+function Ns(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  return e.tableMode !== "bounded" && e.tableMode !== "server_paginated" && e.tableMode !== "server_windowed" && i.push(`${s}.tableMode must be a supported table mode.`), i.push(
+    ...Os(e.height, `${s}.height`),
+    ...Bs(e.pagination, `${s}.pagination`),
+    ...Ts(e.sorting, `${s}.sorting`),
+    ...Ms(e.totals, `${s}.totals`)
+  ), typeof e.serverSideRequired != "boolean" && i.push(`${s}.serverSideRequired must be a boolean.`), i;
+}
+function Os(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  return (typeof e.maxPx != "number" || !Number.isInteger(e.maxPx) || e.maxPx <= 0) && i.push(`${s}.maxPx must be a positive integer.`), e.scroll !== "vertical" && e.scroll !== "both" && i.push(`${s}.scroll must be vertical or both.`), typeof e.stickyHeader != "boolean" && i.push(`${s}.stickyHeader must be a boolean.`), i;
+}
+function Bs(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  return e.mode !== "none" && e.mode !== "server" && e.mode !== "client_for_bounded_rows" && i.push(`${s}.mode must be a supported pagination mode.`), e.pageSize !== void 0 && (typeof e.pageSize != "number" || !Number.isInteger(e.pageSize) || e.pageSize <= 0) && i.push(`${s}.pageSize must be a positive integer.`), e.readsFrom !== void 0 && e.readsFrom !== "result.pagination" && i.push(`${s}.readsFrom must be result.pagination.`), i;
+}
+function Ts(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  return e.mode !== "server" && e.mode !== "client_for_bounded_rows" && i.push(`${s}.mode must be a supported sorting mode.`), e.defaultField !== void 0 && (typeof e.defaultField != "string" || !e.defaultField.trim()) && i.push(`${s}.defaultField must be a non-empty string.`), e.defaultDirection !== void 0 && e.defaultDirection !== "asc" && e.defaultDirection !== "desc" && i.push(`${s}.defaultDirection must be asc or desc.`), e.resetPageOnChange !== void 0 && typeof e.resetPageOnChange != "boolean" && i.push(`${s}.resetPageOnChange must be a boolean.`), i;
+}
+function Ms(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  return e.mode !== "none" && e.mode !== "server" && e.mode !== "local" ? (i.push(`${s}.mode must be none, server, or local.`), i) : e.mode === "none" ? (e.measures !== void 0 && i.push(`${s}.measures is not allowed when mode is none.`), e.label !== void 0 && i.push(`${s}.label is not allowed when mode is none.`), i) : e.mode === "server" ? (!Array.isArray(e.measures) || e.measures.length === 0 ? i.push(
+    `${s}.measures must include at least one measure when mode is server.`
+  ) : e.measures.forEach((n, a) => {
+    var l;
+    i.push(
+      ...be(
+        n,
+        `${s}.measures.${a}`
+      )
+    ), ((l = o(n)) == null ? void 0 : l.role) !== "measure" && i.push(`${s}.measures.${a}.role must be measure.`);
+  }), e.label !== void 0 && i.push(`${s}.label is not allowed when mode is server.`), i) : (e.mode === "local" && (e.label !== "Displayed rows" && e.label !== "Current page" && i.push(
+    `${s}.label must be Displayed rows or Current page when mode is local.`
+  ), e.measures !== void 0 && i.push(`${s}.measures is not allowed when mode is local.`)), i);
+}
+function Ds(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  switch (e.kind) {
+    case "server_query":
+      k(e.queryKind) || i.push(
+        `${s}.queryKind must be a supported codegen query kind.`
+      ), e.queryOwnership !== void 0 && e.queryOwnership !== "view_owned" && e.queryOwnership !== "shared_query" && i.push(
+        `${s}.queryOwnership must be view_owned or shared_query.`
+      ), e.sourceKeys !== void 0 && !h(e.sourceKeys) && i.push(`${s}.sourceKeys must be an array of strings.`), e.fieldNames !== void 0 && !h(e.fieldNames) && i.push(`${s}.fieldNames must be an array of strings.`);
+      break;
+    case "derived":
+      (typeof e.upstreamViewId != "string" || !e.upstreamViewId.trim()) && i.push(`${s}.upstreamViewId is required.`), (typeof e.derivation != "string" || !e.derivation.trim()) && i.push(`${s}.derivation is required.`);
+      break;
+    case "presentation_only":
+      break;
+    case "unsupported":
+      (typeof e.reason != "string" || !e.reason.trim()) && i.push(`${s}.reason is required.`), (typeof e.suggestedModelingFix != "string" || !e.suggestedModelingFix.trim()) && i.push(`${s}.suggestedModelingFix is required.`);
+      break;
+    default:
+      i.push(`${s}.kind must be a supported computation kind.`);
+  }
+  return i;
+}
+function Ps(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  for (const a of ["title", "requestedQuestion", "suggestedModelingFix"])
+    (typeof e[a] != "string" || !e[a].trim()) && i.push(`${s}.${a} is required.`);
+  return ps.has(e.reason) || i.push(
+    `${s}.reason must be a supported unsupported insight reason.`
+  ), (e.relationshipCandidate !== void 0 || e.nextRepairAction !== void 0) && e.reason !== "missing_relationship" && i.push(
+    `${s} relationship repair metadata is only valid for missing_relationship unsupported insights.`
+  ), e.diagnostic !== void 0 && i.push(
+    ...Vs(
+      e.diagnostic,
+      `${s}.diagnostic`,
+      e.reason
+    )
+  ), e.relationshipCandidate !== void 0 && i.push(
+    ...zs(
+      e.relationshipCandidate,
+      `${s}.relationshipCandidate`
+    )
+  ), e.nextRepairAction !== void 0 && i.push(
+    ...Us(
+      e.nextRepairAction,
+      `${s}.nextRepairAction`
+    )
+  ), i;
+}
+function Vs(t, s, e) {
+  const i = o(t);
+  if (!i)
+    return [`${s} must be an object.`];
+  const n = [], a = /* @__PURE__ */ new Set([
+    "kind",
+    "inputId",
+    "inputLabel",
+    "optionSource",
+    "optionField",
+    "missingEvidence"
+  ]);
+  Object.keys(i).forEach((u) => {
+    a.has(u) || n.push(
+      `${s}.${u} is not supported; raw identifier diagnostics support only kind, inputId, inputLabel, optionSource, optionField, and missingEvidence.`
+    );
+  }), e !== "raw_identifier_filter_options" && n.push(
+    `${s} is only valid for raw_identifier_filter_options unsupported insights.`
+  ), i.kind !== "raw_identifier_filter_options" && n.push(`${s}.kind must be raw_identifier_filter_options.`);
+  for (const u of ["inputId", "inputLabel"])
+    (typeof i[u] != "string" || !i[u].trim()) && n.push(`${s}.${u} must be a non-empty string.`);
+  n.push(
+    ...M(
+      i.optionSource,
+      `${s}.optionSource`
+    )
+  ), n.push(
+    ...he(
+      i.optionField,
+      `${s}.optionField`
+    )
+  );
+  const l = /* @__PURE__ */ new Set([
+    "display_field",
+    "relationship_display_path"
+  ]);
+  return !Array.isArray(i.missingEvidence) || i.missingEvidence.length === 0 ? n.push(`${s}.missingEvidence must be a non-empty evidence array.`) : i.missingEvidence.forEach((u, d) => {
+    l.has(u) || n.push(
+      `${s}.missingEvidence.${d} must be display_field or relationship_display_path.`
+    );
+  }), n;
+}
+function Us(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [], n = /* @__PURE__ */ new Set(["tool", "reason"]);
+  return Object.keys(e).forEach((a) => {
+    n.has(a) || i.push(
+      `${s}.${a} is not supported; repair actions support only tool and reason.`
+    );
+  }), e.tool !== "semaphor_propose_semantic_model_change" && i.push(`${s}.tool must be semaphor_propose_semantic_model_change.`), e.reason !== "missing_relationship" && i.push(`${s}.reason must be missing_relationship.`), i;
+}
+function zs(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [], n = /* @__PURE__ */ new Set([
+    "source",
+    "sourceFields",
+    "target",
+    "targetFields"
+  ]);
+  Object.keys(e).forEach((a) => {
+    n.has(a) || i.push(
+      `${s}.${a} is not supported; relationship candidates support only source, sourceFields, target, and targetFields.`
+    );
+  }), i.push(
+    ...M(e.source, `${s}.source`)
+  ), i.push(
+    ...M(e.target, `${s}.target`)
+  );
+  for (const a of ["sourceFields", "targetFields"]) {
+    const l = e[a];
+    if (!Array.isArray(l) || l.length === 0) {
+      i.push(`${s}.${a} must be a non-empty endpoint field array.`);
+      continue;
+    }
+    l.forEach((u, d) => {
+      i.push(
+        ...he(u, `${s}.${a}.${d}`)
+      );
+    });
+  }
+  return i;
+}
+function he(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [], n = /* @__PURE__ */ new Set(["name", "label", "role", "dataType"]);
+  return Object.keys(e).forEach((a) => {
+    n.has(a) || i.push(
+      `${s}.${a} is not supported; relationship candidate fields are scoped by their endpoint and support only name, label, role, and dataType.`
+    );
+  }), (typeof e.name != "string" || !e.name.trim()) && i.push(`${s}.name must be a non-empty string.`), e.role !== void 0 && (typeof e.role != "string" || !["dimension", "measure", "date", "id", "unknown"].includes(e.role)) && i.push(
+    `${s}.role must be dimension, measure, date, id, or unknown.`
+  ), e.dataType !== void 0 && (typeof e.dataType != "string" || !["string", "number", "boolean", "date", "datetime", "unknown"].includes(
+    e.dataType
+  )) && i.push(
+    `${s}.dataType must be string, number, boolean, date, datetime, or unknown.`
+  ), i;
+}
+function M(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [], n = /* @__PURE__ */ new Set([
+    "kind",
+    "domainId",
+    "datasetName",
+    "datasetId",
+    "label",
+    "sourceKey"
+  ]);
+  return Object.keys(e).forEach((a) => {
+    n.has(a) || i.push(
+      `${s}.${a} is not supported; relationship candidate sources support only semantic identity fields.`
+    );
+  }), e.kind !== "semantic" && i.push(`${s} must use semantic source identity.`), (typeof e.domainId != "string" || !e.domainId.trim() || typeof e.datasetName != "string" || !e.datasetName.trim()) && i.push(`${s} must include semantic domainId and datasetName.`), i;
+}
+function k(t) {
+  return rs.has(t);
+}
+function ge(t) {
+  return ns.has(t);
+}
+function S(t, s) {
+  return t === void 0 ? [] : f(t, s);
+}
+function f(t, s) {
+  const e = o(t);
+  if (!e)
+    return [`${s} must be an object.`];
+  const i = [];
+  return (typeof e.name != "string" || !e.name.trim()) && i.push(`${s}.name is required.`), !e.source && typeof e.sourceKey != "string" && i.push(`${s} must include source or sourceKey.`), e.aggregate !== void 0 && !as.has(e.aggregate) && i.push(`${s}.aggregate must be a supported aggregate function.`), i;
+}
+function be(t, s) {
+  const e = o(t), i = f(t, s);
+  if (!e || typeof e.sourceKey == "string" && e.sourceKey.trim())
+    return i;
+  if (e.source !== void 0) {
+    const a = C(
+      e.source,
+      `${s}.source`
+    );
+    return a.length === 0 || i.push(...a), i;
+  }
+  return i.includes(`${s} must include source or sourceKey.`) || i.push(`${s} must include source or sourceKey.`), i;
+}
+function o(t) {
+  return t && typeof t == "object" && !Array.isArray(t) ? t : void 0;
+}
+function h(t) {
+  return Array.isArray(t) && t.every((s) => typeof s == "string");
+}
+const Ls = r.union([
+  Ne,
+  Oe,
+  Be,
+  Te,
+  le
+]), Gs = r.object({
+  status: r.enum([
+    "not_required",
+    "resolved",
+    "missing",
+    "ambiguous",
+    "fanout_risk",
+    "unknown"
+  ]),
+  requiredSources: r.array(q).optional(),
+  relationshipsUsed: r.array(r.string()).optional(),
+  missingSources: r.array(r.string()).optional(),
+  warnings: r.array(r.string()).optional(),
+  message: r.string().optional(),
+  recommendedNextStep: r.string().optional(),
+  joinPlanSummary: r.object({
+    baseSource: q.optional(),
+    joinedSources: r.array(q).optional(),
+    joinCount: r.number().optional()
+  }).passthrough().optional(),
+  fanoutRisk: r.object({
+    status: r.enum(["none", "warning", "error", "unknown"]),
+    message: r.string().optional()
+  }).passthrough().optional()
+}).passthrough(), Z = r.enum([
+  "ambiguous_fields",
+  "empty_result",
+  "missing_grounded_fields",
+  "missing_relationship",
+  "no_grounded_query",
+  "partial_result",
+  "presentation_incomplete",
+  "query_validation_failed",
+  "unsafe_join"
+]), ve = r.object({
+  version: r.literal(1),
+  status: r.enum(["answered", "partial", "blocked"]),
+  summary: r.string(),
+  answered: r.array(
+    r.object({
+      slotId: r.string().optional(),
+      queryId: r.string().optional(),
+      summary: r.string(),
+      evidenceIds: r.array(r.string()).optional(),
+      fieldsUsed: r.array(P).optional()
+    }).passthrough()
+  ),
+  blocked: r.array(
+    r.object({
+      slotId: r.string().optional(),
+      queryId: r.string().optional(),
+      reasonCode: Z,
+      message: r.string(),
+      missingFields: r.array(r.string()).optional(),
+      availableFields: r.array(r.string()).optional(),
+      ambiguousFields: r.array(r.string()).optional(),
+      missingRelationships: r.array(r.string()).optional(),
+      evidenceIds: r.array(r.string()).optional(),
+      neededFromUser: r.array(r.string()).optional(),
+      recommendedNextStep: r.string().optional()
+    }).passthrough()
+  ),
+  semanticModelRecommendations: r.array(
+    r.object({
+      reasonCode: Z,
+      message: r.string(),
+      recommendedNextStep: r.string().optional()
+    }).passthrough()
+  ).optional()
+}).passthrough(), Se = r.object({
+  scope: r.literal("filtered_query"),
+  measures: r.record(Me)
+}).passthrough(), $e = r.object({
+  answeredObligations: r.array(r.string()),
+  missingObligations: r.array(r.string()),
+  warnings: r.array(De).optional()
+}).passthrough(), ke = r.object({
+  intentId: r.string().optional(),
+  queryId: r.string().optional(),
+  status: r.enum(["answered", "partial", "failed"]),
+  resultShape: r.enum([
+    "metric",
+    "records",
+    "inputOptions",
+    "sql",
+    "matrix",
+    "period_change",
+    "analysis"
+  ]).optional(),
+  intent: r.unknown().optional(),
+  compiledQuery: r.unknown().optional(),
+  fieldsUsed: r.array(P).optional(),
+  result: Ls.optional(),
+  validation: ie,
+  coverage: $e.optional(),
+  missingFields: r.array(r.string()).optional(),
+  warnings: r.array(r.string()).optional(),
+  relationshipDiagnostics: Gs.optional(),
+  diagnosticFeedback: ve.optional(),
+  population: Se.optional(),
+  metadata: r.record(r.string(), r.unknown()).optional()
+}).passthrough(), Qs = ke;
+function Hs(t) {
+  switch (t) {
+    case "boolean":
+      return r.boolean().optional();
+    case "compactExecutionFieldArray":
+      return r.array(Ue).optional();
+    case "coverage":
+      return $e.optional();
+    case "diagnosticFeedback":
+      return ve.optional();
+    case "executionFieldArray":
+      return r.array(P).optional();
+    case "executionResult":
+      return Qs.optional();
+    case "number":
+      return r.number().finite().optional();
+    case "population":
+      return Se.optional();
+    case "record":
+      return m.optional();
+    case "recordArray":
+      return Ve.optional();
+    case "responseDetail":
+      return r.enum(["compact", "standard", "debug"]).optional();
+    case "string":
+      return r.string().optional();
+    case "stringArray":
+      return r.array(r.string()).optional();
+    case "unknown":
+      return r.unknown().optional();
+    case "unknownArray":
+      return r.array(r.unknown()).optional();
+    case "validationResult":
+      return ie.optional();
+  }
+}
+const Ws = Object.fromEntries(
+  Object.entries(V).map(
+    ([t, s]) => [t, Hs(s)]
+  )
+), Ys = r.object(Ws).strict(), z = r.object({
+  sourceKey: r.string().optional(),
+  kind: r.enum(["semantic", "physical", "sql"]).optional(),
+  domainId: r.string().optional(),
+  datasetName: r.string().optional(),
+  datasetId: r.string().optional(),
+  connectionId: r.string().optional(),
+  tableName: r.string().optional(),
+  label: r.string().optional()
+}).passthrough(), $ = r.object({
+  name: r.string(),
+  label: r.string().optional(),
+  role: r.enum(["dimension", "measure", "date", "id", "unknown"]).optional(),
+  dataType: r.enum(["string", "number", "boolean", "date", "datetime", "unknown"]).optional(),
+  aggregate: Pe.optional(),
+  sourceKey: r.string().optional(),
+  source: z.optional()
+}).passthrough(), we = r.object({
+  id: r.string().optional(),
+  builder: r.literal("semaphor.inputOptions"),
+  source: z.optional(),
+  sourceKey: r.string().optional(),
+  valueFieldRef: $,
+  labelFieldRef: $,
+  filterFieldRef: $.optional(),
+  population: r.unknown().optional(),
+  dependencies: r.unknown().optional(),
+  limit: r.number().int().positive().optional(),
+  spec: m.optional()
+}).passthrough(), Ie = r.object({
+  appliesToViewIds: r.array(r.string()).optional(),
+  viewId: r.string().optional(),
+  fieldRef: $,
+  relationshipHint: r.unknown().optional(),
+  relationshipsUsed: r.array(m).optional()
+}).passthrough(), Js = r.object({
+  id: r.string(),
+  label: r.string().optional(),
+  type: r.string().optional(),
+  serverSide: r.boolean().optional(),
+  fieldRef: $.optional(),
+  optionQuery: we.optional(),
+  bindings: r.array(Ie).optional(),
+  appliesToViewIds: r.array(r.string()),
+  relationshipHint: r.unknown().optional(),
+  relationshipsUsed: r.array(m).optional()
+}).passthrough(), Zs = r.object({
+  builder: r.enum([
+    "semaphor.metric",
+    "semaphor.records",
+    "semaphor.matrix",
+    "semaphor.analysis",
+    "semaphor.sql"
+  ]),
+  spec: m,
+  fallbackReason: m.optional()
+}).passthrough(), Xs = r.object({
+  id: r.string(),
+  title: r.string().optional(),
+  purpose: r.string().optional(),
+  sourcePresentation: r.object({
+    sourceKeys: r.array(r.string()).optional(),
+    sourceLabels: r.array(r.string()).optional()
+  }).passthrough().optional(),
+  visual: r.string().optional(),
+  visualSpec: m.optional(),
+  queryKind: r.enum(["metric", "records", "matrix", "analysis", "sql_fallback"]).optional(),
+  sdkBuilder: r.enum([
+    "semaphor.metric",
+    "semaphor.records",
+    "semaphor.matrix",
+    "semaphor.analysis",
+    "semaphor.sql"
+  ]).optional(),
+  sdkSpec: Zs.optional(),
+  fields: r.array($).optional(),
+  computation: m.optional(),
+  uxExpectations: r.array(r.string()).optional(),
+  validation: m.optional()
+}).passthrough(), et = r.object({
+  inputId: r.string(),
+  label: r.string().optional(),
+  type: r.string().optional(),
+  serverSide: r.boolean().optional(),
+  fieldRef: $.optional(),
+  optionQuery: we.optional(),
+  bindings: r.array(Ie),
+  appliesToViewIds: r.array(r.string()),
+  notAppliedToViewIds: r.array(r.string())
+}).passthrough(), wt = r.object({
+  schemaVersion: r.literal(T),
+  title: r.string(),
+  purpose: r.string().optional(),
+  userGoal: r.string().optional(),
+  nextStep: r.string().optional(),
+  sources: r.array(z),
+  inputs: r.array(Js),
+  views: r.array(Xs),
+  filterContracts: r.array(et),
+  implementationChecklist: r.object({
+    schemaVersion: r.string().optional(),
+    requiredDevtools: r.object({
+      mountRootDevtools: r.boolean(),
+      providerDebugBridge: r.string().optional(),
+      panelPosition: r.string().optional(),
+      forbidden: r.array(r.string()).optional()
+    }).passthrough(),
+    requiredInputOptions: r.array(m),
+    filterScopeByInput: r.array(m),
+    bindingsByView: r.record(r.string(), r.array(m)),
+    validationCommands: r.array(r.string()),
+    browserSmokeChecks: r.array(r.string())
+  }).passthrough(),
+  nextRequiredTool: r.object({
+    name: r.string(),
+    reason: r.string().optional()
+  }).optional(),
+  unsupportedInsights: r.array(
+    r.object({
+      title: r.string(),
+      requestedQuestion: r.string(),
+      reason: r.string(),
+      suggestedModelingFix: r.string()
+    }).passthrough()
+  ).optional(),
+  assumptions: r.array(r.string()).optional(),
+  validation: m.optional()
+}).passthrough().superRefine((t, s) => {
+  const e = me(t);
+  for (const i of e.issues)
+    s.addIssue({
+      code: r.ZodIssueCode.custom,
+      message: i
+    });
+}), st = new Set(
+  Object.keys(V)
+);
+function It() {
+  return Object.keys(
+    V
+  );
+}
+function tt(t) {
+  return st.has(t);
+}
+function At(t) {
+  if (!t || typeof t != "object" || Array.isArray(t))
+    throw new Error("Semaphor analyze result must be an object.");
+  const e = Object.keys(t).filter(
+    (i) => !tt(i)
+  );
+  if (e.length)
+    throw new Error(
+      `Semaphor analyze result contains unsupported top-level field(s): ${e.join(", ")}.`
+    );
+  return Ys.parse(t);
+}
+const Ae = 100, R = "selection:";
+function _e(t) {
+  return [
+    ne(t.source),
+    He(t.name),
+    t.sourceField ?? ""
+  ].join("::");
+}
+function _t(t) {
+  return `${R}${t}`;
+}
+function it(t) {
+  return t.startsWith(R) && t.length > R.length;
+}
+function Rt(t) {
+  return it(t) ? t.slice(R.length) : void 0;
+}
+function Re(t) {
+  if (!t) return "";
+  const s = t.calendar.fiscalCalendar;
+  return JSON.stringify([
+    t.granularity,
+    t.calendar.tz,
+    t.calendar.weekStart,
+    s ? [s.kind, s.yearStartMonth] : null
+  ]);
+}
+function rt(t) {
+  return JSON.stringify([
+    _e(t.field),
+    t.operator,
+    t.operator === "isNull" ? null : t.value,
+    Re(t.temporalBucket)
+  ]);
+}
+function X(t) {
+  return JSON.stringify(t.conditions.map(rt).sort());
+}
+function D(t) {
+  return JSON.stringify([
+    ne(t.field.source),
+    t.field.name,
+    t.operator,
+    t.operator === "isNull" ? null : t.value,
+    Re(t.temporalBucket)
+  ]);
+}
+function ee(t) {
+  return JSON.stringify(
+    t.conditions.map(D).sort()
+  );
+}
+function Ct(t) {
+  const s = t.map((e) => e.id);
+  if (new Set(s).size !== s.length)
+    throw new Error("Data App selections require one active selection per id.");
+  return t.map((e) => ({
+    ...e,
+    tuples: e.tuples.map((i) => ({
+      ...i,
+      conditions: [...i.conditions].sort(
+        (n, a) => O(
+          D(n),
+          D(a)
+        )
+      )
+    })).sort(
+      (i, n) => O(
+        ee(i),
+        ee(n)
+      )
+    )
+  })).sort((e, i) => O(e.id, i.id));
+}
+function O(t, s) {
+  return t < s ? -1 : t > s ? 1 : 0;
+}
+function jt(t, s) {
+  return X(t) === X(s);
+}
+const nt = "(Blank)";
+function qt(t) {
+  return t.conditions.map((s) => s.label ? s.label : s.operator === "isNull" || s.value === null ? nt : String(s.value)).join(" · ");
+}
+const at = r.union([
+  ze,
+  Le
+]), ot = r.object({
+  name: r.string().min(1),
+  source: at,
+  dataType: r.enum(["string", "number", "boolean", "date", "datetime"]),
+  sourceField: r.string().min(1).optional()
+}).strict(), ut = r.object({
+  field: ot,
+  operator: r.enum(["=", "isNull"]),
+  value: r.union([r.string(), r.number().finite(), r.null()]),
+  label: r.string().optional(),
+  temporalBucket: re.optional()
+}).strict().superRefine((t, s) => {
+  t.operator === "isNull" != (t.value === null) && s.addIssue({
+    code: r.ZodIssueCode.custom,
+    message: "isNull carries a null value, and only isNull does.",
+    path: ["value"]
+  });
+}), lt = r.object({
+  conditions: r.array(ut).min(1)
+}).strict().superRefine((t, s) => {
+  const e = t.conditions.map((i) => _e(i.field));
+  new Set(e).size !== e.length && s.addIssue({
+    code: r.ZodIssueCode.custom,
+    message: "A tuple holds one condition per field.",
+    path: ["conditions"]
+  });
+}), Et = r.object({
+  kind: r.literal("selection"),
+  sourceCardId: r.string().min(1),
+  tuples: r.array(lt).min(1).max(Ae)
+}).strict(), dt = r.object({
+  field: Ge,
+  operator: r.enum(["=", "isNull"]),
+  value: r.union([r.string(), r.number().finite(), r.null()]),
+  temporalBucket: re.optional()
+}).strict().superRefine((t, s) => {
+  t.operator === "isNull" != (t.value === null) && s.addIssue({
+    code: r.ZodIssueCode.custom,
+    message: "isNull carries a null value, and only isNull does.",
+    path: ["value"]
+  });
+}), ct = r.object({
+  conditions: r.array(dt).min(1)
+}).strict().superRefine((t, s) => {
+  for (let e = 0; e < t.conditions.length; e += 1) {
+    const i = t.conditions[e];
+    t.conditions.findIndex(
+      (a, l) => l < e && Qe(a.field, i.field)
+    ) !== -1 && s.addIssue({
+      code: r.ZodIssueCode.custom,
+      message: "A selection tuple can contain only one condition per field.",
+      path: ["conditions", e, "field"]
+    });
+  }
+}), Ft = r.object({
+  id: r.string().min(1),
+  tuples: r.array(ct).min(1).max(Ae)
+}).strict(), pt = r.object({
+  runtimeFilters: B.innerType().shape.filters,
+  runtimeSorts: B.innerType().shape.sorts.optional()
+});
+function xt(t) {
+  return pt.parse(t);
+}
+const mt = {
+  // A window executes a governed statement set, not one compiled query.
+  compiledQuery: r.never().optional(),
+  intent: ce.shape.intent,
+  resultShape: r.literal("matrix"),
+  result: le.optional(),
+  metadata: r.object({ rowLimitExceeded: r.boolean(), matrixFailure: U.optional() }).passthrough()
+}, ft = ke.extend(mt), Kt = ft.superRefine((t, s) => {
+  t.status === "failed" == !!t.result && s.addIssue({ code: "custom", message: "Only answered or partial Matrix execution carries a window." }), t.result && t.status === "partial" != t.result.window.failures.length > 0 && s.addIssue({ code: "custom", message: "Matrix execution status must match acquired window failures." });
+});
+export {
+  ts as $,
+  rt as A,
+  X as B,
+  D as C,
+  ee as D,
+  jt as E,
+  qt as F,
+  ot as G,
+  ut as H,
+  lt as I,
+  Et as J,
+  dt as K,
+  ct as L,
+  gt as M,
+  Ye as N,
+  G as O,
+  Je as P,
+  ae as Q,
+  bt as R,
+  T as S,
+  Ze as T,
+  Xe as U,
+  Q as V,
+  U as W,
+  es as X,
+  ue as Y,
+  vt as Z,
+  ss as _,
+  $t as a,
+  H as a0,
+  is as a1,
+  St as a2,
+  pt as a3,
+  xt as a4,
+  Kt as a5,
+  ce as a6,
+  Ft as b,
+  Ct as c,
+  tt as d,
+  V as e,
+  Gs as f,
+  It as g,
+  ve as h,
+  kt as i,
+  Se as j,
+  $e as k,
+  ke as l,
+  Qs as m,
+  Ws as n,
+  Ys as o,
+  At as p,
+  wt as q,
+  le as r,
+  Ls as s,
+  Ae as t,
+  _e as u,
+  me as v,
+  _t as w,
+  it as x,
+  Rt as y,
+  Re as z
+};