jupiter-dynamic-forms 1.22.3 → 1.22.5

package/dist/index.mjs

@@ -1808,6 +1808,7 @@ const field$1 = {
   selectUnit: "Select Unit",
   leaveBlankForInf: "Leave blank for INF",
   prefilledLocked: "Pre-filled — cannot be changed here",
+  notApplicablePriorYear: "Not required for the previous year",
   invalidNumber: `Can't read "{{value}}" as a number`,
   noDecimalsAllowed: "This field doesn't accept decimals",
   negativeNotAllowed: "A negative value isn't allowed here",
@@ -1857,6 +1858,18 @@ 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",
+  cellTooltip: "This value differs from the same fact entered elsewhere — click to review",
+  close: "Close"
+};
 const calculationWarning$1 = {
   title: "Calculation warning",
   summaryLine: 'Total "{{label}}" should equal {{calculated}}, but you entered {{entered}}.',
@@ -1877,7 +1890,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 +1913,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,
@@ -2055,6 +2071,7 @@ const field = {
   selectUnit: "Selecteer eenheid",
   leaveBlankForInf: "Leeg laten voor INF",
   prefilledLocked: "Vooraf ingevuld — kan hier niet worden gewijzigd",
+  notApplicablePriorYear: "Niet vereist voor het voorgaande jaar",
   invalidNumber: "Kan '{{value}}' niet lezen als getal",
   noDecimalsAllowed: "Dit veld accepteert geen decimalen",
   negativeNotAllowed: "Een negatieve waarde is hier niet toegestaan",
@@ -2104,6 +2121,18 @@ 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",
+  cellTooltip: "Deze waarde wijkt af van hetzelfde feit dat elders is ingevoerd — klik om te controleren",
+  close: "Sluiten"
+};
 const calculationWarning = {
   title: "Berekeningswaarschuwing",
   summaryLine: 'Totaal "{{label}}" zou {{calculated}} moeten zijn, maar u heeft {{entered}} ingevoerd.',
@@ -2124,7 +2153,8 @@ const formulaValidation = {
   summaryCountBreakdown: "{{warnings}} waarschuwingen, {{errors}} fouten",
   severityWarning: "Waarschuwing",
   severityError: "Fout",
-  close: "Sluiten"
+  close: "Sluiten",
+  breakdownLabel: "Gecontroleerde waarden:"
 };
 const scrollToConcept = {
   revealRole: {
@@ -2146,6 +2176,8 @@ const nlTranslations = {
   xbrlValidation,
   error,
   typedDimensionWarning,
+  validateWarningPopup,
+  duplicateFactWarning,
   calculationWarning,
   balanceCheck,
   formulaValidation,
@@ -2528,6 +2560,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 +3033,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 +3148,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 +3156,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 +3218,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 +3236,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 +3267,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 +3316,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 +3387,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 +3410,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 +3593,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 +3686,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 +3713,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 +3735,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 +3747,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) {
@@ -4942,7 +5017,7 @@ let JupiterFormField = class extends LitElement {
     if (changedProperties.has("value") || changedProperties.has("field")) {
       this._validateField();
     }
-    if (changedProperties.has("unit") && this.unit) {
+    if (changedProperties.has("unit") && this.unit && this.hasUpdated) {
       console.log(`🏷️ [FormField willUpdate] Unit property changed to: ${this.unit}, conceptId: ${this.conceptId}, columnId: ${this.columnId}`);
       this.dispatchEvent(new CustomEvent("unit-change", {
         detail: {
@@ -4977,6 +5052,14 @@ let JupiterFormField = class extends LitElement {
   _isRoundingLevelConcept() {
     return !!this.conceptId && this.conceptId.includes("DocumentIntendedRoundingLevel");
   }
+  // jenv-bw2-i:BalanceSheetBeforeAfterAppropriationResults records the profit-appropriation
+  // decision for the current balance sheet only — the NL taxonomy's validation rules warn when
+  // it's also reported for the comparative year, so the prior-year column doesn't accept it.
+  // `columnId` carries the `_prev` marker `generatePreviousYearColumns` (xbrl-form-builder.ts)
+  // gives every comparative-year column, whether dimensioned (`${id}_prev`) or not (`duration_prev_N`).
+  _isDisabledForPriorYear() {
+    return !!this.conceptId && !!this.columnId && this.conceptId.includes("BalanceSheetBeforeAfterAppropriationResults") && this.columnId.includes("_prev");
+  }
   /**
    * JDF-110: lock icon (SVG, not emoji) shown on a masterData-prefilled or rounding-level-locked
    * cell, so a locked value reads as "filled and protected" rather than empty placeholder text.
@@ -5620,7 +5703,7 @@ let JupiterFormField = class extends LitElement {
     const isMonetary = this._isMonetaryType();
     return html`<span class="readonly-value ${isEmpty ? "empty" : ""} ${isMonetary ? "monetary" : ""}">${isEmpty ? "—" : displayValue}</span>`;
   }
-  _renderInput(effectiveValue = this.value, effectiveDisabled = this.disabled, isLocked = false) {
+  _renderInput(effectiveValue = this.value, effectiveDisabled = this.disabled, isLocked = false, disabledTooltip) {
     if (this.mode === "readonly") {
       return this._renderReadonlyValue(effectiveValue);
     }
@@ -5646,6 +5729,7 @@ let JupiterFormField = class extends LitElement {
           class="${cssClass}"
           .value="${effectiveValue ?? ""}"
           ?disabled="${effectiveDisabled || this.field.disabled}"
+          title="${disabledTooltip || ""}"
           @change="${this._handleInput}"
           @focus="${this._handleFocus}"
           @blur="${this._handleBlur}"
@@ -5997,6 +6081,7 @@ let JupiterFormField = class extends LitElement {
     const baseConceptId = this._extractBaseConceptId(this.conceptId);
     const isPredefinedValue = this.mode !== "admin" && this.masterData && baseConceptId in this.masterData;
     const isRoundingLevelLocked = this._isRoundingLevelConcept();
+    const isDisabledForPriorYear = this._isDisabledForPriorYear();
     let factValue = null;
     if (this.facts && this.facts.length > 0 && !isPredefinedValue) {
       const cellContext = {
@@ -6050,8 +6135,8 @@ let JupiterFormField = class extends LitElement {
       }
     }
     const hasUserValue = this.value !== null && this.value !== void 0;
-    const effectiveValue = isPredefinedValue ? this.masterData[baseConceptId] : hasUserValue ? this.value : factValue;
-    const effectiveDisabled = isPredefinedValue || isRoundingLevelLocked || this.disabled || this.mode === "readonly";
+    const effectiveValue = isDisabledForPriorYear ? null : isPredefinedValue ? this.masterData[baseConceptId] : hasUserValue ? this.value : factValue;
+    const effectiveDisabled = isPredefinedValue || isRoundingLevelLocked || isDisabledForPriorYear || this.disabled || this.mode === "readonly";
     const isLocked = (isPredefinedValue || isRoundingLevelLocked) && this.mode !== "readonly";
     const typeConfigForLock = getInputTypeForConceptType(this.conceptType, this.datatypes);
     const effectiveFieldTypeForLock = typeConfigForLock.fieldType || this.field.type || "text";
@@ -6065,7 +6150,7 @@ let JupiterFormField = class extends LitElement {
         ` : ""}
 
         <div class="field-wrapper">
-          ${this._renderInput(effectiveValue, effectiveDisabled, isLocked)}
+          ${this._renderInput(effectiveValue, effectiveDisabled, isLocked, isDisabledForPriorYear ? I18n.t("field.notApplicablePriorYear") : void 0)}
 
           ${isLocked && !isTextareaField || hasPeriodControl && this.mode !== "readonly" && !isRoundingLevelLocked ? html`
             <div class="field-trailing-icons">
@@ -6992,6 +7077,19 @@ let JupiterConceptTree = class extends LitElement {
     `;
     document.head.appendChild(style);
   }
+  /**
+   * Dispatches the clicked cell's duplicate-fact mismatch up to `jupiter-dynamic-form`, which owns
+   * the click-to-navigate machinery (role/column reveal, side-panel switch, highlight) already
+   * built for the Validate pre-flight popup — reused here to show this one mismatch's facts.
+   */
+  _handleDuplicateFactWarningBadgeClick(e2, mismatch) {
+    e2.stopPropagation();
+    this.dispatchEvent(new CustomEvent("duplicate-fact-warning-click", {
+      detail: { mismatch },
+      bubbles: true,
+      composed: true
+    }));
+  }
   _openCalculationWarningDialog(e2, mismatch) {
     var _a;
     e2.stopPropagation();
@@ -7066,7 +7164,7 @@ let JupiterConceptTree = class extends LitElement {
 
       <!-- Input Field Cells (Period Columns) - Only for non-abstract concepts -->
       ${this.columns.map((column2) => {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d, _e, _f;
       if (column2.hidden) {
         return html`<td class="field-cell hidden-column"></td>`;
       }
@@ -7075,8 +7173,9 @@ let JupiterConceptTree = class extends LitElement {
       const storedUnit = (_b = (_a = this.unitData) == null ? void 0 : _a[this.concept.id]) == null ? void 0 : _b[column2.id];
       const storedDecimals = (_d = (_c = this.decimalsData) == null ? void 0 : _c[this.concept.id]) == null ? void 0 : _d[column2.id];
       const calcMismatch = this.mode !== "readonly" ? (_e = this.calculationMismatches) == null ? void 0 : _e.get(`${this.concept.id}__${column2.id}`) : void 0;
+      const dupWarning = this.mode !== "readonly" ? (_f = this.duplicateFactWarnings) == null ? void 0 : _f.get(`${this.concept.id}__${column2.id}`) : void 0;
       return html`
-          <td class="field-cell ${!shouldShowField ? "empty" : ""} ${isAbstract ? "abstract-row" : ""} ${isTotal ? "total-row" : ""} ${this.highlightType && column2.id === this.highlightColumnId ? "highlight-" + this.highlightType : ""} ${calcMismatch ? "calc-warning" : ""} ${this.rowFocused ? "row-focused" : ""}">
+          <td class="field-cell ${!shouldShowField ? "empty" : ""} ${isAbstract ? "abstract-row" : ""} ${isTotal ? "total-row" : ""} ${this.highlightType && column2.id === this.highlightColumnId ? "highlight-" + this.highlightType : ""} ${calcMismatch ? "calc-warning" : ""} ${dupWarning ? "duplicate-fact-warning" : ""} ${this.rowFocused ? "row-focused" : ""}">
             ${calcMismatch ? html`
               <button
                 class="calc-warning-badge"
@@ -7086,6 +7185,15 @@ let JupiterConceptTree = class extends LitElement {
                 @click="${(e2) => this._openCalculationWarningDialog(e2, calcMismatch)}"
               >!</button>
             ` : ""}
+            ${dupWarning ? html`
+              <button
+                class="duplicate-warning-badge"
+                type="button"
+                tabindex="-1"
+                title="${I18n.t("duplicateFactWarning.cellTooltip")}"
+                @click="${(e2) => this._handleDuplicateFactWarningBadgeClick(e2, dupWarning)}"
+              >≠</button>
+            ` : ""}
             ${shouldShowField ? html`
               <jupiter-form-field
                 .field="${field2}"
@@ -7338,6 +7446,38 @@ JupiterConceptTree.styles = css`
       background: #e65100;
     }
 
+    /* Live counterpart to the Validate pre-flight's duplicate-fact-value check — deliberately a
+       distinct color from calc-warning's amber so the two non-blocking warnings never look like
+       the same issue when both land on the same cell. */
+    .field-cell.duplicate-fact-warning {
+      box-shadow: inset 0 0 0 2px var(--jupiter-duplicate-warning-color, #8e24aa);
+    }
+
+    .duplicate-warning-badge {
+      position: absolute;
+      top: 2px;
+      left: 2px;
+      width: 16px;
+      height: 16px;
+      border-radius: 50%;
+      border: none;
+      background: var(--jupiter-duplicate-warning-color, #8e24aa);
+      color: #fff;
+      font-size: 10px;
+      font-weight: 700;
+      line-height: 1;
+      padding: 0;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      cursor: pointer;
+      z-index: 3;
+    }
+
+    .duplicate-warning-badge:hover {
+      background: #6a1b9a;
+    }
+
     /* Row-level highlight while a field in this row has focus. Applied to every
        cell so the row stays identifiable even after the user scrolls the table
        horizontally away from the focused input. */
@@ -7491,6 +7631,9 @@ __decorateClass$7([
 __decorateClass$7([
   n2({ type: Object })
 ], JupiterConceptTree.prototype, "calculationMismatches", 2);
+__decorateClass$7([
+  n2({ type: Object })
+], JupiterConceptTree.prototype, "duplicateFactWarnings", 2);
 __decorateClass$7([
   n2({ type: String })
 ], JupiterConceptTree.prototype, "language", 2);
@@ -9278,6 +9421,7 @@ let JupiterFormSection = class extends LitElement {
         .highlightColumnId="${(_b = this._highlightMap.get(instanceConcept.id)) == null ? void 0 : _b.columnId}"
         .rowFocused="${this._focusedConceptId === instanceConcept.id}"
         .calculationMismatches="${this._calculationMismatches}"
+        .duplicateFactWarnings="${this.duplicateFactWarnings}"
         @field-change="${this._handleFieldChange}"
         @field-focus="${this._handleFieldFocusForHighlight}"
         @period-change="${this._handlePeriodChange}"
@@ -9913,6 +10057,9 @@ __decorateClass$5([
 __decorateClass$5([
   n2({ type: Object })
 ], JupiterFormSection.prototype, "totalManuallyEditedData", 2);
+__decorateClass$5([
+  n2({ type: Object })
+], JupiterFormSection.prototype, "duplicateFactWarnings", 2);
 __decorateClass$5([
   r()
 ], JupiterFormSection.prototype, "_expanded", 2);
@@ -12233,6 +12380,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 +12484,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 +12676,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 +13014,11 @@ 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._duplicateFactWarnings = /* @__PURE__ */ new Map();
+    this._duplicateWarningPopupMode = "validate";
     this._submitDisabled = false;
     this._allSections = [];
     this._selectedRoleIds = [];
@@ -12844,6 +13076,15 @@ let JupiterDynamicForm = class extends LitElement {
     this.addEventListener("calculation-mismatch-changed", (e2) => {
       this._handleCalculationMismatchChanged(e2);
     });
+    this.addEventListener("duplicate-fact-warning-click", (e2) => {
+      const { mismatch } = e2.detail || {};
+      if (!mismatch)
+        return;
+      this._typedDimensionWarningFacts = [];
+      this._duplicateFactMismatches = [mismatch];
+      this._duplicateWarningPopupMode = "cellInfo";
+      this._showValidateWarningPopup = true;
+    });
     this.addEventListener("total-manually-edited", (e2) => {
       const { conceptId, columnId } = e2.detail;
       const updated = { ...this._totalManuallyEditedData };
@@ -13057,6 +13298,7 @@ let JupiterDynamicForm = class extends LitElement {
     if ((_a = this.xbrlInput) == null ? void 0 : _a.initialData) {
       this._formData = { ...this._formData, ...this.xbrlInput.initialData };
     }
+    this._formData = this._stripPriorYearExcludedFacts(this._formData);
     this._initializeGlobalDecimalsFromRoundingData();
     this._extractTypedMembersFromFacts();
     if (!this._skipDraftLoading) {
@@ -13737,8 +13979,15 @@ let JupiterDynamicForm = class extends LitElement {
   // which reads as "still cut off" when its row height isn't an exact multiple of the container.
   _scrollActiveRoleIntoView() {
     var _a;
-    const activeItem = (_a = this.shadowRoot) == null ? void 0 : _a.querySelector(".side-panel-roles-list .side-panel-role-item.active");
-    activeItem == null ? void 0 : activeItem.scrollIntoView({ block: "center" });
+    const rolesList = (_a = this.shadowRoot) == null ? void 0 : _a.querySelector(".side-panel-roles-list");
+    const activeItem = rolesList == null ? void 0 : rolesList.querySelector(".side-panel-role-item.active");
+    if (!rolesList || !activeItem)
+      return;
+    const listRect = rolesList.getBoundingClientRect();
+    const itemRect = activeItem.getBoundingClientRect();
+    const itemCenter = itemRect.top + itemRect.height / 2;
+    const listCenter = listRect.top + listRect.height / 2;
+    rolesList.scrollTop += itemCenter - listCenter;
   }
   // Re-locates the fact input identified by _lastFocusedFieldIdentity after a rebuild and restores
   // focus to it, mirroring the shadow-DOM traversal scrollToConcept/_handleErrorFieldClick use.
@@ -13963,6 +14212,29 @@ let JupiterDynamicForm = class extends LitElement {
     this._calculationWarnings = next;
     this._validateForm();
   }
+  // jenv-bw2-i:BalanceSheetBeforeAfterAppropriationResults isn't applicable to the previous-year
+  // column — mirrors `_isDisabledForPriorYear` in form-field.ts (which disables the input itself);
+  // this is the `_formData`/submission-side counterpart so a value already sitting in a draft,
+  // `initialData`, or preserved (hidden-role) data from before that UI restriction existed gets
+  // scrubbed on load and can never resurface in a later draft save or submission.
+  _isPriorYearExcludedFact(conceptId, columnId) {
+    return !!conceptId && !!columnId && conceptId.includes("BalanceSheetBeforeAfterAppropriationResults") && columnId.includes("_prev");
+  }
+  /** Strips any prior-year-excluded concept/column entries from a `FormData` map (immutable). */
+  _stripPriorYearExcludedFacts(data) {
+    const cleaned = {};
+    Object.keys(data).forEach((conceptId) => {
+      const columns = data[conceptId] || {};
+      const keptColumns = {};
+      Object.keys(columns).forEach((columnId) => {
+        if (!this._isPriorYearExcludedFact(conceptId, columnId)) {
+          keptColumns[columnId] = columns[columnId];
+        }
+      });
+      cleaned[conceptId] = keptColumns;
+    });
+    return cleaned;
+  }
   /**
    * JDF-058: single source of truth for writing a value into `_formData` with the immutable-update
    * pattern Lit reactivity needs — shared by a real user keystroke (`_handleFieldChange`) and the
@@ -13970,6 +14242,10 @@ let JupiterDynamicForm = class extends LitElement {
    * duplicated. Returns the value that was previously stored, for event `oldValue` fields.
    */
   _writeFormDataValue(conceptId, columnId, value) {
+    var _a;
+    if (this._isPriorYearExcludedFact(conceptId, columnId)) {
+      return (_a = this._formData[conceptId]) == null ? void 0 : _a[columnId];
+    }
     const updatedFormData = { ...this._formData };
     if (!updatedFormData[conceptId]) {
       updatedFormData[conceptId] = {};
@@ -14022,13 +14298,17 @@ let JupiterDynamicForm = class extends LitElement {
     this.requestUpdate();
   }
   _handleUnitChange(event) {
+    var _a;
     console.log(`🏷️ [DynamicForm] _handleUnitChange called with event:`, event);
     console.log(`🏷️ [DynamicForm] Event detail:`, event.detail);
     const { conceptId, columnId, unit } = event.detail;
     console.log(`🏷️ Unit change received: conceptId=${conceptId}, columnId=${columnId}, unit=${unit}`);
+    const isUnchanged = ((_a = this._unitData[conceptId]) == null ? void 0 : _a[columnId]) === unit;
     this._storeUnit(conceptId, columnId, unit);
-    this._dirty = true;
-    this.hasUnsavedChanges = true;
+    if (!isUnchanged) {
+      this._dirty = true;
+      this.hasUnsavedChanges = true;
+    }
     this.requestUpdate();
   }
   _storeUnit(conceptId, columnId, unit) {
@@ -14336,6 +14616,7 @@ let JupiterDynamicForm = class extends LitElement {
       console.log(`🟧 [DynamicForm] Removed ${beforeLength - this._xbrlFormErrors.length} errors`);
     }
     console.log(`🔍 [Validation] Total errors: ${this._xbrlFormErrors.length}`, this._xbrlFormErrors);
+    this._updateDuplicateFactWarnings(conceptId, columnId);
   }
   _getSectionTitle(sectionId) {
     console.log(`🔍 [_getSectionTitle] Looking for sectionId: "${sectionId}"`);
@@ -14354,7 +14635,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 +15333,164 @@ 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);
+  }
+  /**
+   * Live, blur-triggered counterpart to `_findDuplicateFactMismatches`. Re-runs the full duplicate
+   * check (cheap — the same pass Validate already does) and rebuilds `_duplicateFactWarnings` from
+   * scratch, so a resolved conflict clears itself and a newly created one appears without any
+   * extra bookkeeping. Every fact in every current mismatch group gets flagged, not just the field
+   * that was just blurred, so the user sees all the cells involved in a conflict — including one
+   * they filled in earlier — the moment either side changes, rather than having to revisit them
+   * one by one after Validate. Skipped when the blurred cell has no value and wasn't already
+   * flagged, since a blank cell can never be part of a mismatch (`_collectDuplicateFactCandidates`
+   * ignores blanks) — this keeps tabbing through empty cells cheap.
+   */
+  _updateDuplicateFactWarnings(conceptId, columnId) {
+    var _a;
+    const value = (_a = this._formData[conceptId]) == null ? void 0 : _a[columnId];
+    const hasMeaningfulValue = value !== void 0 && value !== null && String(value).trim() !== "";
+    const key = `${conceptId}__${columnId}`;
+    if (!hasMeaningfulValue && !this._duplicateFactWarnings.has(key))
+      return;
+    const mismatches = this._findDuplicateFactMismatches();
+    const updated = /* @__PURE__ */ new Map();
+    for (const mismatch of mismatches) {
+      for (const fact of mismatch.facts) {
+        updated.set(`${fact.conceptId}__${fact.columnId}`, mismatch);
+      }
+    }
+    this._duplicateFactWarnings = updated;
+  }
+  /** 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 +15502,14 @@ 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._duplicateWarningPopupMode = "validate";
+      this._showValidateWarningPopup = true;
       this._submitDisabled = false;
       this.requestUpdate();
       return;
@@ -15070,8 +15518,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;
@@ -15431,6 +15879,10 @@ let JupiterDynamicForm = class extends LitElement {
           return;
         }
       }
+      if (this._isPriorYearExcludedFact(conceptId, columnId)) {
+        console.log(`⏭️ Dropping legacy draft value for ${conceptId}/${columnId} — not applicable to the previous year`);
+        return;
+      }
       const instanceKey = draftInstanceId || conceptId;
       const baseConceptId = instanceKey.includes("__repeat_") ? instanceKey.split("__repeat_")[0] : instanceKey;
       const actualBaseId = this._findActualConceptId(baseConceptId);
@@ -15974,6 +16426,8 @@ let JupiterDynamicForm = class extends LitElement {
   }
   _addConceptDataToSubmission(concept, columnId, value, submissionData, section2) {
     var _a, _b, _c, _d, _e;
+    if (this._isPriorYearExcludedFact(concept.id, columnId))
+      return;
     const field2 = concept.fields.find((f2) => f2.columnId === columnId);
     if (!field2)
       return;
@@ -16146,26 +16600,25 @@ let JupiterDynamicForm = class extends LitElement {
       }
       if (concept.fields && concept.fields.length > 0) {
         concept.fields.forEach((field2) => {
-          var _a, _b, _c, _d, _e, _f, _g, _h;
+          var _a, _b, _c, _d, _e, _f, _g;
+          if (this._isPriorYearExcludedFact(concept.id, field2.columnId)) {
+            return;
+          }
           const conceptData = this._formData[concept.id];
-          let fieldValue = conceptData == null ? void 0 : conceptData[field2.columnId];
           const baseConceptId = field2.conceptId || concept.id.split("__").slice(0, -1).join("__") || concept.id;
-          if ((fieldValue === void 0 || fieldValue === null || fieldValue === "") && this._isRoundingLevelConcept(baseConceptId) && !this._hasValidGlobalDecimals()) {
+          const masterDataWins = this.mode !== "admin" && !!this._effectiveMasterData && baseConceptId in this._effectiveMasterData;
+          let fieldValue = masterDataWins ? this._effectiveMasterData[baseConceptId] : conceptData == null ? void 0 : conceptData[field2.columnId];
+          if (masterDataWins) {
+            console.log(`  📦 [Submission] Using masterData for: ${baseConceptId} [${field2.columnId}] = ${JSON.stringify(fieldValue)}`);
+          } else if ((fieldValue === void 0 || fieldValue === null || fieldValue === "") && this._isRoundingLevelConcept(baseConceptId) && !this._hasValidGlobalDecimals()) {
             const factValue = this._findFactValueForField(concept, field2, section2);
             if (factValue !== void 0 && factValue !== null && factValue !== "") {
               fieldValue = factValue;
             }
           }
-          if ((fieldValue === void 0 || fieldValue === null || fieldValue === "") && this._effectiveMasterData) {
-            const masterValue = (_a = this._effectiveMasterData) == null ? void 0 : _a[baseConceptId];
-            if (masterValue !== void 0 && masterValue !== null && masterValue !== "") {
-              fieldValue = masterValue;
-              console.log(`  📦 [Submission] Using masterData for: ${baseConceptId} [${field2.columnId}] = ${JSON.stringify(fieldValue)}`);
-            }
-          }
           if (fieldValue !== void 0 && fieldValue !== null && fieldValue !== "") {
             const column2 = this._findColumnByIdInSection(field2.columnId, section2);
-            const fieldPeriodData = (_b = this._periodData[concept.id]) == null ? void 0 : _b[field2.columnId];
+            const fieldPeriodData = (_a = this._periodData[concept.id]) == null ? void 0 : _a[field2.columnId];
             const submissionEntry = {
               conceptId: concept.id,
               draftInstanceId: concept.id,
@@ -16187,21 +16640,21 @@ let JupiterDynamicForm = class extends LitElement {
               submissionEntry.period.endDate = endDate;
             }
             console.log(`🔍 [Submission] Concept: ${concept.id}, Column: ${field2.columnId}, Field Period: ${fieldPeriodData ? JSON.stringify(fieldPeriodData) : "none"}, Column Period: ${(column2 == null ? void 0 : column2.periodStartDate) || "none"} - ${(column2 == null ? void 0 : column2.periodEndDate) || "none"}, Used Period: ${submissionEntry.period.type === "instant" ? submissionEntry.period.date : `${submissionEntry.period.startDate} - ${submissionEntry.period.endDate}`}`);
-            const fieldUnit = (_c = this._unitData[concept.id]) == null ? void 0 : _c[field2.columnId];
+            const fieldUnit = (_b = this._unitData[concept.id]) == null ? void 0 : _b[field2.columnId];
             if (fieldUnit) {
               submissionEntry.unit = fieldUnit;
               console.log(`✅ [Submission] Adding unit to entry: ${fieldUnit} for ${concept.id}/${field2.columnId}`);
             } else {
               console.log(`⚠️ [Submission] No unit found in _unitData for ${concept.id}/${field2.columnId}. _unitData state:`, JSON.stringify(this._unitData, null, 2));
             }
-            const isMonetary = (_d = concept.type) == null ? void 0 : _d.toLowerCase().includes("monetary");
-            const fieldDecimals = (_e = this._decimalsData[concept.id]) == null ? void 0 : _e[field2.columnId];
+            const isMonetary = (_c = concept.type) == null ? void 0 : _c.toLowerCase().includes("monetary");
+            const fieldDecimals = (_d = this._decimalsData[concept.id]) == null ? void 0 : _d[field2.columnId];
             const decimalsValue = fieldDecimals || (this.decimals !== "INF" ? this.decimals : void 0);
             if (isMonetary && decimalsValue) {
               const parsed = parseFloat(decimalsValue);
               submissionEntry.decimals = isNaN(parsed) ? decimalsValue : String(-Math.abs(parsed));
             }
-            if ((column2 == null ? void 0 : column2.type) === "dimension" && ((_f = column2.dimensionData) == null ? void 0 : _f.dimensionIdKey)) {
+            if ((column2 == null ? void 0 : column2.type) === "dimension" && ((_e = column2.dimensionData) == null ? void 0 : _e.dimensionIdKey)) {
               submissionEntry.dimension = column2.dimensionData.dimensionIdKey;
               console.log(`🔍 [DynamicForm] Using dimension key from field's column (${field2.columnId}):`, column2.dimensionData.dimensionIdKey);
             } else {
@@ -16240,12 +16693,12 @@ let JupiterDynamicForm = class extends LitElement {
                 console.log(`🔍 [DynamicForm] Column details:`, {
                   id: column2.id,
                   type: column2.type,
-                  hasTypedMembers: (_g = column2.dimensionData) == null ? void 0 : _g.hasTypedMembers,
+                  hasTypedMembers: (_f = column2.dimensionData) == null ? void 0 : _f.hasTypedMembers,
                   dimensionData: column2.dimensionData
                 });
               }
             }
-            if (!submissionEntry.typedMembers && ((_h = field2.crossRoleTypedMembers) == null ? void 0 : _h.length)) {
+            if (!submissionEntry.typedMembers && ((_g = field2.crossRoleTypedMembers) == null ? void 0 : _g.length)) {
               const crossRoleKey = `${concept.id}__${field2.columnId}`;
               const crossRoleValues = this._typedMemberData[crossRoleKey];
               if (crossRoleValues) {
@@ -16336,7 +16789,7 @@ let JupiterDynamicForm = class extends LitElement {
     });
   }
   _handleReset() {
-    this._formData = { ...this.initialData };
+    this._formData = this._stripPriorYearExcludedFacts(this.initialData);
     this._touched.clear();
     this._dirty = false;
     this.hasUnsavedChanges = false;
@@ -17103,6 +17556,7 @@ let JupiterDynamicForm = class extends LitElement {
             .periodEndDate="${this.periodEndDate}"
             .calculationEnabled="${this.calculationEnabled}"
             .totalManuallyEditedData="${this._totalManuallyEditedData}"
+            .duplicateFactWarnings="${this._duplicateFactWarnings}"
             @field-change="${this._handleFieldChange}"
             @period-change="${this._handlePeriodChange}"
             @typed-member-change="${this._handleTypedMemberChange}"
@@ -17310,6 +17764,7 @@ let JupiterDynamicForm = class extends LitElement {
                 .periodEndDate="${this.periodEndDate}"
                 .calculationEnabled="${this.calculationEnabled}"
                 .totalManuallyEditedData="${this._totalManuallyEditedData}"
+                .duplicateFactWarnings="${this._duplicateFactWarnings}"
                 @field-change="${this._handleFieldChange}"
                 @typed-member-change="${this._handleTypedMemberChange}"
                 @add-concept-repeat="${this._handleAddConceptRepeat}"
@@ -17362,7 +17817,7 @@ let JupiterDynamicForm = class extends LitElement {
     return { ...this._formData };
   }
   setData(data) {
-    this._formData = { ...data };
+    this._formData = this._stripPriorYearExcludedFacts(data);
     this._dirty = true;
     this.hasUnsavedChanges = true;
     this._validateForm();
@@ -18098,55 +18553,96 @@ 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._duplicateWarningPopupMode === "validate" ? html`
+                  <button class="btn-secondary" @click="${() => {
+      this._showValidateWarningPopup = false;
       this.requestUpdate();
     }}">${I18n.t("typedDimensionWarning.cancel")}</button>
-                <button class="btn-primary" @click="${() => {
-      this._showTypedDimensionWarning = false;
+                  <button class="btn-primary" @click="${() => {
+      this._showValidateWarningPopup = false;
       this._continueSubmit();
     }}">${I18n.t("typedDimensionWarning.continue")}</button>
+                ` : html`
+                  <button class="btn-primary" @click="${() => {
+      this._showValidateWarningPopup = false;
+      this.requestUpdate();
+    }}">${I18n.t("duplicateFactWarning.close")}</button>
+                `}
               </div>
             </div>
           </div>
@@ -19023,6 +19519,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 +19769,19 @@ __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, "_duplicateFactWarnings", 2);
+__decorateClass([
+  r()
+], JupiterDynamicForm.prototype, "_duplicateWarningPopupMode", 2);
 __decorateClass([
   r()
 ], JupiterDynamicForm.prototype, "_submitDisabled", 2);