react-semaphor 0.1.381 → 0.1.382

package/dist/data-app-sdk-validation/index.js

@@ -1,8 +1,1075 @@
-import "../chunks/validators-CtNmgsvG.js";
-import "../chunks/catalog-field-grounding-BK4BX8sZ.js";
-import "../chunks/source-identity-Dj3dryN9.js";
-import { m, v as i } from "../chunks/validation-BM3-ShHV.js";
+import { b as O } from "../chunks/validators-CHPH6ORs.js";
+import "../chunks/analyze-result-contract-DuhlklhI.js";
+import { s as K, b as q } from "../chunks/source-identity-CN4xiyKJ.js";
+import { toSemaphorMetricIntent as Q, toSemaphorAnalysisIntent as E, toSemaphorRecordsIntent as J, toSemaphorSqlIntent as U, toSemaphorMatrixIntent as W, toSemaphorInputOptionsIntent as L } from "../data-app-sdk-adapters/index.js";
+import { n as A, b as V } from "../chunks/catalog-field-grounding-CJKAqtiC.js";
+function G({
+  intent: e,
+  field: r,
+  catalogField: o,
+  relativePath: t
+}) {
+  const i = Y({
+    intent: e,
+    field: r,
+    relativePath: t
+  });
+  if (!i || i.allowedRelatedRoles.length === 0)
+    return !1;
+  const a = m(
+    r,
+    i.selectedField
+  ), s = H(o), n = f(a);
+  return X(
+    s,
+    i.allowedRelatedRoles
+  ) ? n === s : !1;
+}
+function De(e) {
+  return e.kind === "records" ? oe(e) : e.kind === "metric" ? te(e) : ie(e);
+}
+function H(e) {
+  const r = A(e.role);
+  if (r === "measure")
+    return "measure";
+  if (r === "id")
+    return "id";
+  const o = V(e.dataType);
+  if (r === "date" || o === "date" || o === "datetime")
+    return "date";
+  if (r === "dimension")
+    return "dimension";
+}
+function X(e, r) {
+  return !!(e && r.includes(e));
+}
+function m(e, r) {
+  const o = f(e);
+  if (o)
+    return e.role === o ? e : {
+      ...e,
+      role: o
+    };
+  const t = r ? f(r) : void 0;
+  return t ? {
+    ...e,
+    role: t
+  } : e;
+}
+function u(e, r) {
+  return e.find(
+    (o) => B(o, r)
+  );
+}
+function k(e) {
+  return [
+    ...e.rows.map((r) => r.field),
+    ...(e.columns || []).map((r) => r.field)
+  ];
+}
+function Y({
+  intent: e,
+  field: r,
+  relativePath: o
+}) {
+  if (e.kind === "records")
+    return Z(e, r, o);
+  if (e.kind === "metric")
+    return ee(e, r, o);
+  if (e.kind === "matrix")
+    return re(e, r, o);
+}
+function Z(e, r, o) {
+  if (o.startsWith("spec.fields."))
+    return { allowedRelatedRoles: ["dimension", "date", "id"] };
+  if (o === "spec.dateField" && !e.timeWindow)
+    return { allowedRelatedRoles: ["date"] };
+  if (o === "spec.orderBy.field") {
+    const t = u(
+      M(e),
+      r
+    );
+    return {
+      selectedField: t,
+      allowedRelatedRoles: t ? F(t) : []
+    };
+  }
+}
+function ee(e, r, o) {
+  if (o.startsWith("spec.dimensions."))
+    return { allowedRelatedRoles: ["dimension"] };
+  if (o === "spec.orderBy.field") {
+    const t = u(
+      e.dimensions || [],
+      r
+    );
+    return {
+      selectedField: t,
+      allowedRelatedRoles: t ? ["dimension"] : []
+    };
+  }
+}
+function re(e, r, o) {
+  if (ne(o))
+    return { allowedRelatedRoles: ["dimension", "date"] };
+  if (de(o)) {
+    const t = u(
+      k(e),
+      r
+    );
+    return {
+      selectedField: t,
+      allowedRelatedRoles: g(t)
+    };
+  }
+}
+function oe(e) {
+  var t, i;
+  const r = M(e), o = (t = e.orderBy) != null && t.field ? u(r, e.orderBy.field) : void 0;
+  return R([
+    ...r.map(
+      (a) => l(
+        a,
+        F(a)
+      )
+    ),
+    ...(i = e.orderBy) != null && i.field ? [
+      l(
+        m(
+          e.orderBy.field,
+          o
+        ),
+        o ? F(o) : [],
+        {
+          unsupportedRelatedRoleMessage: "Joined records projections support related sort fields only when the same related field is included in spec.fields.",
+          recommendedNextStep: "Add the related sort field to spec.fields, or keep orderBy fields on the base source."
+        }
+      )
+    ] : []
+  ]);
+}
+function te(e) {
+  var o, t;
+  const r = (o = e.orderBy) != null && o.field ? u(
+    e.dimensions || [],
+    e.orderBy.field
+  ) : void 0;
+  return R([
+    ...e.measures.map((i) => l(i, [])),
+    ...e.primaryMeasure ? [l(e.primaryMeasure, [])] : [],
+    ...(e.dimensions || []).map(
+      (i) => l(i, ["dimension"])
+    ),
+    ...e.dateField ? [l({ ...e.dateField, role: "date" }, [])] : [],
+    ...(t = e.orderBy) != null && t.field ? [
+      l(
+        m(
+          e.orderBy.field,
+          r
+        ),
+        r ? ["dimension"] : [],
+        {
+          unsupportedRelatedRoleMessage: "Joined metric projections support related orderBy fields only when the same related field is declared in spec.dimensions.",
+          recommendedNextStep: "Add the related field as a metric dimension when it should participate in the grouped result, or keep orderBy fields on the base source."
+        }
+      )
+    ] : []
+  ]);
+}
+function ie(e) {
+  const r = [...e.rows, ...e.columns || []];
+  return R([
+    ...r.map(
+      (o) => l(
+        o.field,
+        g(o.field)
+      )
+    ),
+    ...r.flatMap((o) => {
+      var a;
+      if (((a = o.sortBy) == null ? void 0 : a.by.kind) !== "field")
+        return [];
+      const t = o.sortBy.by.field, i = u(
+        k(e),
+        t
+      );
+      return [
+        l(
+          m(t, i),
+          g(i),
+          {
+            unsupportedRelatedRoleMessage: "Joined matrix projections support related axis sort fields only when the same related field is used as a row/column axis.",
+            recommendedNextStep: "Use a related field as a row or column axis, or keep axis sort fields on the base source."
+          }
+        )
+      ];
+    }),
+    ...e.values.map(
+      (o) => l(o.field, [], {
+        unsupportedRelatedRoleMessage: "Joined matrix projections support related row/column dimensions or dates only. Related value fields are not supported in this phase.",
+        recommendedNextStep: "Keep matrix values on the base source, or use governed SQL for unsupported aggregate-safe joined values."
+      })
+    ),
+    ...(e.sort || []).flatMap((o) => {
+      if (o.by.kind !== "field")
+        return [];
+      const t = o.by.field, i = u(
+        k(e),
+        t
+      );
+      return [
+        l(
+          m(t, i),
+          g(i),
+          {
+            unsupportedRelatedRoleMessage: "Joined matrix projections support related top-level sort fields only when the same related field is used as a row/column axis.",
+            recommendedNextStep: "Use a related field as a row or column axis, or keep matrix sort fields on the base source."
+          }
+        )
+      ];
+    })
+  ]);
+}
+function F(e) {
+  const r = e ? f(e) : void 0;
+  return r === "dimension" ? ["dimension"] : r === "date" ? ["date"] : r === "id" ? ["id"] : ["dimension", "date", "id"];
+}
+function g(e) {
+  const r = e ? f(e) : void 0;
+  return r === "date" ? ["date"] : r === "dimension" ? ["dimension"] : [];
+}
+function l(e, r, o = {}) {
+  return {
+    field: m(e),
+    allowedRelatedRoles: r,
+    ...o
+  };
+}
+function R(e) {
+  const r = [];
+  return e.forEach((o) => {
+    r.some(
+      (t) => ae(t, o)
+    ) || r.push(o);
+  }), r;
+}
+function M(e) {
+  const r = [...e.fields];
+  return e.dateField && !r.some(
+    (o) => j(o, e.dateField)
+  ) && r.push({ ...e.dateField, role: "date" }), r;
+}
+function ae(e, r) {
+  return B(e.field, r.field) && e.allowedRelatedRoles.join("|") === r.allowedRelatedRoles.join("|") && (e.unsupportedRelatedRoleMessage || "") === (r.unsupportedRelatedRoleMessage || "") && (e.recommendedNextStep || "") === (r.recommendedNextStep || "");
+}
+function j(e, r) {
+  return K(e, r);
+}
+function B(e, r) {
+  return j(e, r) && se(
+    f(e),
+    f(r)
+  );
+}
+function se(e, r) {
+  return !!(e && (!r || e === r));
+}
+function f(e) {
+  return H(e);
+}
+function ne(e) {
+  const r = e.split(".");
+  return r.length === 4 && r[0] === "spec" && (r[1] === "rows" || r[1] === "columns") && b(r[2]) && r[3] === "field";
+}
+function de(e) {
+  const r = e.split(".");
+  return r.length === 6 && r[0] === "spec" && (r[1] === "rows" || r[1] === "columns") && b(r[2]) && r[3] === "sortBy" && r[4] === "by" && r[5] === "field" || r.length === 5 && r[0] === "spec" && r[1] === "sort" && b(r[2]) && r[3] === "by" && r[4] === "field";
+}
+function b(e) {
+  return e === void 0 || e.trim() === "" ? !1 : Number.isInteger(Number(e)) && Number(e) >= 0;
+}
+function le({
+  intent: e,
+  field: r,
+  relativePath: o,
+  baseCatalog: t,
+  fieldCatalogs: i
+}) {
+  const a = h(r, e.source), s = q(
+    a,
+    e.source
+  );
+  if (!s && !ue(e.source, a))
+    return {
+      ok: !1,
+      code: "invalid_source_ref",
+      message: `Field "${r.name}" references a related Semaphor source outside the query's semantic domain.`,
+      pathSuffix: ".source",
+      source: a
+    };
+  const n = s ? t : S(i, a);
+  if (!n)
+    return {
+      ok: !1,
+      code: "invalid_source_ref",
+      message: `Field "${r.name}" references a Semaphor source that is not present in the visible field catalog.`,
+      pathSuffix: ".source",
+      source: a
+    };
+  const d = v(n, r, e.source);
+  return d ? !s && !ce({
+    intent: e,
+    field: r,
+    catalogField: d,
+    relativePath: o
+  }) ? {
+    ok: !1,
+    code: "unsupported_joined_projection",
+    message: `Field "${r.name}" references a related Semaphor source, but this query kind does not support joined projections for that field yet.`,
+    pathSuffix: ".source",
+    source: a
+  } : {
+    ok: !0,
+    source: a,
+    catalogField: d,
+    usesBaseSource: s
+  } : {
+    ok: !1,
+    code: "missing_field",
+    message: `Field "${r.name}" is not visible on the selected Semaphor source.`,
+    source: a
+  };
+}
+function ce({
+  intent: e,
+  field: r,
+  catalogField: o,
+  relativePath: t
+}) {
+  return G({
+    intent: e,
+    field: r,
+    catalogField: o,
+    relativePath: t
+  });
+}
+function ue(e, r) {
+  return e.kind === "semantic" && r.kind === "semantic" && e.domainId === r.domainId;
+}
+function S(e, r) {
+  return e.find((o) => x(o, r));
+}
+function v(e, r, o) {
+  const t = h(r, o);
+  if (x(e, t))
+    return e.fields.find(
+      (i) => fe(i, r) && x(
+        e,
+        h(i, e.source)
+      )
+    );
+}
+function $(e) {
+  return A(e);
+}
+function h(e, r) {
+  return e.source || r;
+}
+function x(e, r) {
+  return [e.source, ...e.sourceAliases || []].some(
+    (o) => q(o, r)
+  );
+}
+function fe(e, r) {
+  return !!(e.name && r.name && e.name === r.name);
+}
+function pe(e, r = {}) {
+  const o = r.pathPrefix || "analysisOptions";
+  if (e === void 0)
+    return { ok: !0 };
+  if (!e || typeof e != "object" || Array.isArray(e))
+    return c(
+      o,
+      "Data App analysis options must be an object."
+    );
+  const t = e, i = {};
+  if (t.chartTitle !== void 0) {
+    if (typeof t.chartTitle != "string")
+      return c(
+        `${o}.chartTitle`,
+        'Data App analysis option "chartTitle" must be a string.'
+      );
+    i.chartTitle = t.chartTitle;
+  }
+  if (t.chartType !== void 0) {
+    if (typeof t.chartType != "string")
+      return c(
+        `${o}.chartType`,
+        'Data App analysis option "chartType" must be a string.'
+      );
+    i.chartType = t.chartType;
+  }
+  if (t.driverMode !== void 0) {
+    if (!ye(t.driverMode))
+      return c(
+        `${o}.driverMode`,
+        'Data App analysis option "driverMode" must be absolute_delta, largest_negative, largest_positive, positive_and_negative, or all.'
+      );
+    i.driverMode = t.driverMode;
+  }
+  if (t.includePopulation !== void 0) {
+    if (typeof t.includePopulation != "boolean")
+      return c(
+        `${o}.includePopulation`,
+        'Data App analysis option "includePopulation" must be a boolean.'
+      );
+    i.includePopulation = t.includePopulation;
+  }
+  if (t.calendarContext !== void 0) {
+    const a = ge(
+      t.calendarContext,
+      {
+        pathPrefix: `${o}.calendarContext`,
+        validateTimezone: r.validateTimezone
+      }
+    );
+    if (!a.ok)
+      return a;
+    i.calendarContext = a.calendarContext;
+  }
+  return { ok: !0, analysisOptions: i };
+}
+function ze(e) {
+  const r = e.queries.map(
+    (i, a) => me(i, a, {
+      fieldCatalogs: e.fieldCatalogs || [],
+      requireFieldCatalog: !!e.requireFieldCatalog,
+      validateTimezone: e.validateTimezone
+    })
+  ), o = r.flatMap((i) => i.diagnostics), t = r.map((i) => i.executionResult);
+  return {
+    ok: o.every((i) => i.severity !== "error"),
+    diagnostics: o,
+    queries: r,
+    intents: r.flatMap(
+      (i) => i.intent ? [i.intent] : []
+    ),
+    executionResults: t
+  };
+}
+function me(e, r, o) {
+  const t = `queries.${r}`;
+  try {
+    const i = ve(e), a = Ae(e, i), s = O(i), n = [
+      ...$e({
+        querySpec: e,
+        queryId: a,
+        intent: i,
+        pathPrefix: t
+      }),
+      ...s.errors.map(
+        (y) => w(y, {
+          queryHook: e.queryHook,
+          queryId: a,
+          pathPrefix: t,
+          severity: "error",
+          intent: i
+        })
+      ),
+      ...s.warnings.map(
+        (y) => w(y, {
+          queryHook: e.queryHook,
+          queryId: a,
+          pathPrefix: t,
+          severity: "warning",
+          intent: i
+        })
+      ),
+      ...Se({
+        querySpec: e,
+        queryId: a,
+        intent: i,
+        pathPrefix: t,
+        fieldCatalogs: o.fieldCatalogs,
+        requireFieldCatalog: o.requireFieldCatalog
+      }),
+      ...Re({
+        querySpec: e,
+        queryId: a,
+        intent: i,
+        pathPrefix: t,
+        validateTimezone: o.validateTimezone
+      })
+    ], d = Pe(s, n);
+    return {
+      queryHook: e.queryHook,
+      queryId: a,
+      intent: i,
+      diagnostics: n,
+      executionResult: P({
+        intent: i,
+        validation: d,
+        diagnostics: n
+      })
+    };
+  } catch (i) {
+    const a = {
+      severity: "error",
+      code: "invalid_query_spec",
+      message: i instanceof Error ? i.message : String(i),
+      path: t,
+      queryHook: e.queryHook,
+      queryId: N(e.spec)
+    }, s = z([a]);
+    return {
+      queryHook: e.queryHook,
+      queryId: a.queryId,
+      diagnostics: [a],
+      executionResult: P({
+        validation: s,
+        diagnostics: [a]
+      })
+    };
+  }
+}
+function c(e, r) {
+  return {
+    ok: !1,
+    issues: [
+      {
+        code: "invalid_analysis_option",
+        message: r,
+        path: e
+      }
+    ]
+  };
+}
+function T(e) {
+  return !!(e && typeof e == "object" && !Array.isArray(e));
+}
+function ye(e) {
+  return e === "absolute_delta" || e === "largest_negative" || e === "largest_positive" || e === "positive_and_negative" || e === "all";
+}
+function he(e) {
+  return e.trim().length > 0 && !Number.isNaN(Date.parse(e));
+}
+function ge(e, r) {
+  var d;
+  if (!e || typeof e != "object" || Array.isArray(e))
+    return c(
+      r.pathPrefix,
+      'Data App analysis option "calendarContext" must be an object.'
+    );
+  const o = e, t = o.tz, i = o.weekStart, a = o.anchor, s = a && typeof a == "object" && !Array.isArray(a) ? a.iso : void 0, n = typeof t == "string" ? ((d = r.validateTimezone) == null ? void 0 : d.call(r, t)) ?? t : null;
+  return n ? typeof i != "number" || !Number.isInteger(i) || i < 0 || i > 6 ? c(
+    `${r.pathPrefix}.weekStart`,
+    'Data App analysis option "calendarContext.weekStart" must be an integer from 0 to 6.'
+  ) : a !== "now" && !(typeof s == "string" && he(s)) ? c(
+    `${r.pathPrefix}.anchor`,
+    'Data App analysis option "calendarContext.anchor" must be "now" or an object with a valid iso string.'
+  ) : {
+    ok: !0,
+    calendarContext: {
+      tz: n,
+      weekStart: i,
+      anchor: a
+    }
+  } : c(
+    `${r.pathPrefix}.tz`,
+    'Data App analysis option "calendarContext.tz" must be a valid timezone string.'
+  );
+}
+function ve(e) {
+  return qe(e.spec);
+}
+function qe(e) {
+  if (!T(e))
+    throw new Error("useSemaphorQuery spec must be an object.");
+  if (e.queryKind === "metric")
+    return Q(e);
+  if (e.queryKind === "analysis")
+    return E(e);
+  if (e.queryKind === "records")
+    return J(e);
+  if (e.queryKind === "sql")
+    return U(e);
+  if (e.queryKind === "matrix")
+    return W(e);
+  if (e.queryKind === "inputOptions")
+    return L(e);
+  throw new Error(
+    "useSemaphorQuery spec.queryKind must be metric, analysis, records, inputOptions, sql, or matrix."
+  );
+}
+function Se(e) {
+  if (e.intent.kind === "sql")
+    return [];
+  if (e.fieldCatalogs.length === 0 && !e.requireFieldCatalog)
+    return [];
+  const r = S(
+    e.fieldCatalogs,
+    e.intent.source
+  );
+  if (!r)
+    return [
+      {
+        severity: "error",
+        code: "invalid_source_ref",
+        message: `Source ref for ${e.querySpec.queryHook} does not match a visible Semaphor source.`,
+        path: `${e.pathPrefix}.spec.source`,
+        queryHook: e.querySpec.queryHook,
+        queryId: e.queryId,
+        intentId: e.intent.id,
+        source: e.intent.source
+      }
+    ];
+  const o = ke({
+    ...e,
+    catalog: r
+  }), t = {
+    ...r,
+    fields: [
+      ...r.fields,
+      ..._e(e.intent, r, e.intent.source)
+    ]
+  };
+  return [
+    ...o,
+    ...Ie({
+      ...e,
+      fieldCatalogs: e.fieldCatalogs
+    }),
+    ...Fe({
+      ...e,
+      catalog: t,
+      fieldCatalogs: e.fieldCatalogs
+    }),
+    ...be({
+      ...e,
+      catalog: t,
+      fieldCatalogs: e.fieldCatalogs
+    })
+  ];
+}
+function Ie(e) {
+  var o;
+  if (e.intent.kind !== "inputOptions" || ((o = e.intent.population) == null ? void 0 : o.kind) !== "related_population")
+    return [];
+  const r = e.intent.population.baseSource;
+  return S(e.fieldCatalogs, r) ? [] : [
+    {
+      severity: "error",
+      code: "invalid_source_ref",
+      message: "Input options related population baseSource does not match a visible Semaphor source.",
+      path: `${e.pathPrefix}.spec.population.baseSource`,
+      queryHook: e.querySpec.queryHook,
+      queryId: e.queryId,
+      intentId: e.intent.id,
+      source: r
+    }
+  ];
+}
+function ke(e) {
+  const r = D(e.intent);
+  if (r.length === 0)
+    return [];
+  const o = [], t = /* @__PURE__ */ new Set();
+  return r.forEach((i, a) => {
+    const s = `${e.pathPrefix}.spec.derivedFields.${a}`, n = $(i.name);
+    n && (t.has(n) && o.push({
+      severity: "error",
+      code: "duplicate_derived_field",
+      message: `Derived field "${i.name}" is declared more than once.`,
+      path: `${s}.name`,
+      queryHook: e.querySpec.queryHook,
+      queryId: e.queryId,
+      intentId: e.intent.id,
+      source: e.intent.source
+    }), t.add(n), e.catalog.fields.some(
+      (d) => $(d.name) === n
+    ) && o.push({
+      severity: "error",
+      code: "derived_field_name_collision",
+      message: `Derived field "${i.name}" conflicts with a field already visible on the selected Semaphor source.`,
+      path: `${s}.name`,
+      queryHook: e.querySpec.queryHook,
+      queryId: e.queryId,
+      intentId: e.intent.id,
+      source: e.intent.source
+    })), Object.entries(i.inputs || {}).forEach(([d, y]) => {
+      const p = Ce(y);
+      if (!p)
+        return;
+      const I = h(p, e.intent.source);
+      if (!q(I, e.intent.source)) {
+        o.push({
+          severity: "error",
+          code: "unsupported_derived_field_source",
+          message: `Derived field "${i.name}" input "${d}" references a different Semaphor source. App-local derived fields must use fields from the query source.`,
+          path: `${s}.inputs.${d}`,
+          queryHook: e.querySpec.queryHook,
+          queryId: e.queryId,
+          intentId: e.intent.id,
+          source: I,
+          field: p
+        });
+        return;
+      }
+      v(e.catalog, p, e.intent.source) || o.push({
+        severity: "error",
+        code: "missing_field",
+        message: `Derived field "${i.name}" input "${d}" references field "${p.name}", which is not visible on the selected Semaphor source.`,
+        path: `${s}.inputs.${d}`,
+        queryHook: e.querySpec.queryHook,
+        queryId: e.queryId,
+        intentId: e.intent.id,
+        source: I,
+        field: p
+      });
+    });
+  }), o;
+}
+function Fe(e) {
+  return we(e.intent).flatMap(({ field: r, path: o }) => {
+    const t = le({
+      intent: e.intent,
+      field: r,
+      relativePath: o,
+      baseCatalog: e.catalog,
+      fieldCatalogs: e.fieldCatalogs
+    });
+    return t.ok ? [] : [
+      {
+        severity: "error",
+        code: t.code,
+        message: t.message,
+        path: `${e.pathPrefix}.${o}${t.pathSuffix || ""}`,
+        queryHook: e.querySpec.queryHook,
+        queryId: e.queryId,
+        intentId: e.intent.id,
+        source: t.source,
+        field: r
+      }
+    ];
+  });
+}
+function be(e) {
+  return ("inputs" in e.intent ? e.intent.inputs || [] : []).flatMap((o, t) => {
+    if (!o.field)
+      return [];
+    const i = h(o.field, e.intent.source);
+    if (!q(i, e.intent.source)) {
+      if (xe(e.intent, i)) {
+        const a = S(e.fieldCatalogs, i);
+        return a ? v(a, o.field, i) ? [] : [
+          {
+            severity: "error",
+            code: "missing_field",
+            message: `Input "${o.inputId}" references field "${o.field.name}", which is not visible on the selected Semaphor source.`,
+            path: `${e.pathPrefix}.spec.inputs.${t}.field`,
+            queryHook: e.querySpec.queryHook,
+            queryId: e.queryId,
+            intentId: e.intent.id,
+            source: i,
+            field: o.field
+          }
+        ] : [
+          {
+            severity: "error",
+            code: "invalid_source_ref",
+            message: `Input "${o.inputId}" references a Semaphor source that is not present in the visible field catalog.`,
+            path: `${e.pathPrefix}.spec.inputs.${t}.field.source`,
+            queryHook: e.querySpec.queryHook,
+            queryId: e.queryId,
+            intentId: e.intent.id,
+            source: i,
+            field: o.field
+          }
+        ];
+      }
+      return [
+        {
+          severity: "error",
+          code: "unsupported_input_filter_composition",
+          message: `Input "${o.inputId}" filters a different Semaphor source than the query, and no relationship-aware semantic validation path is available for this query kind.`,
+          path: `${e.pathPrefix}.spec.inputs.${t}.field`,
+          queryHook: e.querySpec.queryHook,
+          queryId: e.queryId,
+          intentId: e.intent.id,
+          source: i,
+          field: o.field
+        }
+      ];
+    }
+    return v(e.catalog, o.field, e.intent.source) ? [] : [
+      {
+        severity: "error",
+        code: "missing_field",
+        message: `Input "${o.inputId}" references field "${o.field.name}", which is not visible on the selected Semaphor source.`,
+        path: `${e.pathPrefix}.spec.inputs.${t}.field`,
+        queryHook: e.querySpec.queryHook,
+        queryId: e.queryId,
+        intentId: e.intent.id,
+        source: i,
+        field: o.field
+      }
+    ];
+  });
+}
+function xe(e, r) {
+  return e.source.kind === "semantic" && r.kind === "semantic" && r.domainId === e.source.domainId;
+}
+function Re(e) {
+  if (e.querySpec.spec.queryKind !== "analysis")
+    return [];
+  const r = pe(
+    e.querySpec.spec,
+    {
+      pathPrefix: `${e.pathPrefix}.spec`,
+      validateTimezone: e.validateTimezone
+    }
+  );
+  return r.ok ? [] : r.issues.map((o) => ({
+    severity: "error",
+    code: o.code,
+    message: o.message,
+    path: o.path,
+    queryHook: e.querySpec.queryHook,
+    queryId: e.queryId,
+    intentId: e.intent.id,
+    source: e.intent.source
+  }));
+}
+function $e(e) {
+  return e.querySpec.spec.queryKind !== "sql" ? [] : T(e.querySpec.spec) ? Object.prototype.hasOwnProperty.call(e.querySpec.spec, "parameters") ? [
+    {
+      severity: "error",
+      code: "deprecated_sql_parameters",
+      message: "semaphor.sql uses defaultParameters for static SQL param(...) fallback values. The legacy parameters field is not supported.",
+      path: `${e.pathPrefix}.spec.parameters`,
+      queryHook: e.querySpec.queryHook,
+      queryId: e.queryId,
+      intentId: e.intent.id
+    }
+  ] : [] : [];
+}
+function we(e) {
+  return e.kind === "metric" ? [
+    ...e.measures.map((r, o) => ({
+      field: r,
+      path: `spec.measures.${o}`
+    })),
+    ...e.primaryMeasure ? [{ field: e.primaryMeasure, path: "spec.primaryMeasure" }] : [],
+    ...e.dateField ? [{ field: e.dateField, path: "spec.dateField" }] : [],
+    ...(e.dimensions || []).map((r, o) => ({
+      field: r,
+      path: `spec.dimensions.${o}`
+    })),
+    ...e.orderBy ? [{ field: e.orderBy.field, path: "spec.orderBy.field" }] : [],
+    ...(e.filters || []).map((r, o) => ({
+      field: r.field,
+      path: `spec.filters.${o}.field`
+    }))
+  ] : e.kind === "records" ? [
+    ...e.fields.map((r, o) => ({
+      field: r,
+      path: `spec.fields.${o}`
+    })),
+    ...e.dateField ? [{ field: e.dateField, path: "spec.dateField" }] : [],
+    ...e.orderBy ? [{ field: e.orderBy.field, path: "spec.orderBy.field" }] : [],
+    ...(e.filters || []).map((r, o) => ({
+      field: r.field,
+      path: `spec.filters.${o}.field`
+    }))
+  ] : e.kind === "inputOptions" ? [
+    { field: e.labelField, path: "spec.labelField" },
+    { field: e.valueField, path: "spec.valueField" },
+    ...e.searchField ? [{ field: e.searchField, path: "spec.searchField" }] : [],
+    ...(e.disambiguationFields || []).map((r, o) => ({
+      field: r,
+      path: `spec.disambiguationFields.${o}`
+    }))
+  ] : e.kind === "matrix" ? [
+    ...e.rows.map((r, o) => ({
+      field: r.field,
+      path: `spec.rows.${o}.field`
+    })),
+    ...e.rows.flatMap(
+      (r, o) => {
+        var t;
+        return ((t = r.sortBy) == null ? void 0 : t.by.kind) === "field" ? [
+          {
+            field: r.sortBy.by.field,
+            path: `spec.rows.${o}.sortBy.by.field`
+          }
+        ] : [];
+      }
+    ),
+    ...(e.columns || []).map((r, o) => ({
+      field: r.field,
+      path: `spec.columns.${o}.field`
+    })),
+    ...(e.columns || []).flatMap(
+      (r, o) => {
+        var t;
+        return ((t = r.sortBy) == null ? void 0 : t.by.kind) === "field" ? [
+          {
+            field: r.sortBy.by.field,
+            path: `spec.columns.${o}.sortBy.by.field`
+          }
+        ] : [];
+      }
+    ),
+    ...e.values.map((r, o) => ({
+      field: r.field,
+      path: `spec.values.${o}.field`
+    })),
+    ...(e.sort || []).flatMap(
+      (r, o) => r.by.kind === "field" ? [
+        {
+          field: r.by.field,
+          path: `spec.sort.${o}.by.field`
+        }
+      ] : []
+    ),
+    ...(e.filters || []).map((r, o) => ({
+      field: r.field,
+      path: `spec.filters.${o}.field`
+    }))
+  ] : [];
+}
+function D(e) {
+  return !("derivedFields" in e) || !Array.isArray(e.derivedFields) ? [] : e.derivedFields;
+}
+function _e(e, r, o) {
+  return D(e).map((t) => ({
+    name: t.name,
+    label: t.label,
+    role: t.resultRole,
+    dataType: t.dataType,
+    source: r.source || o,
+    ...t.defaultAggregate ? { aggregate: t.defaultAggregate } : {}
+  }));
+}
+function Ce(e) {
+  if (!(!e || typeof e != "object"))
+    return e.field;
+}
+function w(e, r) {
+  return {
+    severity: r.severity,
+    code: e.code || "invalid_analytics_intent",
+    message: e.message,
+    path: e.path ? `${r.pathPrefix}.spec.${e.path}` : r.pathPrefix,
+    queryHook: r.queryHook,
+    queryId: r.queryId,
+    intentId: r.intent.id,
+    source: r.intent.source
+  };
+}
+function Pe(e, r) {
+  const o = z(r);
+  return {
+    ok: o.ok && e.ok,
+    errors: C([
+      ...e.errors,
+      ...o.errors
+    ]),
+    warnings: C([
+      ...e.warnings,
+      ...o.warnings
+    ]),
+    repairHints: [
+      ...e.repairHints,
+      ...o.repairHints
+    ]
+  };
+}
+function z(e) {
+  const r = e.filter((t) => t.severity === "error").map(_), o = e.filter((t) => t.severity === "warning").map(_);
+  return {
+    ok: r.length === 0,
+    errors: r,
+    warnings: o,
+    repairHints: r.map((t) => {
+      var i, a;
+      return {
+        code: t.code,
+        message: t.message,
+        fieldRole: t.fieldRole,
+        invalidField: (i = t.repairHint) == null ? void 0 : i.invalidField,
+        recommendedNextStep: ((a = t.repairHint) == null ? void 0 : a.recommendedNextStep) || "Update the Data App SDK query spec to use visible Semaphor source and field refs."
+      };
+    })
+  };
+}
+function _(e) {
+  var r;
+  return {
+    code: e.code,
+    message: e.message,
+    path: e.path,
+    fieldRole: e.code === "invalid_source_ref" ? "source" : void 0,
+    repairHint: {
+      code: e.code,
+      message: e.message,
+      invalidField: (r = e.field) == null ? void 0 : r.name,
+      fieldRole: e.code === "invalid_source_ref" ? "source" : void 0,
+      recommendedNextStep: e.code === "unsupported_input_filter_composition" ? "Use an input field from the same Semaphor source as the query, or split the query into separate source-scoped queries." : "Update the query spec to use a visible Semaphor source and field ref."
+    }
+  };
+}
+function C(e) {
+  const r = /* @__PURE__ */ new Set();
+  return e.filter((o) => {
+    const t = `${o.code}:${o.path || ""}:${o.message}`;
+    return r.has(t) ? !1 : (r.add(t), !0);
+  });
+}
+function P(e) {
+  var o, t;
+  const r = e.diagnostics.filter(
+    (i) => i.severity === "error"
+  );
+  return {
+    intentId: (o = e.intent) == null ? void 0 : o.id,
+    status: r.length ? "failed" : "answered",
+    resultShape: (t = e.intent) == null ? void 0 : t.kind,
+    intent: e.intent,
+    validation: e.validation,
+    coverage: {
+      answeredObligations: r.length ? [] : ["query_spec_validation"],
+      missingObligations: r.length ? ["query_spec_validation"] : [],
+      warnings: e.validation.warnings
+    },
+    missingFields: r.filter((i) => i.code === "missing_field").flatMap(
+      (i) => {
+        var a;
+        return (a = i.field) != null && a.name ? [i.field.name] : [];
+      }
+    ),
+    warnings: e.diagnostics.filter((i) => i.severity === "warning").map((i) => i.message),
+    metadata: {
+      validationKind: "data_app_sdk_query_spec"
+    }
+  };
+}
+function Ae(e, r) {
+  return r.id || N(e.spec);
+}
+function N(e) {
+  if (!e || typeof e != "object" || !("id" in e))
+    return;
+  const r = e.id;
+  return typeof r == "string" && r.trim() ? r : void 0;
+}
 export {
-  m as normalizeSemaphorAnalysisQueryOptions,
-  i as validateSemaphorDataAppQuerySpecs
+  m as fieldWithSelectedProjectionRole,
+  u as findMatchingRelatedProjectionField,
+  X as isAllowedRelatedProjectionRole,
+  k as matrixAxisFieldsForPolicy,
+  pe as normalizeSemaphorAnalysisQueryOptions,
+  H as normalizeSemaphorFieldRole,
+  De as relatedProjectionFieldCandidatesForIntent,
+  ze as validateSemaphorDataAppQuerySpecs
 };