jupiter-dynamic-forms 1.20.5 → 1.20.7

package/dist/index.mjs

@@ -989,7 +989,9 @@ class XBRLFormBuilder {
         axisId: dimension.id,
         axisLabel,
         typedMemberId: dimension.typedMember.id,
-        memberLabel: axisLabel
+        memberLabel: axisLabel,
+        type: dimension.typedMember.type,
+        validation: dimension.typedMember.validation
       });
     }
     return result.length > 0 ? result : null;
@@ -1181,6 +1183,8 @@ class XBRLFormBuilder {
         axisId: dimension.id,
         axisLabel: axisLabel2,
         typedMemberId: dimension.typedMember.id,
+        type: dimension.typedMember.type,
+        validation: dimension.typedMember.validation,
         dimensionKey: `${axisLabel2} | [Typed Input]`,
         dimensionIdKey: `${dimension.id}|[typed]`
       };
@@ -1207,7 +1211,9 @@ class XBRLFormBuilder {
               axisId: dimensionInfo2.axisId,
               axisLabel: dimensionInfo2.axisLabel,
               typedMemberId: dimensionInfo2.typedMemberId,
-              memberLabel: dimensionInfo2.axisLabel
+              memberLabel: dimensionInfo2.axisLabel,
+              type: dimensionInfo2.type,
+              validation: dimensionInfo2.validation
             }]
           },
           order: 0,
@@ -1237,7 +1243,9 @@ class XBRLFormBuilder {
               axisId: dimensionInfo2.axisId,
               axisLabel: dimensionInfo2.axisLabel,
               typedMemberId: dimensionInfo2.typedMemberId,
-              memberLabel: dimensionInfo2.axisLabel
+              memberLabel: dimensionInfo2.axisLabel,
+              type: dimensionInfo2.type,
+              validation: dimensionInfo2.validation
             }]
           },
           order: 0,
@@ -1267,7 +1275,9 @@ class XBRLFormBuilder {
               axisId: dimensionInfo2.axisId,
               axisLabel: dimensionInfo2.axisLabel,
               typedMemberId: dimensionInfo2.typedMemberId,
-              memberLabel: dimensionInfo2.axisLabel
+              memberLabel: dimensionInfo2.axisLabel,
+              type: dimensionInfo2.type,
+              validation: dimensionInfo2.validation
             }]
           },
           order: 0,
@@ -1297,7 +1307,9 @@ class XBRLFormBuilder {
               axisId: dimensionInfo2.axisId,
               axisLabel: dimensionInfo2.axisLabel,
               typedMemberId: dimensionInfo2.typedMemberId,
-              memberLabel: dimensionInfo2.axisLabel
+              memberLabel: dimensionInfo2.axisLabel,
+              type: dimensionInfo2.type,
+              validation: dimensionInfo2.validation
             }]
           },
           order: 0,
@@ -1442,6 +1454,8 @@ class XBRLFormBuilder {
           axisLabel,
           isTyped: true,
           typedMemberId: dimension.typedMember.id,
+          type: dimension.typedMember.type,
+          validation: dimension.typedMember.validation,
           members: [{
             id: "[typed]",
             label: `${axisLabel}`
@@ -1482,7 +1496,9 @@ class XBRLFormBuilder {
           axisId: c2.axisId,
           axisLabel: c2.axisLabel,
           typedMemberId: c2.typedMemberId,
-          memberLabel: c2.memberLabel
+          memberLabel: c2.memberLabel,
+          type: c2.type,
+          validation: c2.validation
         })),
         hasTypedMembers: typedMembers.length > 0,
         memberKey: columnTitle,
@@ -1537,7 +1553,9 @@ class XBRLFormBuilder {
         memberId: member.id,
         memberLabel: member.label,
         isTyped: dimensionInfos[0].isTyped || false,
-        typedMemberId: dimensionInfos[0].typedMemberId
+        typedMemberId: dimensionInfos[0].typedMemberId,
+        type: dimensionInfos[0].type,
+        validation: dimensionInfos[0].validation
       }]);
     }
     const [firstDimension, ...restDimensions] = dimensionInfos;
@@ -1551,7 +1569,9 @@ class XBRLFormBuilder {
           memberId: member.id,
           memberLabel: member.label,
           isTyped: firstDimension.isTyped || false,
-          typedMemberId: firstDimension.typedMemberId
+          typedMemberId: firstDimension.typedMemberId,
+          type: firstDimension.type,
+          validation: firstDimension.validation
         }]);
       } else {
         restCombinations.forEach((restCombination) => {
@@ -1562,7 +1582,9 @@ class XBRLFormBuilder {
               memberId: member.id,
               memberLabel: member.label,
               isTyped: firstDimension.isTyped || false,
-              typedMemberId: firstDimension.typedMemberId
+              typedMemberId: firstDimension.typedMemberId,
+              type: firstDimension.type,
+              validation: firstDimension.validation
             },
             ...restCombination
           ]);
@@ -1783,7 +1805,8 @@ const admin$1 = {
 const validation$1 = {
   summary: "Please fix the following errors before submitting:",
   errorsFound: "errors found",
-  unitRequired: "Unit is required. Please select a unit via the period icon."
+  unitRequired: "Unit is required. Please select a unit via the period icon.",
+  typedMemberRequired: "This field is required because data has been entered in this column."
 };
 const xbrlValidation$1 = {
   patternMismatch: "Value does not match required pattern: {{pattern}}",
@@ -1989,7 +2012,8 @@ const admin = {
 const validation = {
   summary: "Corrigeer de volgende fouten voordat u indient:",
   errorsFound: "fouten gevonden",
-  unitRequired: "Eenheid is verplicht. Selecteer een eenheid via het periodeicoon."
+  unitRequired: "Eenheid is verplicht. Selecteer een eenheid via het periodeicoon.",
+  typedMemberRequired: "Dit veld is verplicht omdat er gegevens zijn ingevoerd in deze kolom."
 };
 const xbrlValidation = {
   patternMismatch: "Waarde voldoet niet aan het vereiste patroon: {{pattern}}",
@@ -2766,13 +2790,24 @@ function indexConceptTree(concept, conceptByQName, conceptById, conceptIdByQName
   );
   children.forEach((child) => indexConceptTree(child, conceptByQName, conceptById, conceptIdByQName, conceptIdByQNameHasChildren, childrenIndex));
 }
-function indexMemberTree(member, memberQNameToId, memberChildrenByQName) {
+function collectMemberSubtreeIds(member) {
+  const ids = [member.id];
+  (member.children || []).forEach((child) => ids.push(...collectMemberSubtreeIds(child)));
+  return ids;
+}
+function indexMemberTree(member, memberQNameToId, memberChildrenByQName, memberDescendantOrSelfIdsByQName, memberIdsWithParent) {
   if (!memberQNameToId.has(member.conceptName))
     memberQNameToId.set(member.conceptName, member.id);
   if (!memberChildrenByQName.has(member.conceptName)) {
     memberChildrenByQName.set(member.conceptName, (member.children || []).map((child) => child.id));
   }
-  (member.children || []).forEach((child) => indexMemberTree(child, memberQNameToId, memberChildrenByQName));
+  if (!memberDescendantOrSelfIdsByQName.has(member.conceptName)) {
+    memberDescendantOrSelfIdsByQName.set(member.conceptName, collectMemberSubtreeIds(member));
+  }
+  (member.children || []).forEach((child) => {
+    memberIdsWithParent.add(child.id);
+    indexMemberTree(child, memberQNameToId, memberChildrenByQName, memberDescendantOrSelfIdsByQName, memberIdsWithParent);
+  });
 }
 const PRESENTATION_TOTAL_GROUP_ACCESSORS = {
   getId: (concept) => concept.id,
@@ -2802,16 +2837,35 @@ function buildFormulaResolutionContext(formData, columns, sections, hypercubeRol
     if (section2.columns)
       columnsByRole.set(section2.roleURI, section2.columns);
   });
+  const crossRoleChildrenByQName = /* @__PURE__ */ new Map();
+  conceptIdByQNamePerRole.forEach((conceptIdByQName, roleURI) => {
+    const childrenIndex = childrenByRole.get(roleURI);
+    const totalGroupIndex = totalGroupChildrenByRole.get(roleURI);
+    conceptIdByQName.forEach((conceptId, qname) => {
+      var _a;
+      const nestedChildren = (childrenIndex == null ? void 0 : childrenIndex.get(conceptId)) || [];
+      const children = nestedChildren.length > 0 ? nestedChildren : (totalGroupIndex == null ? void 0 : totalGroupIndex.get(conceptId)) || [];
+      if (children.length === 0)
+        return;
+      if (!crossRoleChildrenByQName.has(qname))
+        crossRoleChildrenByQName.set(qname, /* @__PURE__ */ new Map());
+      (_a = crossRoleChildrenByQName.get(qname)) == null ? void 0 : _a.set(roleURI, children);
+    });
+  });
   const dimensionQNameToId = /* @__PURE__ */ new Map();
   const memberQNameToId = /* @__PURE__ */ new Map();
   const memberChildrenByQName = /* @__PURE__ */ new Map();
+  const memberDescendantOrSelfIdsByQName = /* @__PURE__ */ new Map();
+  const memberIdsWithParent = /* @__PURE__ */ new Set();
   (hypercubeRoles || []).forEach((role) => {
     role.items.forEach((item) => {
       item.dimensions.forEach((dimension) => {
         if (!dimensionQNameToId.has(dimension.conceptName)) {
           dimensionQNameToId.set(dimension.conceptName, dimension.id);
         }
-        (dimension.members || []).forEach((member) => indexMemberTree(member, memberQNameToId, memberChildrenByQName));
+        (dimension.members || []).forEach(
+          (member) => indexMemberTree(member, memberQNameToId, memberChildrenByQName, memberDescendantOrSelfIdsByQName, memberIdsWithParent)
+        );
       });
     });
   });
@@ -2825,9 +2879,12 @@ function buildFormulaResolutionContext(formData, columns, sections, hypercubeRol
     conceptIdByQNamePerRole,
     childrenByRole,
     totalGroupChildrenByRole,
+    crossRoleChildrenByQName,
     dimensionQNameToId,
     memberQNameToId,
     memberChildrenByQName,
+    memberDescendantOrSelfIdsByQName,
+    memberIdsWithParent,
     columnsByRole,
     roleURIByConceptId,
     allCandidates: collectAllCandidates(formData),
@@ -2951,6 +3008,21 @@ function resolveChildMemberAxisFilter(memberQName, axisId, universe, ctx, siblin
     return [];
   return universe.filter((candidate) => !directChildren.has(candidate.conceptId));
 }
+function resolveDescendantOrSelfMemberAxisFilter(memberQName, axisId, universe, ctx) {
+  const memberIds = ctx.memberDescendantOrSelfIdsByQName.get(memberQName) || [];
+  if (memberIds.length === 0)
+    return [];
+  return universe.filter((candidate) => memberIds.some((id) => columnMatchesExplicitDimension(getColumn(ctx, candidate), axisId, id)));
+}
+function resolveCrossRoleChildren(anchorQName, ownLinkrole, ctx) {
+  if (!anchorQName)
+    return [];
+  const candidatesByRole = ctx.crossRoleChildrenByQName.get(anchorQName);
+  if (!candidatesByRole)
+    return [];
+  const otherRoles = Array.from(candidatesByRole.entries()).filter(([roleURI]) => roleURI !== ownLinkrole);
+  return otherRoles.length === 1 ? otherRoles[0][1] : [];
+}
 function matchFilter(filter2, universe, ctx, siblingFilters) {
   var _a, _b;
   switch (filter2.type) {
@@ -2983,6 +3055,9 @@ function matchFilter(filter2, universe, ctx, siblingFilters) {
       } else {
         const nestedChildren = childrenIndex.get(anchorConceptId) || [];
         relatedConceptIds = nestedChildren.length > 0 ? nestedChildren : ((_b = ctx.totalGroupChildrenByRole.get(linkrole ?? "")) == null ? void 0 : _b.get(anchorConceptId)) || [];
+        if (relatedConceptIds.length === 0) {
+          relatedConceptIds = resolveCrossRoleChildren(anchorQName, linkrole, ctx);
+        }
       }
       const relatedSet = new Set(relatedConceptIds);
       return universe.filter((candidate) => relatedSet.has(candidate.conceptId));
@@ -2993,9 +3068,13 @@ function matchFilter(filter2, universe, ctx, siblingFilters) {
       const axisId = dimensionQName ? ctx.dimensionQNameToId.get(dimensionQName) : void 0;
       if (!axisId)
         return [];
-      if (memberQName && filter2.attributes["member.axis"] === "child") {
+      const memberAxis = filter2.attributes["member.axis"];
+      if (memberQName && memberAxis === "child") {
         return resolveChildMemberAxisFilter(memberQName, axisId, universe, ctx, siblingFilters);
       }
+      if (memberQName && memberAxis === "descendant-or-self") {
+        return resolveDescendantOrSelfMemberAxisFilter(memberQName, axisId, universe, ctx);
+      }
       const memberId = memberQName ? ctx.memberQNameToId.get(memberQName) : void 0;
       return universe.filter((candidate) => columnMatchesExplicitDimension(getColumn(ctx, candidate), axisId, memberId));
     }
@@ -3015,8 +3094,17 @@ function matchFilter(filter2, universe, ctx, siblingFilters) {
       return unionCandidates(filter2.children.map((child) => resolveFilter(child, universe, ctx, siblingFilters)));
     case "ASPECT_COVER":
       return universe;
-    case "UNKNOWN":
+    case "UNKNOWN": {
+      const boundary = filter2.attributes["boundary"];
+      if (boundary === "start" || boundary === "end") {
+        const requiredRole = boundary === "start" ? "periodStartLabel" : "periodEndLabel";
+        return universe.filter((candidate) => {
+          var _a2;
+          return ((_a2 = ctx.conceptById.get(candidate.conceptId)) == null ? void 0 : _a2.effectivePeriodRole) === requiredRole;
+        });
+      }
       return universe;
+    }
     default:
       return [];
   }
@@ -3087,15 +3175,37 @@ function narrowByPreferredOccurrence(candidates, ctx) {
   });
   return result;
 }
-function resolveFormulaVariable(variable, ctx) {
-  const matched = narrowByPreferredOccurrence(narrowToCurrentPeriod(resolveMatchedCandidates(variable, ctx), variable, ctx), ctx);
+function narrowToDirectChildOfDescendantAnchor(candidates, variable, ctx) {
+  var _a, _b;
+  if (variable.bindAsSequence)
+    return candidates;
+  if (new Set(candidates.map((candidate) => candidate.conceptId)).size <= 1)
+    return candidates;
+  const relationFilter = variable.filters.find(
+    (filter2) => filter2.type === "CONCEPT_RELATION" && filter2.attributes["axis"] === "descendant"
+  );
+  const anchorQName = relationFilter == null ? void 0 : relationFilter.attributes["qname"];
+  const linkrole = relationFilter == null ? void 0 : relationFilter.attributes["linkrole"];
+  const anchorConceptId = anchorQName && linkrole ? (_a = ctx.conceptIdByQNamePerRole.get(linkrole)) == null ? void 0 : _a.get(anchorQName) : void 0;
+  const directChildren = new Set(anchorConceptId && linkrole ? ((_b = ctx.childrenByRole.get(linkrole)) == null ? void 0 : _b.get(anchorConceptId)) || [] : []);
+  if (directChildren.size === 0)
+    return candidates;
+  return candidates.filter((candidate) => directChildren.has(candidate.conceptId));
+}
+function resolveNarrowedCandidates(variable, ctx) {
+  return narrowByPreferredOccurrence(
+    narrowToDirectChildOfDescendantAnchor(narrowToCurrentPeriod(resolveMatchedCandidates(variable, ctx), variable, ctx), variable, ctx),
+    ctx
+  );
+}
+function valuesFromCandidates(variable, matched, ctx) {
   const values = matched.map((candidate) => {
     var _a;
     return resolveRawValue((_a = ctx.formData[candidate.conceptId]) == null ? void 0 : _a[candidate.columnId]);
   }).filter((value) => value !== void 0);
+  if (values.length === 0 && variable.fallbackValue === "()")
+    return [];
   if (variable.bindAsSequence) {
-    if (values.length === 0 && variable.fallbackValue === "()")
-      return [];
     if (values.length === 0)
       return void 0;
     return values;
@@ -3109,6 +3219,186 @@ function resolveFormulaVariable(variable, ctx) {
   }
   return values[0];
 }
+function uncoveredExplicitDimensionAxisIds(variable, ctx) {
+  const axisIds = /* @__PURE__ */ new Set();
+  for (const filter2 of variable.filters) {
+    if (filter2.type !== "EXPLICIT_DIMENSION" || filter2.complement || filter2.cover)
+      continue;
+    if (filter2.attributes["member.qname"])
+      continue;
+    const axisId = ctx.dimensionQNameToId.get(filter2.attributes["dimension.qname"] ?? "");
+    if (axisId)
+      axisIds.add(axisId);
+  }
+  return axisIds;
+}
+function candidateMemberIdForAxis(ctx, candidate, axisId) {
+  var _a;
+  const column2 = getColumn(ctx, candidate);
+  if (!(column2 == null ? void 0 : column2.dimensionData))
+    return void 0;
+  if (column2.dimensionData.axisId === axisId)
+    return column2.dimensionData.memberId;
+  return (_a = (column2.dimensionData.combinations || []).find((combo) => combo.axisId === axisId)) == null ? void 0 : _a.memberId;
+}
+function findUncoveredAxisAnchor(variables, axisId, candidatesByName, ctx) {
+  for (const variable of variables) {
+    if (variable.bindAsSequence)
+      continue;
+    if (!uncoveredExplicitDimensionAxisIds(variable, ctx).has(axisId))
+      continue;
+    const candidates = candidatesByName.get(variable.name) || [];
+    const memberIds = new Set(
+      candidates.map((candidate) => candidateMemberIdForAxis(ctx, candidate, axisId)).filter((id) => id !== void 0)
+    );
+    if (memberIds.size === 1)
+      return { memberId: [...memberIds][0], variableName: variable.name, ambiguous: false };
+    const rootMembers = [...memberIds].filter((id) => !ctx.memberIdsWithParent.has(id));
+    if (rootMembers.length === 1)
+      return { memberId: rootMembers[0], variableName: variable.name, ambiguous: true };
+  }
+  return void 0;
+}
+function resolveAssertionVariableBindings(variables, ctx, implicitFiltering) {
+  const candidatesByName = /* @__PURE__ */ new Map();
+  variables.forEach((variable) => candidatesByName.set(variable.name, resolveNarrowedCandidates(variable, ctx)));
+  if (implicitFiltering) {
+    const axisIds = /* @__PURE__ */ new Set();
+    variables.forEach((variable) => uncoveredExplicitDimensionAxisIds(variable, ctx).forEach((axisId) => axisIds.add(axisId)));
+    axisIds.forEach((axisId) => {
+      const anchor = findUncoveredAxisAnchor(variables, axisId, candidatesByName, ctx);
+      if (!anchor)
+        return;
+      variables.forEach((variable) => {
+        const isNarrowableSequence = variable.bindAsSequence && uncoveredExplicitDimensionAxisIds(variable, ctx).has(axisId);
+        const isAmbiguousAnchorItself = anchor.ambiguous && variable.name === anchor.variableName;
+        if (!isNarrowableSequence && !isAmbiguousAnchorItself)
+          return;
+        const candidates = candidatesByName.get(variable.name) || [];
+        candidatesByName.set(
+          variable.name,
+          candidates.filter((candidate) => candidateMemberIdForAxis(ctx, candidate, axisId) === anchor.memberId)
+        );
+      });
+    });
+  }
+  const bindings = /* @__PURE__ */ new Map();
+  variables.forEach((variable) => bindings.set(variable.name, valuesFromCandidates(variable, candidatesByName.get(variable.name) || [], ctx)));
+  return bindings;
+}
+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 });
+}
+function detectSumOfMembersOnAbstractShape(assertion) {
+  if (assertion.type !== "VALUE_ASSERTION" || assertion.variables.length !== 2)
+    return void 0;
+  const scalarVariable = assertion.variables.find((v) => !v.bindAsSequence);
+  const sequenceVariable = assertion.variables.find((v) => v.bindAsSequence);
+  if (!scalarVariable || !sequenceVariable)
+    return void 0;
+  const isDescendantRelation = (f2) => f2.type === "CONCEPT_RELATION" && f2.attributes["axis"] === "descendant" && !f2.complement && !f2.cover;
+  const scalarCR = scalarVariable.filters.find(isDescendantRelation);
+  const seqCR = sequenceVariable.filters.find(isDescendantRelation);
+  if (!scalarCR || !seqCR)
+    return void 0;
+  const anchorQName = scalarCR.attributes["qname"];
+  const linkrole = scalarCR.attributes["linkrole"];
+  if (!anchorQName || !linkrole)
+    return void 0;
+  if (seqCR.attributes["qname"] !== anchorQName || seqCR.attributes["linkrole"] !== linkrole)
+    return void 0;
+  const scalarED = scalarVariable.filters.find(
+    (f2) => f2.type === "EXPLICIT_DIMENSION" && !f2.complement && f2.cover && !("member.axis" in f2.attributes)
+  );
+  const seqED = sequenceVariable.filters.find(
+    (f2) => f2.type === "EXPLICIT_DIMENSION" && !f2.complement && f2.cover && f2.attributes["member.axis"] === "child"
+  );
+  if (!scalarED || !seqED)
+    return void 0;
+  const dimensionQName = scalarED.attributes["dimension.qname"];
+  const memberQName = scalarED.attributes["member.qname"];
+  if (!dimensionQName || !memberQName)
+    return void 0;
+  if (seqED.attributes["dimension.qname"] !== dimensionQName || seqED.attributes["member.qname"] !== memberQName)
+    return void 0;
+  const scalarOther = scalarVariable.filters.filter((f2) => f2 !== scalarCR && f2 !== scalarED).map(filterSignature).sort();
+  const seqOther = sequenceVariable.filters.filter((f2) => f2 !== seqCR && f2 !== seqED).map(filterSignature).sort();
+  if (scalarOther.length !== seqOther.length || scalarOther.some((sig, i2) => sig !== seqOther[i2]))
+    return void 0;
+  return { scalarVariable, sequenceVariable, anchorQName, linkrole, dimensionQName, memberQName };
+}
+function resolveSumOfMembersOnAbstractSatisfaction(shape, ctx) {
+  var _a;
+  const { scalarVariable, sequenceVariable, anchorQName, linkrole, dimensionQName, memberQName } = shape;
+  const anchorConceptId = (_a = ctx.conceptIdByQNamePerRole.get(linkrole)) == null ? void 0 : _a.get(anchorQName);
+  const childrenIndex = ctx.childrenByRole.get(linkrole);
+  if (!anchorConceptId || !childrenIndex)
+    return "not-applicable";
+  const descendantConceptIds = collectDescendantConceptIds(childrenIndex, anchorConceptId);
+  if (descendantConceptIds.length === 0)
+    return "not-applicable";
+  const axisId = ctx.dimensionQNameToId.get(dimensionQName);
+  const rootMemberId = ctx.memberQNameToId.get(memberQName);
+  const childMemberIds = ctx.memberChildrenByQName.get(memberQName) || [];
+  if (!axisId || !rootMemberId || childMemberIds.length === 0)
+    return "not-applicable";
+  const sharedFilters = scalarVariable.filters.filter(
+    (f2) => !(f2.type === "CONCEPT_RELATION" && f2.attributes["axis"] === "descendant") && !(f2.type === "EXPLICIT_DIMENSION" && f2.attributes["dimension.qname"] === dimensionQName)
+  );
+  const sharedPool = sharedFilters.length > 0 ? intersectCandidates(sharedFilters.map((f2) => resolveFilter(f2, ctx.allCandidates, ctx, sharedFilters))) : ctx.allCandidates;
+  const descendantSet = new Set(descendantConceptIds);
+  const poolByConceptId = /* @__PURE__ */ new Map();
+  sharedPool.forEach((candidate) => {
+    if (!descendantSet.has(candidate.conceptId))
+      return;
+    const list = poolByConceptId.get(candidate.conceptId);
+    if (list)
+      list.push(candidate);
+    else
+      poolByConceptId.set(candidate.conceptId, [candidate]);
+  });
+  const hasGenuineChildMemberData = Array.from(poolByConceptId.values()).some((candidates) => candidates.some((candidate) => childMemberIds.some((id) => columnMatchesExplicitDimension(getColumn(ctx, candidate), axisId, id))));
+  if (!hasGenuineChildMemberData)
+    return "not-applicable";
+  let comparedAny = false;
+  for (const conceptId of descendantConceptIds) {
+    const candidates = poolByConceptId.get(conceptId);
+    if (!candidates || candidates.length === 0)
+      continue;
+    const scalarCandidates = narrowToCurrentPeriod(
+      candidates.filter((candidate) => columnMatchesExplicitDimension(getColumn(ctx, candidate), axisId, rootMemberId)),
+      scalarVariable,
+      ctx
+    );
+    const childCandidates = narrowToCurrentPeriod(
+      candidates.filter((candidate) => childMemberIds.some((id) => columnMatchesExplicitDimension(getColumn(ctx, candidate), axisId, id))),
+      sequenceVariable,
+      ctx
+    );
+    const scalarValues = scalarCandidates.map((candidate) => {
+      var _a2;
+      return resolveRawValue((_a2 = ctx.formData[candidate.conceptId]) == null ? void 0 : _a2[candidate.columnId]);
+    }).filter((value) => typeof value === "number");
+    const childValues = childCandidates.map((candidate) => {
+      var _a2;
+      return resolveRawValue((_a2 = ctx.formData[candidate.conceptId]) == null ? void 0 : _a2[candidate.columnId]);
+    }).filter((value) => typeof value === "number");
+    if (scalarValues.length === 0 || childValues.length === 0)
+      continue;
+    if (scalarValues.length > 1) {
+      console.warn(
+        `[formula-variable-resolver] SumOfMembersOnAbstract concept "${conceptId}" matched ${scalarValues.length} aggregate-member facts; using the first by column order.`
+      );
+    }
+    const scalarValue = scalarValues[0];
+    const childrenSum = childValues.reduce((sum, value) => sum + value, 0);
+    comparedAny = true;
+    if (Math.abs(scalarValue - childrenSum) >= CALCULATION_TOLERANCE)
+      return false;
+  }
+  return comparedAny ? true : "unresolvable";
+}
 function resolveFormulaVariableMatchCount(variable, ctx) {
   return resolveMatchedCandidates(variable, ctx).length;
 }
@@ -3151,11 +3441,7 @@ function resolveVariableColumnsForConcept(variable, targetConceptId, ctx) {
   return resolved.map((candidate) => candidate.columnId);
 }
 function buildAssertionBindings(assertion, ctx) {
-  const bindings = /* @__PURE__ */ new Map();
-  for (const variable of assertion.variables) {
-    bindings.set(variable.name, resolveFormulaVariable(variable, ctx));
-  }
-  return bindings;
+  return resolveAssertionVariableBindings(assertion.variables, ctx, assertion.implicitFiltering);
 }
 function buildAssertionFallbackUsage(assertion, ctx) {
   var _a;
@@ -3248,7 +3534,10 @@ class FormulaValidationService {
   _evaluateAssertion(assertion, role, ctx, language) {
     try {
       const bindings = buildAssertionBindings(assertion, ctx);
-      if (assertion.type === "VALUE_ASSERTION") {
+      const sumOfMembersShape = detectSumOfMembersOnAbstractShape(assertion);
+      const sumOfMembersResult = sumOfMembersShape ? resolveSumOfMembersOnAbstractSatisfaction(sumOfMembersShape, ctx) : void 0;
+      const usesSumOfMembersPath = sumOfMembersResult !== void 0 && sumOfMembersResult !== "not-applicable";
+      if (assertion.type === "VALUE_ASSERTION" && !usesSumOfMembersPath) {
         const bindingCheck = checkAllVariablesBound(assertion, bindings);
         if (!bindingCheck.satisfied) {
           return this._skippedResult(assertion, role, bindingCheck.skipReason ?? "unresolvable");
@@ -3264,6 +3553,12 @@ class FormulaValidationService {
         const satisfied2 = evaluateExistenceTest(assertion.test, matchedFactCount);
         return this._evaluatedResult(assertion, role, ctx, satisfied2, language, matchedFactCount);
       }
+      if (usesSumOfMembersPath) {
+        if (sumOfMembersResult === "unresolvable") {
+          return this._skippedResult(assertion, role, "unresolvable");
+        }
+        return this._evaluatedResult(assertion, role, ctx, sumOfMembersResult, language);
+      }
       const satisfied = evaluateFormulaTest(assertion.test, bindings, fallbackUsage);
       return this._evaluatedResult(assertion, role, ctx, satisfied, language);
     } catch (error2) {
@@ -3592,204 +3887,6 @@ class FactMatcher {
     console.log("  Match Result:", match ? match.value : "No match");
   }
 }
-class XBRLValidator {
-  /**
-   * Validates a value against XBRL datatype validation rules
-   * Only validates when value is not blank
-   * 
-   * @param conceptType - The XBRL concept type (e.g., "nl-types:houseNumberNLItemType")
-   * @param value - The input value to validate
-   * @param datatypes - Array of XBRL datatypes from taxonomy
-   * @returns Validation result with errors if any
-   */
-  static validateConceptValue(conceptType, value, datatypes) {
-    const errors = [];
-    if (value === null || value === void 0 || value === "") {
-      return { valid: true, errors: [] };
-    }
-    if (!conceptType || !datatypes || datatypes.length === 0) {
-      return { valid: true, errors: [] };
-    }
-    const datatype = this.findDatatype(conceptType, datatypes);
-    if (!datatype || !datatype.validation) {
-      return { valid: true, errors: [] };
-    }
-    const validation2 = datatype.validation;
-    const stringValue = String(value);
-    if (validation2.pattern) {
-      const patternError = this.validatePattern(stringValue, validation2.pattern);
-      if (patternError) {
-        errors.push(patternError);
-      }
-    }
-    if (validation2.length !== void 0) {
-      const lengthError = this.validateExactLength(stringValue, validation2.length);
-      if (lengthError) {
-        errors.push(lengthError);
-      }
-    }
-    if (validation2.minLength !== void 0) {
-      const minLengthError = this.validateMinLength(stringValue, validation2.minLength);
-      if (minLengthError) {
-        errors.push(minLengthError);
-      }
-    }
-    if (validation2.maxLength !== void 0) {
-      const maxLengthError = this.validateMaxLength(stringValue, validation2.maxLength);
-      if (maxLengthError) {
-        errors.push(maxLengthError);
-      }
-    }
-    if (validation2.totalDigits !== void 0) {
-      const totalDigitsError = this.validateTotalDigits(stringValue, validation2.totalDigits);
-      if (totalDigitsError) {
-        errors.push(totalDigitsError);
-      }
-    }
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  /**
-   * Finds the datatype definition for a given concept type
-   * Handles both exact matches and base type chain resolution
-   */
-  static findDatatype(conceptType, datatypes) {
-    let datatype = datatypes.find((dt) => dt.type === conceptType);
-    if (datatype) {
-      return datatype;
-    }
-    const visited = /* @__PURE__ */ new Set();
-    let currentType = conceptType;
-    while (currentType && !visited.has(currentType)) {
-      visited.add(currentType);
-      datatype = datatypes.find((dt) => dt.type === currentType);
-      if (datatype) {
-        if (datatype.validation) {
-          return datatype;
-        }
-        currentType = datatype.basetype;
-      } else {
-        break;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Validates that value matches the regex pattern
-   */
-  static validatePattern(value, pattern) {
-    try {
-      const regex = new RegExp(`^${pattern}$`);
-      if (!regex.test(value)) {
-        return {
-          type: "pattern",
-          message: I18n.t("xbrlValidation.patternMismatch", { pattern }),
-          expectedValue: pattern,
-          actualValue: value
-        };
-      }
-    } catch (error2) {
-      console.error(`Invalid regex pattern: ${pattern}`, error2);
-      return {
-        type: "pattern",
-        message: I18n.t("xbrlValidation.invalidPattern", { pattern }),
-        expectedValue: pattern,
-        actualValue: value
-      };
-    }
-    return null;
-  }
-  /**
-   * Validates that value has exact length
-   */
-  static validateExactLength(value, requiredLength) {
-    if (value.length !== requiredLength) {
-      return {
-        type: "length",
-        message: I18n.t("xbrlValidation.exactLength", { required: requiredLength, current: value.length }),
-        expectedValue: requiredLength,
-        actualValue: value.length
-      };
-    }
-    return null;
-  }
-  /**
-   * Validates minimum length
-   */
-  static validateMinLength(value, minLength) {
-    if (value.length < minLength) {
-      return {
-        type: "minLength",
-        message: I18n.t("xbrlValidation.minLength", { required: minLength, current: value.length }),
-        expectedValue: minLength,
-        actualValue: value.length
-      };
-    }
-    return null;
-  }
-  /**
-   * Validates maximum length
-   */
-  static validateMaxLength(value, maxLength) {
-    if (value.length > maxLength) {
-      return {
-        type: "maxLength",
-        message: I18n.t("xbrlValidation.maxLength", { required: maxLength, current: value.length }),
-        expectedValue: maxLength,
-        actualValue: value.length
-      };
-    }
-    return null;
-  }
-  /**
-   * Validates total digits (for numeric values)
-   */
-  static validateTotalDigits(value, totalDigits) {
-    const digitsOnly = value.replace(/[^\d]/g, "");
-    if (digitsOnly.length > totalDigits) {
-      return {
-        type: "totalDigits",
-        message: I18n.t("xbrlValidation.totalDigits", { required: totalDigits, current: digitsOnly.length }),
-        expectedValue: totalDigits,
-        actualValue: digitsOnly.length
-      };
-    }
-    return null;
-  }
-  /**
-   * Gets a human-readable summary of validation rules for a concept type
-   * Useful for displaying validation hints to users
-   */
-  static getValidationRulesSummary(conceptType, datatypes) {
-    if (!conceptType || !datatypes) {
-      return [];
-    }
-    const datatype = this.findDatatype(conceptType, datatypes);
-    if (!datatype || !datatype.validation) {
-      return [];
-    }
-    const validation2 = datatype.validation;
-    const rules = [];
-    if (validation2.pattern) {
-      rules.push(I18n.t("xbrlValidation.ruleSummaryPattern", { pattern: validation2.pattern }));
-    }
-    if (validation2.length !== void 0) {
-      rules.push(I18n.t("xbrlValidation.ruleSummaryExactLength", { required: validation2.length }));
-    }
-    if (validation2.minLength !== void 0) {
-      rules.push(I18n.t("xbrlValidation.ruleSummaryMinLength", { required: validation2.minLength }));
-    }
-    if (validation2.maxLength !== void 0) {
-      rules.push(I18n.t("xbrlValidation.ruleSummaryMaxLength", { required: validation2.maxLength }));
-    }
-    if (validation2.totalDigits !== void 0) {
-      rules.push(I18n.t("xbrlValidation.ruleSummaryTotalDigits", { required: validation2.totalDigits }));
-    }
-    return rules;
-  }
-}
 const TYPE_INPUT_MAP = {
   // ==========================================
   // Dutch XBRL Types (nl-types namespace)
@@ -3826,14 +3923,21 @@ const TYPE_INPUT_MAP = {
     htmlInputType: "text",
     placeholder: I18n.t("field.enterText")
   },
-  // Date types
+  // Date types — bounded to a sane 1900-2100 range. Browsers don't stop you from *typing* a
+  // year outside this (see MDN: min/max restrict the calendar picker and validity state, not
+  // keystrokes), but it does keep the calendar picker itself sane and correctly flags an
+  // out-of-range typed value as :invalid without us clearing/rejecting anything ourselves.
   "xbrli:dateItemType": {
     fieldType: "date",
-    htmlInputType: "date"
+    htmlInputType: "date",
+    min: "1900-01-01",
+    max: "2100-12-31"
   },
   "xbrli:dateTimeItemType": {
     fieldType: "datetime",
-    htmlInputType: "datetime-local"
+    htmlInputType: "datetime-local",
+    min: "1900-01-01T00:00",
+    max: "2100-12-31T23:59"
   },
   // Numeric types - integers
   "xbrli:integerItemType": {
@@ -3993,12 +4097,16 @@ function getInputTypeForConceptType(conceptType, datatypes) {
     if (lowerType.includes("time")) {
       return {
         fieldType: "datetime",
-        htmlInputType: "datetime-local"
+        htmlInputType: "datetime-local",
+        min: "1900-01-01T00:00",
+        max: "2100-12-31T23:59"
       };
     }
     return {
       fieldType: "date",
-      htmlInputType: "date"
+      htmlInputType: "date",
+      min: "1900-01-01",
+      max: "2100-12-31"
     };
   }
   if (lowerType.includes("boolean") || lowerType.includes("bool")) {
@@ -4131,12 +4239,16 @@ function determineInputTypeFromBaseChain(baseTypeChain, datatypes) {
     if (chainString.includes("datetime") || chainString.includes("time")) {
       return {
         fieldType: "datetime",
-        htmlInputType: "datetime-local"
+        htmlInputType: "datetime-local",
+        min: "1900-01-01T00:00",
+        max: "2100-12-31T23:59"
       };
     }
     return {
       fieldType: "date",
-      htmlInputType: "date"
+      htmlInputType: "date",
+      min: "1900-01-01",
+      max: "2100-12-31"
     };
   }
   if (chainLower.some((type) => type.includes("boolean") || type.includes("bool"))) {
@@ -4167,48 +4279,262 @@ function determineInputTypeFromBaseChain(baseTypeChain, datatypes) {
       placeholder: I18n.t("field.enterPercentage")
     };
   }
-  if (chainLower.some((type) => type.includes("decimal") || type === "decimal")) {
-    if (chainString.includes("monetary") || chainString.includes("currency")) {
-      if (chainString.includes("nodecimals") || chainString.includes("no-decimals") || chainString.includes("nodecimals20")) {
-        return {
-          fieldType: "number",
-          htmlInputType: "text",
-          inputMode: "decimal",
-          allowDecimals: false,
-          step: 1,
-          placeholder: I18n.t("field.enterAmountNoDecimals")
-        };
-      }
+  if (chainLower.some((type) => type.includes("decimal") || type === "decimal")) {
+    if (chainString.includes("monetary") || chainString.includes("currency")) {
+      if (chainString.includes("nodecimals") || chainString.includes("no-decimals") || chainString.includes("nodecimals20")) {
+        return {
+          fieldType: "number",
+          htmlInputType: "text",
+          inputMode: "decimal",
+          allowDecimals: false,
+          step: 1,
+          placeholder: I18n.t("field.enterAmountNoDecimals")
+        };
+      }
+      return {
+        fieldType: "currency",
+        htmlInputType: "text",
+        inputMode: "decimal",
+        allowDecimals: true,
+        step: 0.01,
+        placeholder: I18n.t("field.enterCurrency")
+      };
+    }
+    return {
+      fieldType: "decimal",
+      htmlInputType: "text",
+      inputMode: "decimal",
+      allowDecimals: true,
+      step: "any",
+      placeholder: I18n.t("field.enterDecimalValue")
+    };
+  }
+  if (baseTypeChain.some((type) => type === "xbrli:stringItemType") || chainLower.some((type) => type === "string" || type.includes("stringitem"))) {
+    return {
+      fieldType: "text",
+      htmlInputType: "text",
+      placeholder: I18n.t("field.enterText")
+    };
+  }
+  return {
+    fieldType: "text",
+    htmlInputType: "text",
+    placeholder: I18n.t("field.enterValue")
+  };
+}
+class XBRLValidator {
+  /**
+   * Validates a value against XBRL datatype validation rules
+   * Only validates when value is not blank
+   * 
+   * @param conceptType - The XBRL concept type (e.g., "nl-types:houseNumberNLItemType")
+   * @param value - The input value to validate
+   * @param datatypes - Array of XBRL datatypes from taxonomy
+   * @returns Validation result with errors if any
+   */
+  static validateConceptValue(conceptType, value, datatypes) {
+    if (value === null || value === void 0 || value === "") {
+      return { valid: true, errors: [] };
+    }
+    if (!conceptType || !datatypes || datatypes.length === 0) {
+      return { valid: true, errors: [] };
+    }
+    const datatype = this.findDatatype(conceptType, datatypes);
+    if (!datatype || !datatype.validation) {
+      return { valid: true, errors: [] };
+    }
+    return this.validateAgainstRules(value, datatype.validation);
+  }
+  /**
+   * Validates a value against an already-resolved validation rule set, skipping the
+   * type-name → datatypes.json lookup `validateConceptValue` does. Use this when the caller
+   * already has the applicable rules in hand — e.g. an XBRL typed-dimension member's own
+   * `validation` block, embedded directly on the hypercube JSON's `typedMember` (a separate
+   * source from, and not necessarily mirrored in, datatypes.json — many typed-member types
+   * such as "nl-types:string255" never appear there at all).
+   */
+  static validateAgainstRules(value, validation2) {
+    const errors = [];
+    if (value === null || value === void 0 || value === "") {
+      return { valid: true, errors: [] };
+    }
+    if (!validation2) {
+      return { valid: true, errors: [] };
+    }
+    const stringValue = String(value);
+    if (validation2.pattern) {
+      const patternError = this.validatePattern(stringValue, validation2.pattern);
+      if (patternError) {
+        errors.push(patternError);
+      }
+    }
+    if (validation2.length !== void 0) {
+      const lengthError = this.validateExactLength(stringValue, validation2.length);
+      if (lengthError) {
+        errors.push(lengthError);
+      }
+    }
+    if (validation2.minLength !== void 0) {
+      const minLengthError = this.validateMinLength(stringValue, validation2.minLength);
+      if (minLengthError) {
+        errors.push(minLengthError);
+      }
+    }
+    if (validation2.maxLength !== void 0) {
+      const maxLengthError = this.validateMaxLength(stringValue, validation2.maxLength);
+      if (maxLengthError) {
+        errors.push(maxLengthError);
+      }
+    }
+    if (validation2.totalDigits !== void 0) {
+      const totalDigitsError = this.validateTotalDigits(stringValue, validation2.totalDigits);
+      if (totalDigitsError) {
+        errors.push(totalDigitsError);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Finds the datatype definition for a given concept type
+   * Handles both exact matches and base type chain resolution
+   */
+  static findDatatype(conceptType, datatypes) {
+    let datatype = datatypes.find((dt) => dt.type === conceptType);
+    if (datatype) {
+      return datatype;
+    }
+    const visited = /* @__PURE__ */ new Set();
+    let currentType = conceptType;
+    while (currentType && !visited.has(currentType)) {
+      visited.add(currentType);
+      datatype = datatypes.find((dt) => dt.type === currentType);
+      if (datatype) {
+        if (datatype.validation) {
+          return datatype;
+        }
+        currentType = datatype.basetype;
+      } else {
+        break;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Validates that value matches the regex pattern
+   */
+  static validatePattern(value, pattern) {
+    try {
+      const regex = new RegExp(`^${pattern}$`);
+      if (!regex.test(value)) {
+        return {
+          type: "pattern",
+          message: I18n.t("xbrlValidation.patternMismatch", { pattern }),
+          expectedValue: pattern,
+          actualValue: value
+        };
+      }
+    } catch (error2) {
+      console.error(`Invalid regex pattern: ${pattern}`, error2);
+      return {
+        type: "pattern",
+        message: I18n.t("xbrlValidation.invalidPattern", { pattern }),
+        expectedValue: pattern,
+        actualValue: value
+      };
+    }
+    return null;
+  }
+  /**
+   * Validates that value has exact length
+   */
+  static validateExactLength(value, requiredLength) {
+    if (value.length !== requiredLength) {
+      return {
+        type: "length",
+        message: I18n.t("xbrlValidation.exactLength", { required: requiredLength, current: value.length }),
+        expectedValue: requiredLength,
+        actualValue: value.length
+      };
+    }
+    return null;
+  }
+  /**
+   * Validates minimum length
+   */
+  static validateMinLength(value, minLength) {
+    if (value.length < minLength) {
+      return {
+        type: "minLength",
+        message: I18n.t("xbrlValidation.minLength", { required: minLength, current: value.length }),
+        expectedValue: minLength,
+        actualValue: value.length
+      };
+    }
+    return null;
+  }
+  /**
+   * Validates maximum length
+   */
+  static validateMaxLength(value, maxLength) {
+    if (value.length > maxLength) {
       return {
-        fieldType: "currency",
-        htmlInputType: "text",
-        inputMode: "decimal",
-        allowDecimals: true,
-        step: 0.01,
-        placeholder: I18n.t("field.enterCurrency")
+        type: "maxLength",
+        message: I18n.t("xbrlValidation.maxLength", { required: maxLength, current: value.length }),
+        expectedValue: maxLength,
+        actualValue: value.length
       };
     }
-    return {
-      fieldType: "decimal",
-      htmlInputType: "text",
-      inputMode: "decimal",
-      allowDecimals: true,
-      step: "any",
-      placeholder: I18n.t("field.enterDecimalValue")
-    };
+    return null;
   }
-  if (baseTypeChain.some((type) => type === "xbrli:stringItemType") || chainLower.some((type) => type === "string" || type.includes("stringitem"))) {
-    return {
-      fieldType: "text",
-      htmlInputType: "text",
-      placeholder: I18n.t("field.enterText")
-    };
+  /**
+   * Validates total digits (for numeric values)
+   */
+  static validateTotalDigits(value, totalDigits) {
+    const digitsOnly = value.replace(/[^\d]/g, "");
+    if (digitsOnly.length > totalDigits) {
+      return {
+        type: "totalDigits",
+        message: I18n.t("xbrlValidation.totalDigits", { required: totalDigits, current: digitsOnly.length }),
+        expectedValue: totalDigits,
+        actualValue: digitsOnly.length
+      };
+    }
+    return null;
+  }
+  /**
+   * Gets a human-readable summary of validation rules for a concept type
+   * Useful for displaying validation hints to users
+   */
+  static getValidationRulesSummary(conceptType, datatypes) {
+    if (!conceptType || !datatypes) {
+      return [];
+    }
+    const datatype = this.findDatatype(conceptType, datatypes);
+    if (!datatype || !datatype.validation) {
+      return [];
+    }
+    const validation2 = datatype.validation;
+    const rules = [];
+    if (validation2.pattern) {
+      rules.push(I18n.t("xbrlValidation.ruleSummaryPattern", { pattern: validation2.pattern }));
+    }
+    if (validation2.length !== void 0) {
+      rules.push(I18n.t("xbrlValidation.ruleSummaryExactLength", { required: validation2.length }));
+    }
+    if (validation2.minLength !== void 0) {
+      rules.push(I18n.t("xbrlValidation.ruleSummaryMinLength", { required: validation2.minLength }));
+    }
+    if (validation2.maxLength !== void 0) {
+      rules.push(I18n.t("xbrlValidation.ruleSummaryMaxLength", { required: validation2.maxLength }));
+    }
+    if (validation2.totalDigits !== void 0) {
+      rules.push(I18n.t("xbrlValidation.ruleSummaryTotalDigits", { required: validation2.totalDigits }));
+    }
+    return rules;
   }
-  return {
-    fieldType: "text",
-    htmlInputType: "text",
-    placeholder: I18n.t("field.enterValue")
-  };
 }
 var __defProp$7 = Object.defineProperty;
 var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
@@ -4290,6 +4616,14 @@ let JupiterFormField = class extends LitElement {
   }
   _handleInput(event) {
     const target = event.target;
+    const isDateType = target instanceof HTMLInputElement && (target.type === "date" || target.type === "datetime-local");
+    if (isDateType) {
+      if (event.type !== "change") {
+        return;
+      }
+    } else if (target.tagName === "INPUT" && target.type !== "checkbox" && event.type === "change") {
+      return;
+    }
     const oldValue = this.value;
     let value = target.value;
     if (this._isNumericField()) {
@@ -4427,7 +4761,7 @@ let JupiterFormField = class extends LitElement {
       return;
     }
     const typeConfig = getInputTypeForConceptType(this.conceptType, this.datatypes);
-    const allowNegative = typeConfig.min === void 0 || typeConfig.min < 0;
+    const allowNegative = typeConfig.min === void 0 || typeof typeConfig.min === "number" && typeConfig.min < 0;
     if (event.key === "-" && allowNegative && !target.value.includes("-") && (target.selectionStart === 0 || target.value.length === 0)) {
       return;
     }
@@ -4921,6 +5255,33 @@ let JupiterFormField = class extends LitElement {
     } else {
       renderedInputValue = effectiveValue ?? "";
     }
+    if (inputType === "date" || inputType === "datetime-local") {
+      return html`
+        <div class="date-wrapper">
+          <input
+            id="${fieldId}"
+            name="${fieldName}"
+            type="${inputType}"
+            inputmode="${typeConfig.inputMode || ""}"
+            class="${cssClass}"
+            .value="${renderedInputValue}"
+            ?disabled="${effectiveDisabled || this.field.disabled}"
+            placeholder="${typeConfig.placeholder || this.field.placeholder || ""}"
+            min="${min !== void 0 ? min : ""}"
+            max="${max !== void 0 ? max : ""}"
+            @input="${this._handleInput}"
+            @change="${this._handleInput}"
+            @focus="${this._handleFocus}"
+            @blur="${this._handleBlur}"
+          />
+          <svg class="calendar-icon-svg" viewBox="0 0 24 24">
+            <path fill="currentColor" d="M19 4h-1V2h-2v2H8V2H6v2H5
+                  a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14
+                  a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2zm0 16H5V9h14z"/>
+          </svg>
+        </div>
+      `;
+    }
     return html`
       <input
         id="${fieldId}"
@@ -4935,6 +5296,7 @@ let JupiterFormField = class extends LitElement {
         min="${min !== void 0 ? min : ""}"
         max="${max !== void 0 ? max : ""}"
         @input="${this._handleInput}"
+        @change="${this._handleInput}"
         @focus="${this._handleFocus}"
         @blur="${this._handleBlur}"
         @keydown="${this._handleKeyDown}"
@@ -4987,6 +5349,8 @@ let JupiterFormField = class extends LitElement {
           <div class="date-wrapper">
             <input
               type="date"
+              min="1900-01-01"
+              max="2100-12-31"
               .value="${this.periodInstantDate || this.field.periodInstantDate || ""}"
               @change="${(e2) => this._handlePeriodChange(e2, "instant")}"
               ?disabled="${this.disabled}"
@@ -5006,6 +5370,8 @@ let JupiterFormField = class extends LitElement {
           <div class="date-wrapper">
             <input
               type="date"
+              min="1900-01-01"
+              max="2100-12-31"
               .value="${this.periodStartDate || this.field.periodStartDate || ""}"
               @change="${(e2) => this._handlePeriodChange(e2, "start")}"
               ?disabled="${this.disabled}"
@@ -5020,6 +5386,8 @@ let JupiterFormField = class extends LitElement {
           <div class="date-wrapper">
             <input
               type="date"
+              min="1900-01-01"
+              max="2100-12-31"
               .value="${this.periodEndDate || this.field.periodEndDate || ""}"
               @change="${(e2) => this._handlePeriodChange(e2, "end")}"
               ?disabled="${this.disabled}"
@@ -5053,6 +5421,8 @@ let JupiterFormField = class extends LitElement {
                 <div class="date-wrapper">
                   <input
                     type="date"
+                    min="1900-01-01"
+                    max="2100-12-31"
                     .value="${this.periodInstantDate || this.field.periodInstantDate || ""}"
                     @change="${(e2) => this._handlePeriodChange(e2, "instant")}"
                     ?disabled="${this.disabled}"
@@ -5070,6 +5440,8 @@ let JupiterFormField = class extends LitElement {
                 <div class="date-wrapper">
                   <input
                     type="date"
+                    min="1900-01-01"
+                    max="2100-12-31"
                     .value="${this.periodStartDate || this.field.periodStartDate || ""}"
                     @change="${(e2) => this._handlePeriodChange(e2, "start")}"
                     ?disabled="${this.disabled}"
@@ -5088,6 +5460,8 @@ let JupiterFormField = class extends LitElement {
                 <div class="date-wrapper">
                   <input
                     type="date"
+                    min="1900-01-01"
+                    max="2100-12-31"
                     .value="${this.periodEndDate || this.field.periodEndDate || ""}"
                     @change="${(e2) => this._handlePeriodChange(e2, "end")}"
                     ?disabled="${this.disabled}"
@@ -5318,6 +5692,11 @@ JupiterFormField.styles = css`
       border-radius: 4px;
       transition: background-color 0.2s;
       opacity: 0.7;
+      /* Keep this icon on the wrapper's right edge (same rail as every other field type)
+         regardless of the sibling input's own width — the date-wrapper next to it sizes to
+         its dd/mm/yyyy content, which is narrower than a full-width text/select input. */
+      margin-left: auto;
+      flex-shrink: 0;
     }
 
     .period-icon-btn:hover {
@@ -6580,6 +6959,7 @@ let JupiterAddColumnDialog = class extends LitElement {
     this._instantDate = "";
     this._selectedType = "duration";
     this._selectedDimensions = /* @__PURE__ */ new Map();
+    this._typedValueErrors = {};
   }
   updated(changedProperties) {
     if (changedProperties.has("open") && this.open) {
@@ -6643,6 +7023,7 @@ let JupiterAddColumnDialog = class extends LitElement {
     this._instantDate = e2.target.value;
   }
   _handleDimensionToggle(dimensionId, event) {
+    var _a, _b;
     const checkbox = event.target;
     if (checkbox.checked) {
       const dimension = this.availableDimensions.find((d2) => d2.id === dimensionId);
@@ -6650,7 +7031,9 @@ let JupiterAddColumnDialog = class extends LitElement {
         const selection = {
           axisId: dimension.id,
           axisLabel: dimension.axisLabel,
-          isTyped: !!(dimension.typedMember && (!dimension.members || dimension.members.length === 0))
+          isTyped: !!(dimension.typedMember && (!dimension.members || dimension.members.length === 0)),
+          dataType: (_a = dimension.typedMember) == null ? void 0 : _a.dataType,
+          validation: (_b = dimension.typedMember) == null ? void 0 : _b.validation
         };
         this._selectedDimensions.set(dimensionId, selection);
       }
@@ -6669,24 +7052,130 @@ let JupiterAddColumnDialog = class extends LitElement {
     }
   }
   _handleTypedValueChange(dimensionId, event) {
-    const input = event.target;
+    const target = event.target;
+    const value = target instanceof HTMLInputElement && target.type === "checkbox" ? String(target.checked) : target.value;
     const existing = this._selectedDimensions.get(dimensionId);
     if (existing) {
-      existing.typedValue = input.value;
+      existing.typedValue = value;
       this._selectedDimensions.set(dimensionId, existing);
     }
   }
+  /**
+   * Validate a typed dimension's value against its XBRL datatype's `validation` constraints
+   * (minLength/maxLength/length/pattern/totalDigits), reusing the exact same datatype-driven
+   * validator concept row fields use on blur (`XBRLValidator.validateConceptValue` — see
+   * `form-field.ts`'s `_validateXBRLDatatype` / `form-section.ts`'s `_validateTypedMemberValue`).
+   */
+  _validateTypedValue(dimensionId, dataType, validation2, value) {
+    const hasExistingEntry = dimensionId in this._typedValueErrors;
+    if (!value) {
+      if (hasExistingEntry) {
+        const updated = { ...this._typedValueErrors };
+        delete updated[dimensionId];
+        this._typedValueErrors = updated;
+      }
+      return;
+    }
+    const result = validation2 ? XBRLValidator.validateAgainstRules(value, validation2) : XBRLValidator.validateConceptValue(dataType, value, this.datatypes);
+    if (result.valid) {
+      if (hasExistingEntry) {
+        const updated = { ...this._typedValueErrors };
+        delete updated[dimensionId];
+        this._typedValueErrors = updated;
+      }
+    } else {
+      this._typedValueErrors = { ...this._typedValueErrors, [dimensionId]: result.errors };
+    }
+  }
+  _handleTypedValueBlur(dimensionId, dataType, validation2, event) {
+    const target = event.target;
+    const value = target instanceof HTMLInputElement && target.type === "checkbox" ? String(target.checked) : target.value;
+    this._validateTypedValue(dimensionId, dataType, validation2, value);
+  }
+  /** Renders the `field-errors`-style message list for a typed dimension's value input, if any. */
+  _renderTypedValueErrors(dimensionId) {
+    const errors = this._typedValueErrors[dimensionId];
+    if (!errors || errors.length === 0)
+      return "";
+    return html`
+      <div class="typed-input-errors">
+        ${errors.map((error2) => html`<span class="typed-input-error">${error2.message}</span>`)}
+      </div>
+    `;
+  }
+  /**
+   * Resolve the input-type configuration for a typed dimension's value input, reusing the same
+   * XBRL type → HTML input mapping that drives concept row fields and the column-header typed-
+   * member input (see `getInputTypeForConceptType` / `form-field.ts`'s `_renderInput` /
+   * `form-section.ts`'s `_renderTypedMemberHeaderInput`).
+   */
+  _getTypedValueInputConfig(dataType) {
+    return getInputTypeForConceptType(dataType, this.datatypes);
+  }
+  /**
+   * Render the typed dimension's value input, choosing select/checkbox/date/generic text-like
+   * input based on the typed member's XBRL datatype instead of always rendering plain text.
+   */
+  _renderTypedValueInput(dimensionId, dataType, validation2, currentValue) {
+    var _a;
+    const typeConfig = this._getTypedValueInputConfig(dataType);
+    const hasValidationError = !!((_a = this._typedValueErrors[dimensionId]) == null ? void 0 : _a.length);
+    const inputClass = `typed-input ${hasValidationError ? "has-error" : ""}`;
+    const onChange = (e2) => this._handleTypedValueChange(dimensionId, e2);
+    const onBlur = (e2) => this._handleTypedValueBlur(dimensionId, dataType, validation2, e2);
+    if (typeConfig.fieldType === "select" || isSelectType(typeConfig.fieldType)) {
+      const options = typeConfig.enumerations || [];
+      return html`
+        <select class="${inputClass}" .value="${currentValue}" @change="${onChange}" @blur="${onBlur}">
+          <option value="">${typeConfig.placeholder || I18n.t("field.select")}</option>
+          ${options.map((option) => html`
+            <option value="${option.value}" ?selected="${currentValue === option.value}">
+              ${option.label || option.value}
+            </option>
+          `)}
+        </select>
+      `;
+    }
+    if (typeConfig.fieldType === "boolean" || isCheckboxType(typeConfig.fieldType)) {
+      return html`
+        <input
+          type="checkbox"
+          class="${inputClass}"
+          .checked="${currentValue === "true"}"
+          @change="${onChange}"
+          @blur="${onBlur}"
+        />
+      `;
+    }
+    const inputType = typeConfig.htmlInputType || "text";
+    return html`
+      <input
+        type="${inputType}"
+        inputmode="${typeConfig.inputMode || ""}"
+        class="${inputClass}"
+        .value="${currentValue}"
+        min="${typeConfig.min !== void 0 ? typeConfig.min : ""}"
+        max="${typeConfig.max !== void 0 ? typeConfig.max : ""}"
+        step="${typeConfig.step !== void 0 ? typeConfig.step : ""}"
+        @input="${onChange}"
+        @blur="${onBlur}"
+        placeholder="${typeConfig.placeholder || I18n.t("column.enterValuePlaceholder")}"
+      />
+    `;
+  }
   _resetForm() {
     this._startDate = this.periodStartDate || "";
     this._endDate = this.periodEndDate || "";
     this._instantDate = this.periodEndDate || this.periodStartDate || "";
     this._selectedType = this.periodType === "instant" ? "instant" : "duration";
     this._selectedDimensions.clear();
+    this._typedValueErrors = {};
     this._autoSelectSingleMemberDimensions();
     this.requestUpdate();
   }
   _autoSelectSingleMemberDimensions() {
     this.availableDimensions.forEach((dimension) => {
+      var _a, _b;
       if (dimension.members && dimension.members.length > 0) {
         const member = dimension.members[0];
         const selection = {
@@ -6702,7 +7191,9 @@ let JupiterAddColumnDialog = class extends LitElement {
         const selection = {
           axisId: dimension.id,
           axisLabel: dimension.axisLabel,
-          isTyped: true
+          isTyped: true,
+          dataType: (_a = dimension.typedMember) == null ? void 0 : _a.dataType,
+          validation: (_b = dimension.typedMember) == null ? void 0 : _b.validation
           // Note: typedValue will be entered in column header, not here
         };
         this._selectedDimensions.set(dimension.id, selection);
@@ -6728,6 +7219,8 @@ let JupiterAddColumnDialog = class extends LitElement {
               <div class="date-wrapper">
                 <input 
                   type="date" 
+                  min="1900-01-01"
+                  max="2100-12-31"
                   class="form-input"
                   .value="${this._instantDate}"
                   @change="${this._handleInstantDateChange}"
@@ -6747,6 +7240,8 @@ let JupiterAddColumnDialog = class extends LitElement {
                 <div class="date-wrapper">
                   <input 
                     type="date" 
+                    min="1900-01-01"
+                    max="2100-12-31"
                     class="form-input"
                     .value="${this._startDate}"
                     @change="${this._handleStartDateChange}"
@@ -6764,6 +7259,8 @@ let JupiterAddColumnDialog = class extends LitElement {
                 <div class="date-wrapper">
                   <input 
                     type="date" 
+                    min="1900-01-01"
+                    max="2100-12-31"
                     class="form-input"
                     .value="${this._endDate}"
                     @change="${this._handleEndDateChange}"
@@ -6786,6 +7283,7 @@ let JupiterAddColumnDialog = class extends LitElement {
               <p class="form-description">${I18n.t("column.dimensionsDescription")}</p>
               
               ${this.availableDimensions.map((dimension) => {
+      var _a, _b;
       const isSelected = this._selectedDimensions.has(dimension.id);
       const selection = this._selectedDimensions.get(dimension.id);
       const isTypedDimension = !!(dimension.typedMember && (!dimension.members || dimension.members.length === 0));
@@ -6810,13 +7308,8 @@ let JupiterAddColumnDialog = class extends LitElement {
                           <!-- Typed Dimension Input -->
                           <div class="member-selection">
                             <label>${I18n.t("column.enterValue")} ${dimension.conceptName}:</label>
-                            <input
-                              type="text"
-                              class="typed-input"
-                              .value="${(selection == null ? void 0 : selection.typedValue) || ""}"
-                              @input="${(e2) => this._handleTypedValueChange(dimension.id, e2)}"
-                              placeholder="${I18n.t("column.enterValuePlaceholder")}"
-                            />
+                            ${this._renderTypedValueInput(dimension.id, (_a = dimension.typedMember) == null ? void 0 : _a.dataType, (_b = dimension.typedMember) == null ? void 0 : _b.validation, (selection == null ? void 0 : selection.typedValue) || "")}
+                            ${this._renderTypedValueErrors(dimension.id)}
                           </div>
                         ` : html`
                           <!-- Domain Members Selection -->
@@ -7133,6 +7626,20 @@ JupiterAddColumnDialog.styles = css`
       font-size: 14px;
     }
 
+    .typed-input.has-error {
+      border-color: var(--jupiter-error-color, #d32f2f);
+    }
+
+    .typed-input-errors {
+      margin-top: 4px;
+    }
+
+    .typed-input-error {
+      display: block;
+      font-size: 12px;
+      color: var(--jupiter-error-color, #d32f2f);
+    }
+
     .member-list {
       max-height: 120px;
       overflow-y: auto;
@@ -7188,6 +7695,9 @@ __decorateClass$5([
 __decorateClass$5([
   n2({ type: String })
 ], JupiterAddColumnDialog.prototype, "periodEndDate", 2);
+__decorateClass$5([
+  n2({ type: Array })
+], JupiterAddColumnDialog.prototype, "datatypes", 2);
 __decorateClass$5([
   r()
 ], JupiterAddColumnDialog.prototype, "_startDate", 2);
@@ -7203,6 +7713,9 @@ __decorateClass$5([
 __decorateClass$5([
   r()
 ], JupiterAddColumnDialog.prototype, "_selectedDimensions", 2);
+__decorateClass$5([
+  r()
+], JupiterAddColumnDialog.prototype, "_typedValueErrors", 2);
 JupiterAddColumnDialog = __decorateClass$5([
   t$1("jupiter-add-column-dialog")
 ], JupiterAddColumnDialog);
@@ -7247,6 +7760,7 @@ let JupiterFormSection = class extends LitElement {
     this._sectionPeriodType = "duration";
     this._openMenuColumnId = null;
     this._insertAfterColumnId = null;
+    this._typedMemberErrors = {};
     this._boundFieldBlur = (e2) => {
       this._clearHighlights();
       this._focusedConceptId = null;
@@ -7868,9 +8382,72 @@ let JupiterFormSection = class extends LitElement {
     var _a;
     return ((_a = this.typedMemberData[columnId]) == null ? void 0 : _a[axisId]) || "";
   }
+  /** True once any concept in this section has a non-empty value entered for the given column. */
+  _columnHasAnyValue(columnId) {
+    return Object.keys(this.formData).some((conceptId) => {
+      var _a;
+      const value = (_a = this.formData[conceptId]) == null ? void 0 : _a[columnId];
+      return value !== void 0 && value !== null && value !== "";
+    });
+  }
+  /**
+   * Resolve the input-type configuration for a typed dimension's column-header input,
+   * reusing the same XBRL type → HTML input mapping that drives concept row fields
+   * (see `getInputTypeForConceptType` / `form-field.ts`'s `_renderInput`).
+   */
+  _getTypedMemberInputConfig(typedMember) {
+    return getInputTypeForConceptType(typedMember.type, this.datatypes);
+  }
+  _typedMemberErrorKey(columnId, axisId) {
+    return `${columnId}::${axisId}`;
+  }
+  /**
+   * Validate a typed-member header value against its XBRL datatype's `validation` constraints
+   * (minLength/maxLength/length/pattern/totalDigits), reusing the exact same datatype-driven
+   * validator concept row fields use on blur (`XBRLValidator.validateConceptValue` — see
+   * `form-field.ts`'s `_validateXBRLDatatype`). Stores/clears the result in `_typedMemberErrors`.
+   */
+  _validateTypedMemberValue(columnId, typedMember, value) {
+    const key = this._typedMemberErrorKey(columnId, typedMember.axisId);
+    const hasExistingEntry = key in this._typedMemberErrors;
+    if (!value) {
+      if (hasExistingEntry) {
+        const updated = { ...this._typedMemberErrors };
+        delete updated[key];
+        this._typedMemberErrors = updated;
+      }
+      return;
+    }
+    const result = typedMember.validation ? XBRLValidator.validateAgainstRules(value, typedMember.validation) : XBRLValidator.validateConceptValue(typedMember.type, value, this.datatypes);
+    if (result.valid) {
+      if (hasExistingEntry) {
+        const updated = { ...this._typedMemberErrors };
+        delete updated[key];
+        this._typedMemberErrors = updated;
+      }
+    } else {
+      this._typedMemberErrors = { ...this._typedMemberErrors, [key]: result.errors };
+    }
+  }
+  _handleTypedMemberHeaderBlur(event, columnId, typedMember) {
+    const target = event.target;
+    const value = target instanceof HTMLInputElement && target.type === "checkbox" ? String(target.checked) : target.value;
+    this._validateTypedMemberValue(columnId, typedMember, value);
+  }
+  /** Renders the `field-errors`-style message list for a typed-member header input, if any. */
+  _renderTypedMemberHeaderErrors(columnId, axisId) {
+    const errors = this._typedMemberErrors[this._typedMemberErrorKey(columnId, axisId)];
+    if (!errors || errors.length === 0)
+      return "";
+    return html`
+      <div class="typed-member-header-errors">
+        ${errors.map((error2) => html`<span class="typed-member-header-error">${error2.message}</span>`)}
+      </div>
+    `;
+  }
   _handleTypedMemberHeaderChange(event, columnId, axisId) {
     const target = event.target;
-    const value = target.value;
+    const value = target instanceof HTMLInputElement && target.type === "checkbox" ? String(target.checked) : target.value;
     console.log(`🔍 [FormSection] Typed member header change: columnId=${columnId}, axisId=${axisId}, value=${value}`);
     this.dispatchEvent(new CustomEvent("typed-member-change", {
       detail: {
@@ -7881,6 +8458,69 @@ let JupiterFormSection = class extends LitElement {
       bubbles: true
     }));
   }
+  /**
+   * Render the typed-member column-header input element, choosing select/checkbox/date/generic
+   * text-like input based on the typed member's XBRL datatype — mirrors the branching in
+   * `form-field.ts`'s `_renderInput`, adapted for the compact header cell.
+   */
+  _renderTypedMemberHeaderInput(columnId, typedMember, isRequired) {
+    var _a;
+    const typeConfig = this._getTypedMemberInputConfig(typedMember);
+    const currentValue = this._getTypedMemberHeaderValue(columnId, typedMember.axisId);
+    const hasValidationError = !!((_a = this._typedMemberErrors[this._typedMemberErrorKey(columnId, typedMember.axisId)]) == null ? void 0 : _a.length);
+    const fieldClass = `typed-member-header-field ${isRequired ? "required-field" : ""} ${hasValidationError ? "has-error" : ""}`;
+    const requiredTitle = isRequired ? I18n.t("validation.typedMemberRequired") : "";
+    const onChange = (e2) => this._handleTypedMemberHeaderChange(e2, columnId, typedMember.axisId);
+    const onBlur = (e2) => this._handleTypedMemberHeaderBlur(e2, columnId, typedMember);
+    if (typeConfig.fieldType === "select" || isSelectType(typeConfig.fieldType)) {
+      const options = typeConfig.enumerations || [];
+      return html`
+        <select
+          class="${fieldClass}"
+          .value="${currentValue}"
+          title="${requiredTitle}"
+          @change="${onChange}"
+          @blur="${onBlur}"
+        >
+          <option value="">${typeConfig.placeholder || I18n.t("field.select")}</option>
+          ${options.map((option) => html`
+            <option value="${option.value}" ?selected="${currentValue === option.value}">
+              ${option.label || option.value}
+            </option>
+          `)}
+        </select>
+      `;
+    }
+    if (typeConfig.fieldType === "boolean" || isCheckboxType(typeConfig.fieldType)) {
+      return html`
+        <input
+          type="checkbox"
+          class="${fieldClass}"
+          .checked="${currentValue === "true"}"
+          title="${requiredTitle}"
+          @change="${onChange}"
+          @blur="${onBlur}"
+        />
+      `;
+    }
+    const inputType = typeConfig.htmlInputType || "text";
+    const placeholder = `${typeConfig.placeholder || I18n.t("section.enterPlaceholder")} ${typedMember.axisLabel}`;
+    return html`
+      <input
+        type="${inputType}"
+        inputmode="${typeConfig.inputMode || ""}"
+        class="${fieldClass}"
+        placeholder="${placeholder}"
+        .value="${currentValue}"
+        min="${typeConfig.min !== void 0 ? typeConfig.min : ""}"
+        max="${typeConfig.max !== void 0 ? typeConfig.max : ""}"
+        step="${typeConfig.step !== void 0 ? typeConfig.step : ""}"
+        title="${requiredTitle}"
+        @input="${onChange}"
+        @blur="${onBlur}"
+      />
+    `;
+  }
   _handleAddRepeat(event) {
     event.stopPropagation();
     this.dispatchEvent(new CustomEvent("add-concept-repeat", {
@@ -8024,23 +8664,24 @@ let JupiterFormSection = class extends LitElement {
                       <!-- Typed member input fields in column header -->
                       ${((_a = column2.dimensionData) == null ? void 0 : _a.hasTypedMembers) ? html`
                         <div class="typed-members-header">
-                          ${(_c = (_b = column2.dimensionData) == null ? void 0 : _b.typedMembers) == null ? void 0 : _c.map((typedMember) => html`
+                          ${(_c = (_b = column2.dimensionData) == null ? void 0 : _b.typedMembers) == null ? void 0 : _c.map((typedMember) => {
+        const isRequired = !this._getTypedMemberHeaderValue(column2.id, typedMember.axisId) && this._columnHasAnyValue(column2.id);
+        return html`
                             <div class="typed-member-header-input">
                               ${this.mode === "readonly" ? html`
                                 <span class="typed-member-header-field" style="display:block;padding:4px 0;">
                                   ${this._getTypedMemberHeaderValue(column2.id, typedMember.axisId) || "—"}
                                 </span>
                               ` : html`
-                                <input
-                                  type="text"
-                                  class="typed-member-header-field"
-                                  placeholder="${I18n.t("section.enterPlaceholder")} ${typedMember.axisLabel}"
-                                  .value="${this._getTypedMemberHeaderValue(column2.id, typedMember.axisId)}"
-                                  @input="${(e2) => this._handleTypedMemberHeaderChange(e2, column2.id, typedMember.axisId)}"
-                                />
+                                <div class="typed-member-input-wrapper">
+                                  ${this._renderTypedMemberHeaderInput(column2.id, typedMember, isRequired)}
+                                  ${isRequired ? html`<span class="typed-member-required-asterisk" title="${I18n.t("validation.typedMemberRequired")}">*</span>` : ""}
+                                </div>
+                                ${this._renderTypedMemberHeaderErrors(column2.id, typedMember.axisId)}
                               `}
                             </div>
-                          `)}
+                          `;
+      })}
                         </div>
                       ` : ""}
                     </div>
@@ -8113,6 +8754,7 @@ let JupiterFormSection = class extends LitElement {
         .availableDimensions="${this.availableDimensions}"
         .periodStartDate="${this.periodStartDate}"
         .periodEndDate="${this.periodEndDate}"
+        .datatypes="${this.datatypes}"
         @dialog-cancel="${this._handleDialogCancel}"
         @column-add="${this._handleColumnAdd}"
       ></jupiter-add-column-dialog>
@@ -8366,6 +9008,34 @@ JupiterFormSection.styles = css`
       gap: 2px;
     }
 
+    .typed-member-input-wrapper {
+      display: flex;
+      align-items: center;
+      gap: 4px;
+    }
+
+    .typed-member-header-field.required-field,
+    .typed-member-header-field.has-error {
+      border-color: var(--jupiter-error-color, #d32f2f);
+    }
+
+    .typed-member-header-errors {
+      margin-top: 2px;
+    }
+
+    .typed-member-header-error {
+      display: block;
+      font-size: 11px;
+      color: var(--jupiter-error-color, #d32f2f);
+    }
+
+    .typed-member-required-asterisk {
+      color: var(--jupiter-error-color, #d32f2f);
+      font-weight: bold;
+      font-size: 13px;
+      flex-shrink: 0;
+    }
+
     .typed-member-header-label {
       font-size: 11px;
       font-weight: 500;
@@ -8494,6 +9164,9 @@ __decorateClass$4([
 __decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_insertAfterColumnId", 2);
+__decorateClass$4([
+  r()
+], JupiterFormSection.prototype, "_typedMemberErrors", 2);
 __decorateClass$4([
   r()
 ], JupiterFormSection.prototype, "_expandedConcepts", 2);
@@ -10899,6 +11572,7 @@ let JupiterDynamicForm = class extends LitElement {
     this.readonly = false;
     this.calculationEnabled = false;
     this.formulaEnabled = false;
+    this.tableLayoutEnabled = false;
     this.periodStartDate = "2025-01-01";
     this.periodEndDate = "2025-12-31";
     this.language = "en";
@@ -10908,6 +11582,7 @@ let JupiterDynamicForm = class extends LitElement {
     this.roleFilterAxes = [];
     this.showLastValidationResultBtn = false;
     this.isDraftSaving = false;
+    this.hasUnsavedChanges = false;
     this.defaultUnits = [];
     this.decimals = "INF";
     this._formData = {};
@@ -10996,6 +11671,7 @@ let JupiterDynamicForm = class extends LitElement {
       const oldValue = this._writeFormDataValue(conceptId, columnId, value);
       this._touched.add(`${conceptId}-${columnId}`);
       this._dirty = true;
+      this.hasUnsavedChanges = true;
       this._validateForm();
       this.requestUpdate();
       this.dispatchEvent(new CustomEvent("field-change", {
@@ -11033,6 +11709,12 @@ let JupiterDynamicForm = class extends LitElement {
     }
   }
   updated(changedProperties) {
+    if (changedProperties.has("hasUnsavedChanges")) {
+      this.dispatchEvent(new CustomEvent("has-unsaved-changes-change", {
+        detail: { hasUnsavedChanges: this.hasUnsavedChanges },
+        bubbles: true
+      }));
+    }
     if (changedProperties.has("decimals") || changedProperties.has("masterData")) {
       this._computeEffectiveMasterData();
     }
@@ -11437,22 +12119,34 @@ let JupiterDynamicForm = class extends LitElement {
    *
    * Skipped when form state is being restored from external props or localStorage so that
    * the user's previously saved preferences are not overridden.
+   *
+   * Roles that explicitly set showPreviousYear: false in presentation.json opt out of this
+   * auto-enable — that's a deliberate taxonomy-author decision and must win over the
+   * dimension-member heuristic below.
    */
   _applyDimensionShowPreviousYear() {
-    var _a, _b;
+    var _a, _b, _c, _d, _e, _f;
     if (this.mode !== "admin")
       return;
     const hasExternalState = !!(this.dynaformsFacts && this.dynaformsMetadata);
     const hasLocalDraft = ((_a = this._draftStorageService) == null ? void 0 : _a.hasDraft()) ?? false;
     if (hasExternalState || hasLocalDraft)
       return;
+    const explicitlyDisabled = /* @__PURE__ */ new Set();
+    (_e = (_d = (_c = (_b = this.xbrlInput) == null ? void 0 : _b.presentation) == null ? void 0 : _c[0]) == null ? void 0 : _d.roles) == null ? void 0 : _e.forEach((role) => {
+      if (role.showPreviousYear === false) {
+        explicitlyDisabled.add(role.id);
+      }
+    });
     const updated = { ...this._periodPreferences };
     let changed = false;
     for (const roleId of Object.keys(updated)) {
+      if (explicitlyDisabled.has(roleId))
+        continue;
       const prefs = updated[roleId];
       if (prefs.showPreviousYear)
         continue;
-      const hasDimensionMembers = ((_b = prefs.dimensionSelections) == null ? void 0 : _b.some(
+      const hasDimensionMembers = ((_f = prefs.dimensionSelections) == null ? void 0 : _f.some(
         (ds) => ds.selectedMemberIds && ds.selectedMemberIds.length > 0
       )) ?? false;
       if (hasDimensionMembers) {
@@ -11851,6 +12545,7 @@ let JupiterDynamicForm = class extends LitElement {
     console.log(`💾 Updated formData[${conceptId}]:`, this._formData[conceptId]);
     this._touched.add(`${conceptId}-${columnId}`);
     this._dirty = true;
+    this.hasUnsavedChanges = true;
     this._validateForm();
     this.requestUpdate();
     this.dispatchEvent(new CustomEvent("field-change", {
@@ -11882,6 +12577,7 @@ let JupiterDynamicForm = class extends LitElement {
       this._storeUnit(conceptId, columnId, unit);
     }
     this._dirty = true;
+    this.hasUnsavedChanges = true;
     this.requestUpdate();
   }
   _handleUnitChange(event) {
@@ -11891,6 +12587,7 @@ let JupiterDynamicForm = class extends LitElement {
     console.log(`🏷️ Unit change received: conceptId=${conceptId}, columnId=${columnId}, unit=${unit}`);
     this._storeUnit(conceptId, columnId, unit);
     this._dirty = true;
+    this.hasUnsavedChanges = true;
     this.requestUpdate();
   }
   _storeUnit(conceptId, columnId, unit) {
@@ -11915,6 +12612,7 @@ let JupiterDynamicForm = class extends LitElement {
       return;
     this._storeDecimals(conceptId, columnId, decimals);
     this._dirty = true;
+    this.hasUnsavedChanges = true;
     this.requestUpdate();
   }
   _computeEffectiveMasterData() {
@@ -12056,6 +12754,7 @@ let JupiterDynamicForm = class extends LitElement {
     const { conceptId } = event.detail;
     this._repeatCounts = { ...this._repeatCounts, [conceptId]: (this._repeatCounts[conceptId] || 0) + 1 };
     this._dirty = true;
+    this.hasUnsavedChanges = true;
   }
   _handleRemoveConceptRepeat(event) {
     const { conceptId: rawConceptId } = event.detail;
@@ -12108,6 +12807,7 @@ let JupiterDynamicForm = class extends LitElement {
     this._periodData = newPeriodData;
     this._repeatCounts = { ...this._repeatCounts, [baseConceptId]: current - 1 };
     this._dirty = true;
+    this.hasUnsavedChanges = true;
   }
   _handleTypedMemberChange(event) {
     const { columnId, axisId, value, conceptId } = event.detail;
@@ -12120,6 +12820,7 @@ let JupiterDynamicForm = class extends LitElement {
     updatedTypedMemberData[storageKey] = { ...updatedTypedMemberData[storageKey], [axisId]: value };
     this._typedMemberData = updatedTypedMemberData;
     this._dirty = true;
+    this.hasUnsavedChanges = true;
     this.requestUpdate();
     this.dispatchEvent(new CustomEvent("typed-member-change", {
       detail: { columnId, axisId, value },
@@ -12318,6 +13019,7 @@ let JupiterDynamicForm = class extends LitElement {
     }
     this._removeColumnData(columnId, sectionId);
     this._dirty = true;
+    this.hasUnsavedChanges = true;
     this._validateForm();
     this.requestUpdate();
     this.dispatchEvent(new CustomEvent("column-remove", {
@@ -12334,6 +13036,7 @@ let JupiterDynamicForm = class extends LitElement {
     }
     this._hiddenColumnIds.get(sectionId).add(columnId);
     this._dirty = true;
+    this.hasUnsavedChanges = true;
     this.requestUpdate();
     this.dispatchEvent(new CustomEvent("column-hide", {
       detail: { columnId, sectionId },
@@ -12347,6 +13050,7 @@ let JupiterDynamicForm = class extends LitElement {
       return;
     (_a = this._hiddenColumnIds.get(sectionId)) == null ? void 0 : _a.delete(columnId);
     this._dirty = true;
+    this.hasUnsavedChanges = true;
     this.requestUpdate();
     this.dispatchEvent(new CustomEvent("column-show", {
       detail: { columnId, sectionId },
@@ -12410,8 +13114,8 @@ let JupiterDynamicForm = class extends LitElement {
             if (dimension.typedMember) {
               availableDimension.typedMember = {
                 id: dimension.typedMember.id,
-                dataType: "string"
-                // Default to string for now
+                dataType: dimension.typedMember.type || "string",
+                validation: dimension.typedMember.validation
               };
             }
             availableDimensions.push(availableDimension);
@@ -12632,8 +13336,10 @@ let JupiterDynamicForm = class extends LitElement {
             axisLabel: dim.axisLabel,
             typedMemberId: dim.axisId,
             // Use axisId as typedMemberId for typed dimensions
-            memberLabel: dim.axisLabel
+            memberLabel: dim.axisLabel,
             // Use axisLabel as memberLabel
+            type: dim.dataType,
+            validation: dim.validation
           }));
         }
       }
@@ -12662,6 +13368,7 @@ let JupiterDynamicForm = class extends LitElement {
     }
     this._replicateFieldsForNewColumn(newColumnId, request, sectionId);
     this._dirty = true;
+    this.hasUnsavedChanges = true;
     this.requestUpdate();
     this.dispatchEvent(new CustomEvent("column-add", {
       detail: { column: newColumn },
@@ -12981,9 +13688,11 @@ let JupiterDynamicForm = class extends LitElement {
     });
     if (draftPayloadSnapshot === this._lastSavedDraftSnapshot) {
       console.log(`ℹ️ [Save Draft] No draft content change detected (${source}); skipping event emit.`);
+      this.hasUnsavedChanges = false;
       return;
     }
     this._lastSavedDraftSnapshot = draftPayloadSnapshot;
+    this.hasUnsavedChanges = false;
     const saved = this._draftStorageService.saveDraft(draftData, metadata);
     console.log("💾 [Save Draft] Metadata saved with enhanced selectedRoleIds:", metadata.selectedRoleIds);
     this.dynaformsFacts = draftData;
@@ -14067,6 +14776,7 @@ let JupiterDynamicForm = class extends LitElement {
     this._formData = { ...this.initialData };
     this._touched.clear();
     this._dirty = false;
+    this.hasUnsavedChanges = false;
     this._submitted = false;
     this._preservedFormData = {};
     this._preservedTypedMemberData = {};
@@ -15010,6 +15720,7 @@ let JupiterDynamicForm = class extends LitElement {
   setData(data) {
     this._formData = { ...data };
     this._dirty = true;
+    this.hasUnsavedChanges = true;
     this._validateForm();
     this.requestUpdate();
   }
@@ -15438,7 +16149,7 @@ let JupiterDynamicForm = class extends LitElement {
             <button 
               class="btn-secondary"
               @click="${this._handleSaveDraft}"
-              ?disabled="${this.disabled || this.readonly || this.isDraftSaving}"
+              ?disabled="${this.disabled || this.readonly || this.isDraftSaving || !this.hasUnsavedChanges}"
             >
               ${this.isDraftSaving ? I18n.t("form.savingDraft") : I18n.t("form.saveDraft")}
             </button>
@@ -16436,6 +17147,9 @@ __decorateClass([
 __decorateClass([
   n2({ type: Boolean, attribute: "formula-enabled" })
 ], JupiterDynamicForm.prototype, "formulaEnabled", 2);
+__decorateClass([
+  n2({ type: Boolean, attribute: "table-layout-enabled" })
+], JupiterDynamicForm.prototype, "tableLayoutEnabled", 2);
 __decorateClass([
   n2({ type: String })
 ], JupiterDynamicForm.prototype, "periodStartDate", 2);
@@ -16466,6 +17180,9 @@ __decorateClass([
 __decorateClass([
   n2({ type: Boolean, attribute: "is-draft-saving" })
 ], JupiterDynamicForm.prototype, "isDraftSaving", 2);
+__decorateClass([
+  n2({ type: Boolean, attribute: "has-unsaved-changes", reflect: true })
+], JupiterDynamicForm.prototype, "hasUnsavedChanges", 2);
 __decorateClass([
   n2({ type: Array })
 ], JupiterDynamicForm.prototype, "defaultUnits", 2);