jupiter-dynamic-forms 1.22.3 → 1.22.4

package/dist/index.mjs

@@ -1857,6 +1857,16 @@ const typedDimensionWarning$1 = {
   "continue": "Continue to validate",
   cancel: "Cancel"
 };
+const validateWarningPopup$1 = {
+  title: "Validation warnings"
+};
+const duplicateFactWarning$1 = {
+  title: "Duplicate facts with different values",
+  message: "The same concept, period and dimensions were found with different values entered in different roles. Only one value can be correct — click a fact below to review and fix it.",
+  role: "Role:",
+  value: "Value:",
+  clickToFocus: "Click to go to this fact"
+};
 const calculationWarning$1 = {
   title: "Calculation warning",
   summaryLine: 'Total "{{label}}" should equal {{calculated}}, but you entered {{entered}}.',
@@ -1877,7 +1887,8 @@ const formulaValidation$1 = {
   summaryCountBreakdown: "{{warnings}} warnings, {{errors}} errors",
   severityWarning: "Warning",
   severityError: "Error",
-  close: "Close"
+  close: "Close",
+  breakdownLabel: "Values checked:"
 };
 const scrollToConcept$1 = {
   revealRole: {
@@ -1899,6 +1910,8 @@ const enTranslations = {
   xbrlValidation: xbrlValidation$1,
   error: error$1,
   typedDimensionWarning: typedDimensionWarning$1,
+  validateWarningPopup: validateWarningPopup$1,
+  duplicateFactWarning: duplicateFactWarning$1,
   calculationWarning: calculationWarning$1,
   balanceCheck: balanceCheck$1,
   formulaValidation: formulaValidation$1,
@@ -2104,6 +2117,16 @@ const typedDimensionWarning = {
   "continue": "Doorgaan met valideren",
   cancel: "Annuleren"
 };
+const validateWarningPopup = {
+  title: "Validatiewaarschuwingen"
+};
+const duplicateFactWarning = {
+  title: "Dubbele feiten met verschillende waarden",
+  message: "Hetzelfde concept, dezelfde periode en dimensies zijn gevonden met verschillende waarden in verschillende rollen. Slechts één waarde kan juist zijn — klik op een feit hieronder om het te controleren en te corrigeren.",
+  role: "Rol:",
+  value: "Waarde:",
+  clickToFocus: "Klik om naar dit feit te gaan"
+};
 const calculationWarning = {
   title: "Berekeningswaarschuwing",
   summaryLine: 'Totaal "{{label}}" zou {{calculated}} moeten zijn, maar u heeft {{entered}} ingevoerd.',
@@ -2124,7 +2147,8 @@ const formulaValidation = {
   summaryCountBreakdown: "{{warnings}} waarschuwingen, {{errors}} fouten",
   severityWarning: "Waarschuwing",
   severityError: "Fout",
-  close: "Sluiten"
+  close: "Sluiten",
+  breakdownLabel: "Gecontroleerde waarden:"
 };
 const scrollToConcept = {
   revealRole: {
@@ -2146,6 +2170,8 @@ const nlTranslations = {
   xbrlValidation,
   error,
   typedDimensionWarning,
+  validateWarningPopup,
+  duplicateFactWarning,
   calculationWarning,
   balanceCheck,
   formulaValidation,
@@ -2528,6 +2554,19 @@ class Parser {
   }
   parseBoolTerm() {
     const token = this.peek();
+    if (token.type === "LPAREN") {
+      const savedPos = this.pos;
+      try {
+        this.next();
+        const inner = this.parseOrExpr();
+        this.expect("RPAREN");
+        return inner;
+      } catch (error2) {
+        if (!(error2 instanceof FormulaExpressionError))
+          throw error2;
+        this.pos = savedPos;
+      }
+    }
     if (token.type === "IDENT" && token.value === "not") {
       this.next();
       this.expect("LPAREN");
@@ -2988,8 +3027,8 @@ function collectDescendantConceptIds(childrenIndex, rootConceptId) {
 function candidateKey(candidate) {
   return `${candidate.conceptId}::${candidate.columnId}`;
 }
-function resolveMatchedCandidates(variable, ctx) {
-  return intersectCandidates(variable.filters.map((filter2) => resolveFilter(filter2, ctx.allCandidates, ctx, variable.filters)));
+function resolveMatchedCandidates(variable, ctx, roleURI) {
+  return intersectCandidates(variable.filters.map((filter2) => resolveFilter(filter2, ctx.allCandidates, ctx, variable.filters, roleURI)));
 }
 function getColumn(ctx, candidate) {
   var _a;
@@ -3103,7 +3142,7 @@ function resolveCrossRoleChildren(anchorQName, ownLinkrole, ctx) {
   const otherRoles = Array.from(candidatesByRole.entries()).filter(([roleURI]) => roleURI !== ownLinkrole);
   return otherRoles.length === 1 ? otherRoles[0][1] : [];
 }
-function matchFilter(filter2, universe, ctx, siblingFilters) {
+function matchFilter(filter2, universe, ctx, siblingFilters, roleURI) {
   var _a, _b;
   switch (filter2.type) {
     case "CONCEPT_NAME": {
@@ -3111,7 +3150,9 @@ function matchFilter(filter2, universe, ctx, siblingFilters) {
       const infos = qname ? ctx.conceptByQName.get(qname) : void 0;
       if (!infos || infos.length === 0)
         return [];
-      const conceptIds = new Set(infos.map((info) => info.conceptId));
+      const ownRoleInfos = roleURI ? infos.filter((info) => ctx.roleURIByConceptId.get(info.conceptId) === roleURI) : [];
+      const scopedInfos = ownRoleInfos.length > 0 ? ownRoleInfos : infos;
+      const conceptIds = new Set(scopedInfos.map((info) => info.conceptId));
       return universe.filter((candidate) => conceptIds.has(candidate.conceptId));
     }
     case "CONCEPT_BALANCE": {
@@ -3171,7 +3212,7 @@ function matchFilter(filter2, universe, ctx, siblingFilters) {
       return universe.filter((candidate) => columnMatchesPeriod(getColumn(ctx, candidate), dateAttribute, ctx));
     }
     case "OR_FILTER":
-      return unionCandidates(filter2.children.map((child) => resolveFilter(child, universe, ctx, siblingFilters)));
+      return unionCandidates(filter2.children.map((child) => resolveFilter(child, universe, ctx, siblingFilters, roleURI)));
     case "ASPECT_COVER":
       return universe;
     case "UNKNOWN": {
@@ -3189,8 +3230,8 @@ function matchFilter(filter2, universe, ctx, siblingFilters) {
       return [];
   }
 }
-function resolveFilter(filter2, universe, ctx, siblingFilters) {
-  const matched = matchFilter(filter2, universe, ctx, siblingFilters);
+function resolveFilter(filter2, universe, ctx, siblingFilters, roleURI) {
+  const matched = matchFilter(filter2, universe, ctx, siblingFilters, roleURI);
   if (!filter2.complement)
     return matched;
   const matchedKeys = new Set(matched.map(candidateKey));
@@ -3220,12 +3261,9 @@ function hasExplicitPeriodFilter(filters) {
   });
 }
 function narrowToCurrentPeriod(candidates, variable, ctx) {
-  if (candidates.length <= 1 || hasExplicitPeriodFilter(variable.filters))
+  if (candidates.length === 0 || hasExplicitPeriodFilter(variable.filters))
     return candidates;
-  const currentPeriodOnly = candidates.filter(
-    (candidate) => columnEffectivePeriod(getColumn(ctx, candidate), ctx).end === ctx.periodEndDate
-  );
-  return currentPeriodOnly.length > 0 ? currentPeriodOnly : candidates;
+  return candidates.filter((candidate) => columnEffectivePeriod(getColumn(ctx, candidate), ctx).end === ctx.periodEndDate);
 }
 function narrowByPreferredOccurrence(candidates, ctx) {
   const groups = /* @__PURE__ */ new Map();
@@ -3272,9 +3310,13 @@ function narrowToDirectChildOfDescendantAnchor(candidates, variable, ctx) {
     return candidates;
   return candidates.filter((candidate) => directChildren.has(candidate.conceptId));
 }
-function resolveNarrowedCandidates(variable, ctx) {
+function resolveNarrowedCandidates(variable, ctx, roleURI) {
   return narrowByPreferredOccurrence(
-    narrowToDirectChildOfDescendantAnchor(narrowToCurrentPeriod(resolveMatchedCandidates(variable, ctx), variable, ctx), variable, ctx),
+    narrowToDirectChildOfDescendantAnchor(
+      narrowToCurrentPeriod(resolveMatchedCandidates(variable, ctx, roleURI), variable, ctx),
+      variable,
+      ctx
+    ),
     ctx
   );
 }
@@ -3339,9 +3381,9 @@ function findUncoveredAxisAnchor(variables, axisId, candidatesByName, ctx) {
   }
   return void 0;
 }
-function resolveAssertionVariableBindings(variables, ctx, implicitFiltering) {
+function computeAssertionNarrowedCandidatesByName(variables, ctx, implicitFiltering, roleURI) {
   const candidatesByName = /* @__PURE__ */ new Map();
-  variables.forEach((variable) => candidatesByName.set(variable.name, resolveNarrowedCandidates(variable, ctx)));
+  variables.forEach((variable) => candidatesByName.set(variable.name, resolveNarrowedCandidates(variable, ctx, roleURI)));
   if (implicitFiltering) {
     const axisIds = /* @__PURE__ */ new Set();
     variables.forEach((variable) => uncoveredExplicitDimensionAxisIds(variable, ctx).forEach((axisId) => axisIds.add(axisId)));
@@ -3362,10 +3404,35 @@ function resolveAssertionVariableBindings(variables, ctx, implicitFiltering) {
       });
     });
   }
+  return candidatesByName;
+}
+function resolveAssertionVariableBindings(variables, ctx, implicitFiltering, roleURI) {
+  const candidatesByName = computeAssertionNarrowedCandidatesByName(variables, ctx, implicitFiltering, roleURI);
   const bindings = /* @__PURE__ */ new Map();
   variables.forEach((variable) => bindings.set(variable.name, valuesFromCandidates(variable, candidatesByName.get(variable.name) || [], ctx)));
   return bindings;
 }
+function buildFormulaVariableBreakdown(variables, ctx, implicitFiltering, roleURI) {
+  const sequenceVariables = variables.filter((variable) => variable.bindAsSequence);
+  if (sequenceVariables.length === 0)
+    return void 0;
+  const candidatesByName = computeAssertionNarrowedCandidatesByName(variables, ctx, implicitFiltering, roleURI);
+  const breakdown = [];
+  for (const variable of sequenceVariables) {
+    const candidates = (candidatesByName.get(variable.name) || []).map((candidate) => {
+      var _a, _b;
+      return {
+        conceptId: candidate.conceptId,
+        conceptQName: (_a = ctx.conceptById.get(candidate.conceptId)) == null ? void 0 : _a.qname,
+        columnId: candidate.columnId,
+        value: resolveRawValue((_b = ctx.formData[candidate.conceptId]) == null ? void 0 : _b[candidate.columnId])
+      };
+    }).filter((candidate) => candidate.value !== void 0 && candidate.conceptQName !== void 0);
+    if (candidates.length > 0)
+      breakdown.push({ variableName: variable.name, candidates });
+  }
+  return breakdown.length > 0 ? breakdown : void 0;
+}
 function filterSignature(filter2) {
   const attrs = Object.entries(filter2.attributes).filter(([key]) => key !== "id").sort(([a2], [b2]) => a2.localeCompare(b2));
   return JSON.stringify({ type: filter2.type, complement: filter2.complement, cover: filter2.cover, attrs });
@@ -3520,8 +3587,8 @@ function resolveVariableColumnsForConcept(variable, targetConceptId, ctx) {
   const resolved = intersectCandidates(variable.filters.map((filter2) => resolveFilter(filter2, universe, ctx, variable.filters)));
   return resolved.map((candidate) => candidate.columnId);
 }
-function buildAssertionBindings(assertion, ctx) {
-  return resolveAssertionVariableBindings(assertion.variables, ctx, assertion.implicitFiltering);
+function buildAssertionBindings(assertion, ctx, roleURI) {
+  return resolveAssertionVariableBindings(assertion.variables, ctx, assertion.implicitFiltering, roleURI);
 }
 function buildAssertionFallbackUsage(assertion, ctx) {
   var _a;
@@ -3613,7 +3680,7 @@ class FormulaValidationService {
   }
   _evaluateAssertion(assertion, role, ctx, language) {
     try {
-      const bindings = buildAssertionBindings(assertion, ctx);
+      const bindings = buildAssertionBindings(assertion, ctx, role.roleURI);
       const sumOfMembersShape = detectSumOfMembersOnAbstractShape(assertion);
       const sumOfMembersResult = sumOfMembersShape ? resolveSumOfMembersOnAbstractSatisfaction(sumOfMembersShape, ctx) : void 0;
       const usesSumOfMembersPath = sumOfMembersResult !== void 0 && sumOfMembersResult !== "not-applicable";
@@ -3640,7 +3707,8 @@ class FormulaValidationService {
         return this._evaluatedResult(assertion, role, ctx, sumOfMembersResult, language);
       }
       const satisfied = evaluateFormulaTest(assertion.test, bindings, fallbackUsage);
-      return this._evaluatedResult(assertion, role, ctx, satisfied, language);
+      const variableBreakdown = satisfied ? void 0 : buildFormulaVariableBreakdown(assertion.variables, ctx, assertion.implicitFiltering, role.roleURI);
+      return this._evaluatedResult(assertion, role, ctx, satisfied, language, void 0, variableBreakdown);
     } catch (error2) {
       if (error2 instanceof FormulaExpressionError) {
         console.warn(`[FormulaValidationService] Assertion "${assertion.id}" could not be evaluated (${error2.reason}): ${error2.message}`);
@@ -3661,7 +3729,7 @@ class FormulaValidationService {
       skipReason
     };
   }
-  _evaluatedResult(assertion, role, ctx, satisfied, language, matchedFactCount) {
+  _evaluatedResult(assertion, role, ctx, satisfied, language, matchedFactCount, variableBreakdown) {
     const message = satisfied ? void 0 : this._pickMessage(assertion, language);
     return {
       assertionId: assertion.id,
@@ -3673,7 +3741,8 @@ class FormulaValidationService {
       skipped: false,
       message,
       matchedFactCount,
-      conceptLinks: message ? this._buildConceptLinks(assertion, role.roleURI, ctx, message) : void 0
+      conceptLinks: message ? this._buildConceptLinks(assertion, role.roleURI, ctx, message) : void 0,
+      variableBreakdown
     };
   }
   _pickMessage(assertion, language) {
@@ -12233,6 +12302,44 @@ let JupiterFormulaValidationDialog = class extends LitElement {
       composed: true
     }));
   }
+  // JDF-129: same navigate-and-close flow as `_handleConceptLinkClick`, for a breakdown line
+  // rather than a message's backtick-quoted concept mention.
+  _handleBreakdownCandidateClick(candidate) {
+    this.dispatchEvent(new CustomEvent("formula-concept-click", {
+      detail: { conceptId: candidate.conceptId, conceptQName: candidate.conceptQName, columnId: candidate.columnId },
+      bubbles: true,
+      composed: true
+    }));
+  }
+  // JDF-129: local (non-prefixed) name for a breakdown candidate's concept — same derivation as
+  // `_buildConceptLinks`'s own label in FormulaValidationService.
+  _breakdownCandidateLabel(candidate) {
+    return candidate.conceptQName.includes(":") ? candidate.conceptQName.split(":").pop() : candidate.conceptQName;
+  }
+  // JDF-129: plain, unflagged per-candidate breakdown for a bindAsSequence:true variable — the
+  // real facts an aggregate sum/comparison summed, so a user can see one corrected line reflected
+  // even though the assertion as a whole (a pure aggregate check) is still failing. Deliberately no
+  // per-line pass/fail — see the ticket's own "Diff behavior" scoping decision.
+  _renderBreakdown(result) {
+    const breakdown = result.variableBreakdown;
+    if (!breakdown || breakdown.length === 0)
+      return "";
+    return html`
+      <div class="assertion-breakdown">
+        <span class="assertion-breakdown-label">${I18n.t("formulaValidation.breakdownLabel")}</span>
+        <ul class="assertion-breakdown-list">
+          ${breakdown.flatMap((variable) => variable.candidates.map((candidate) => html`
+            <li class="assertion-breakdown-item">
+              <button type="button" class="concept-link" @click="${() => this._handleBreakdownCandidateClick(candidate)}">
+                ${this._breakdownCandidateLabel(candidate)}
+              </button>
+              <span class="assertion-breakdown-value">${candidate.value}</span>
+            </li>
+          `))}
+        </ul>
+      </div>
+    `;
+  }
   // Splits a message on its backtick-quoted concept mentions and renders the ones this
   // assertion resolved a fact location for (`result.conceptLinks`) as click-to-focus buttons;
   // any other backtick mention (e.g. an enumerated value like `Na`, not a concept) renders as
@@ -12299,7 +12406,10 @@ let JupiterFormulaValidationDialog = class extends LitElement {
                         <span class="severity-badge ${result.severity === "ERROR" ? "error" : "warning"}">
                           ${result.severity === "ERROR" ? I18n.t("formulaValidation.severityError") : I18n.t("formulaValidation.severityWarning")}
                         </span>
-                        <span class="assertion-message">${this._renderMessage(result)}</span>
+                        <div class="assertion-row-body">
+                          <span class="assertion-message">${this._renderMessage(result)}</span>
+                          ${this._renderBreakdown(result)}
+                        </div>
                       </div>
                     `)}
                   </div>
@@ -12488,12 +12598,53 @@ JupiterFormulaValidationDialog.styles = css`
       background: var(--jupiter-error-color, #d32f2f);
     }
 
+    .assertion-row-body {
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+      min-width: 0;
+    }
+
     .assertion-message {
       font-size: 13px;
       color: var(--primaryTextColor, var(--jupiter-text-primary, #333));
       line-height: 1.4;
     }
 
+    .assertion-breakdown {
+      display: flex;
+      flex-direction: column;
+      gap: 2px;
+    }
+
+    .assertion-breakdown-label {
+      font-size: 11px;
+      font-weight: 600;
+      color: var(--jupiter-text-secondary, #666);
+    }
+
+    .assertion-breakdown-list {
+      list-style: none;
+      margin: 0;
+      padding: 0;
+      display: flex;
+      flex-direction: column;
+      gap: 2px;
+    }
+
+    .assertion-breakdown-item {
+      display: flex;
+      align-items: baseline;
+      justify-content: space-between;
+      gap: 8px;
+      font-size: 12px;
+    }
+
+    .assertion-breakdown-value {
+      color: var(--jupiter-text-secondary, #666);
+      white-space: nowrap;
+    }
+
     .concept-link {
       font: inherit;
       font-weight: 600;
@@ -12785,8 +12936,9 @@ let JupiterDynamicForm = class extends LitElement {
     this._xbrlFormErrors = [];
     this._calculationWarnings = /* @__PURE__ */ new Map();
     this._showErrorPopup = false;
-    this._showTypedDimensionWarning = false;
+    this._showValidateWarningPopup = false;
     this._typedDimensionWarningFacts = [];
+    this._duplicateFactMismatches = [];
     this._submitDisabled = false;
     this._allSections = [];
     this._selectedRoleIds = [];
@@ -14354,7 +14506,12 @@ let JupiterDynamicForm = class extends LitElement {
     await this._focusFormField(conceptId, columnId, sectionId);
   }
   async _handleTypedDimensionFactClick(conceptId, columnId, sectionId) {
-    this._showTypedDimensionWarning = false;
+    this._showValidateWarningPopup = false;
+    this.requestUpdate();
+    await this._focusFormField(conceptId, columnId, sectionId);
+  }
+  async _handleDuplicateFactClick(conceptId, columnId, sectionId) {
+    this._showValidateWarningPopup = false;
     this.requestUpdate();
     await this._focusFormField(conceptId, columnId, sectionId);
   }
@@ -15047,6 +15204,137 @@ let JupiterDynamicForm = class extends LitElement {
     }
     return groups;
   }
+  /**
+   * Validate pre-flight: finds entered facts that share their concept, period and dimensions
+   * (i.e. would resolve to the same XBRL context) with at least one other entered fact — typically
+   * because the same concept is presented in more than one disclosure role — but were given
+   * different values. E.g. `IncomeTaxExpense` entered as 992 in one note and -992 in another for
+   * the same year: only one can be correct, so this is a genuine conflict rather than a benign
+   * duplicate (an identical value entered twice in two roles is left alone — see
+   * `_normalizeFactValueForCompare` below). Walks every concept's own `fields` (not every
+   * column x every concept) to stay cheap on large taxonomies.
+   */
+  _findDuplicateFactMismatches() {
+    const mismatches = [];
+    if (!this._currentSchema)
+      return mismatches;
+    const groups = /* @__PURE__ */ new Map();
+    for (const section2 of this._currentSchema.sections) {
+      const columnsById = new Map((section2.columns || []).map((col) => [col.id, col]));
+      this._collectDuplicateFactCandidates(section2.concepts, columnsById, section2, groups);
+    }
+    groups.forEach((group) => {
+      if (group.entries.length < 2)
+        return;
+      const distinctValues = new Set(group.entries.map((e2) => this._normalizeFactValueForCompare(e2.value)));
+      if (distinctValues.size < 2)
+        return;
+      mismatches.push({
+        conceptId: group.conceptId,
+        conceptLabel: group.conceptLabel,
+        facts: group.entries
+      });
+    });
+    return mismatches;
+  }
+  _collectDuplicateFactCandidates(concepts, columnsById, section2, groups) {
+    var _a;
+    for (const concept of concepts) {
+      const conceptValues = this._formData[concept.id];
+      if (conceptValues) {
+        for (const field2 of concept.fields) {
+          const value = conceptValues[field2.columnId];
+          if (value === void 0 || value === null || String(value).trim() === "")
+            continue;
+          const column2 = columnsById.get(field2.columnId);
+          if (!column2)
+            continue;
+          const contextKey = this._buildFactContextKey(concept, field2, column2, section2);
+          if (!contextKey)
+            continue;
+          const entry = {
+            conceptId: concept.id,
+            conceptLabel: concept.label,
+            columnId: column2.id,
+            columnTitle: column2.title,
+            sectionId: section2.id,
+            sectionTitle: section2.title,
+            value
+          };
+          let group = groups.get(contextKey);
+          if (!group) {
+            group = { conceptId: concept.originalConceptId || concept.id, conceptLabel: concept.label, entries: [] };
+            groups.set(contextKey, group);
+          }
+          group.entries.push(entry);
+        }
+      }
+      if ((_a = concept.children) == null ? void 0 : _a.length) {
+        this._collectDuplicateFactCandidates(concept.children, columnsById, section2, groups);
+      }
+    }
+  }
+  /**
+   * Canonical key for the XBRL context (concept + period + dimensions) `concept`'s value in
+   * `column` would resolve to, independent of which role produced it. Returns null when a typed
+   * dimension on this column has no value entered yet, since its true context can't be
+   * determined without one (that gap is already surfaced by the typed-dimension warning).
+   */
+  _buildFactContextKey(concept, field2, column2, section2) {
+    var _a, _b, _c;
+    const conceptKey = concept.originalConceptId || concept.id;
+    const isInstant = concept.periodType === "instant";
+    const fieldPeriodData = (_a = this._periodData[concept.id]) == null ? void 0 : _a[column2.id];
+    const periodStartDate = (fieldPeriodData == null ? void 0 : fieldPeriodData.startDate) || column2.periodStartDate || field2.periodStartDate || this.periodStartDate;
+    const periodEndDate = (fieldPeriodData == null ? void 0 : fieldPeriodData.endDate) || column2.periodEndDate || field2.periodEndDate || this.periodEndDate;
+    const periodInstantDate = (fieldPeriodData == null ? void 0 : fieldPeriodData.instantDate) || field2.periodInstantDate || periodEndDate || periodStartDate;
+    const periodKey = isInstant ? `instant:${periodInstantDate}` : `duration:${periodStartDate}_${periodEndDate}`;
+    const dimensionData = column2.dimensionData;
+    let dimensionKey = "base";
+    if (dimensionData) {
+      const typedMembers = dimensionData.typedMembers;
+      if (typedMembers && typedMembers.length > 0) {
+        const scoped = this._typedMemberData[this._scopedColumnKey(section2.id, column2.id)];
+        const legacy = this._typedMemberData[column2.id];
+        const typedParts = [];
+        for (const tm of typedMembers) {
+          const typedValue = (_b = (scoped == null ? void 0 : scoped[tm.axisId]) ?? (legacy == null ? void 0 : legacy[tm.axisId])) == null ? void 0 : _b.trim();
+          if (!typedValue)
+            return null;
+          typedParts.push(`${tm.axisId}=${typedValue}`);
+        }
+        dimensionKey = typedParts.sort().join("|");
+      } else if ((_c = dimensionData.combinations) == null ? void 0 : _c.length) {
+        dimensionKey = dimensionData.combinations.map((c2) => `${c2.axisId}=${c2.memberId}`).sort().join("|");
+      } else if (dimensionData.dimensionIdKey) {
+        dimensionKey = dimensionData.dimensionIdKey;
+      } else if (dimensionData.axisId && dimensionData.memberId) {
+        dimensionKey = `${dimensionData.axisId}=${dimensionData.memberId}`;
+      }
+    }
+    return `${conceptKey}||${periodKey}||${dimensionKey}`;
+  }
+  /** Numeric-aware value comparison for the duplicate-fact check — "992" and 992 (or "992.0") count as equal. */
+  _normalizeFactValueForCompare(value) {
+    if (typeof value === "number")
+      return String(value);
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      const asNumber = Number(trimmed);
+      return trimmed !== "" && !isNaN(asNumber) ? String(asNumber) : trimmed;
+    }
+    return String(value);
+  }
+  /** Popup header for the Validate pre-flight warning: specific when only one check found something, generic when both did. */
+  _validateWarningPopupTitle() {
+    const hasTypedDimensionWarning = this._typedDimensionWarningFacts.length > 0;
+    const hasDuplicateFactWarning = this._duplicateFactMismatches.length > 0;
+    if (hasTypedDimensionWarning && hasDuplicateFactWarning)
+      return I18n.t("validateWarningPopup.title");
+    if (hasDuplicateFactWarning)
+      return I18n.t("duplicateFactWarning.title");
+    return I18n.t("typedDimensionWarning.title");
+  }
   _handleSubmit() {
     console.log("📝 Form submission started...");
     this._submitted = true;
@@ -15058,10 +15346,13 @@ let JupiterDynamicForm = class extends LitElement {
       return;
     }
     const missingTypedDimensionFacts = this._findMissingTypedDimensionFacts();
-    if (missingTypedDimensionFacts.length > 0) {
+    const duplicateFactMismatches = this._findDuplicateFactMismatches();
+    if (missingTypedDimensionFacts.length > 0 || duplicateFactMismatches.length > 0) {
       console.log("⚠️ [Submit] Typed dimension values missing for entered facts:", missingTypedDimensionFacts);
+      console.log("⚠️ [Submit] Duplicate facts with mismatched values:", duplicateFactMismatches);
       this._typedDimensionWarningFacts = missingTypedDimensionFacts;
-      this._showTypedDimensionWarning = true;
+      this._duplicateFactMismatches = duplicateFactMismatches;
+      this._showValidateWarningPopup = true;
       this._submitDisabled = false;
       this.requestUpdate();
       return;
@@ -15070,8 +15361,8 @@ let JupiterDynamicForm = class extends LitElement {
   }
   /**
    * The original Validate/submit logic (error checks + submission), extracted so "Continue to
-   * validate" on the typed-dimension warning popup can re-enter it directly without re-running
-   * (and re-triggering) the typed-dimension pre-flight in _handleSubmit() above.
+   * validate" on the Validate pre-flight warning popup can re-enter it directly without
+   * re-running (and re-triggering) the checks in _handleSubmit() above.
    */
   _continueSubmit() {
     this._submitted = true;
@@ -18098,53 +18389,87 @@ let JupiterDynamicForm = class extends LitElement {
           </div>
         ` : ""}
 
-        <!-- Typed Dimension Warning Popup -->
-        ${this._showTypedDimensionWarning ? html`
+        <!-- Validate Pre-flight Warning Popup: typed-dimension-missing facts and/or duplicate-fact value mismatches -->
+        ${this._showValidateWarningPopup ? html`
           <div class="error-popup-overlay" @click="${() => {
-      this._showTypedDimensionWarning = false;
+      this._showValidateWarningPopup = false;
       this.requestUpdate();
     }}">
             <div class="error-popup" @click="${(e2) => e2.stopPropagation()}">
               <div class="error-popup-header">
-                <h3>⚠️ ${I18n.t("typedDimensionWarning.title")}</h3>
+                <h3>⚠️ ${this._validateWarningPopupTitle()}</h3>
                 <button class="error-popup-close" @click="${() => {
-      this._showTypedDimensionWarning = false;
+      this._showValidateWarningPopup = false;
       this.requestUpdate();
     }}">×</button>
               </div>
               <div class="error-popup-content">
-                <p>${I18n.t("typedDimensionWarning.message")}</p>
-                <ul class="error-list">
-                  ${this._groupTypedDimensionWarningFactsByRole().map((group) => html`
-                    <li>
-                      <strong>${I18n.t("typedDimensionWarning.role")}</strong> ${group.sectionTitle}
-                      <ul>
-                        ${group.facts.map((fact) => html`
-                          <li>
-                            <strong>${I18n.t("typedDimensionWarning.field")}</strong>
-                            <a
-                              href="javascript:void(0)"
-                              class="error-field-link"
-                              @click="${() => this._handleTypedDimensionFactClick(fact.conceptId, fact.columnId, fact.sectionId)}"
-                              title="${I18n.t("typedDimensionWarning.clickToFocus")}"
-                            >
-                              ${fact.conceptLabel} (${fact.columnTitle})
-                            </a>
-                            — <strong>${I18n.t("typedDimensionWarning.value")}</strong> ${fact.value}
-                          </li>
-                        `)}
-                      </ul>
-                    </li>
-                  `)}
-                </ul>
+                ${this._typedDimensionWarningFacts.length > 0 ? html`
+                  <div class="validate-warning-section">
+                    ${this._duplicateFactMismatches.length > 0 ? html`<h4>${I18n.t("typedDimensionWarning.title")}</h4>` : ""}
+                    <p>${I18n.t("typedDimensionWarning.message")}</p>
+                    <ul class="error-list">
+                      ${this._groupTypedDimensionWarningFactsByRole().map((group) => html`
+                        <li>
+                          <strong>${I18n.t("typedDimensionWarning.role")}</strong> ${group.sectionTitle}
+                          <ul>
+                            ${group.facts.map((fact) => html`
+                              <li>
+                                <strong>${I18n.t("typedDimensionWarning.field")}</strong>
+                                <a
+                                  href="javascript:void(0)"
+                                  class="error-field-link"
+                                  @click="${() => this._handleTypedDimensionFactClick(fact.conceptId, fact.columnId, fact.sectionId)}"
+                                  title="${I18n.t("typedDimensionWarning.clickToFocus")}"
+                                >
+                                  ${fact.conceptLabel} (${fact.columnTitle})
+                                </a>
+                                — <strong>${I18n.t("typedDimensionWarning.value")}</strong> ${fact.value}
+                              </li>
+                            `)}
+                          </ul>
+                        </li>
+                      `)}
+                    </ul>
+                  </div>
+                ` : ""}
+                ${this._duplicateFactMismatches.length > 0 ? html`
+                  <div class="validate-warning-section">
+                    ${this._typedDimensionWarningFacts.length > 0 ? html`<h4>${I18n.t("duplicateFactWarning.title")}</h4>` : ""}
+                    <p>${I18n.t("duplicateFactWarning.message")}</p>
+                    <ul class="error-list">
+                      ${this._duplicateFactMismatches.map((mismatch) => html`
+                        <li>
+                          <strong>${mismatch.conceptLabel}</strong>
+                          <ul>
+                            ${mismatch.facts.map((fact) => html`
+                              <li>
+                                <strong>${I18n.t("duplicateFactWarning.role")}</strong> ${fact.sectionTitle} —
+                                <a
+                                  href="javascript:void(0)"
+                                  class="error-field-link"
+                                  @click="${() => this._handleDuplicateFactClick(fact.conceptId, fact.columnId, fact.sectionId)}"
+                                  title="${I18n.t("duplicateFactWarning.clickToFocus")}"
+                                >
+                                  ${fact.columnTitle}
+                                </a>
+                                — <strong>${I18n.t("duplicateFactWarning.value")}</strong> ${fact.value}
+                              </li>
+                            `)}
+                          </ul>
+                        </li>
+                      `)}
+                    </ul>
+                  </div>
+                ` : ""}
               </div>
               <div class="error-popup-footer">
                 <button class="btn-secondary" @click="${() => {
-      this._showTypedDimensionWarning = false;
+      this._showValidateWarningPopup = false;
       this.requestUpdate();
     }}">${I18n.t("typedDimensionWarning.cancel")}</button>
                 <button class="btn-primary" @click="${() => {
-      this._showTypedDimensionWarning = false;
+      this._showValidateWarningPopup = false;
       this._continueSubmit();
     }}">${I18n.t("typedDimensionWarning.continue")}</button>
               </div>
@@ -19023,6 +19348,17 @@ JupiterDynamicForm.styles = css`
       color: var(--jupiter-text-primary, #333);
     }
 
+    .validate-warning-section + .validate-warning-section {
+      margin-top: 24px;
+      padding-top: 20px;
+      border-top: 1px solid var(--jupiter-border-color, #ddd);
+    }
+
+    .validate-warning-section h4 {
+      margin: 0 0 8px 0;
+      color: var(--jupiter-text-primary, #333);
+    }
+
     .error-list {
       list-style: none;
       padding: 0;
@@ -19262,10 +19598,13 @@ __decorateClass([
 ], JupiterDynamicForm.prototype, "_showErrorPopup", 2);
 __decorateClass([
   r()
-], JupiterDynamicForm.prototype, "_showTypedDimensionWarning", 2);
+], JupiterDynamicForm.prototype, "_showValidateWarningPopup", 2);
 __decorateClass([
   r()
 ], JupiterDynamicForm.prototype, "_typedDimensionWarningFacts", 2);
+__decorateClass([
+  r()
+], JupiterDynamicForm.prototype, "_duplicateFactMismatches", 2);
 __decorateClass([
   r()
 ], JupiterDynamicForm.prototype, "_submitDisabled", 2);