@umriss-ui/calculation 0.41.1 → 0.43.0

package/dist/calculation.model-CZuohgrp.js

@@ -0,0 +1,176 @@
+import { Children as ie, isValidElement as b, Fragment as ae } from "react";
+const p = (o) => Object.defineProperty(() => {
+  throw new Error(
+    `@umriss-ui/calculation: <${o}> stands only directly inside a <Calculation>. A tree written in a Server Component must be written inside the <Calculation> there, in one file, not passed through a client component.`
+  );
+}, "name", { value: o }), se = p("Given"), re = p("Sum"), ce = p("Difference"), ue = p("Product"), le = p("Quotient"), J = p("Ref"), fe = p("Chain"), de = p("Plus"), pe = p("Minus"), me = p("Times"), he = p("DividedBy"), Q = p("Interim"), $e = /* @__PURE__ */ new Map([
+  [re, "sum"],
+  [ce, "difference"],
+  [ue, "product"],
+  [le, "quotient"]
+]), U = {
+  sum: "Sum",
+  difference: "Difference",
+  product: "Product",
+  quotient: "Quotient"
+}, B = /* @__PURE__ */ new Map([
+  [de, { name: "Plus", operator: "sum" }],
+  [pe, { name: "Minus", operator: "sum", negated: !0 }],
+  [me, { name: "Times", operator: "product" }],
+  [he, { name: "DividedBy", operator: "quotient" }]
+]), G = "<Given>, <Sum>, <Difference>, <Product>, <Quotient> or <Chain>", Y = "a calculation with metrics only adds and subtracts - <Sum>, <Difference>, <Plus>, <Minus>.", ye = ["unit", "format", "decimals"];
+function a(o) {
+  throw new Error(`@umriss-ui/calculation: ${o}`);
+}
+function P(o) {
+  return ie.toArray(o).flatMap(
+    (t) => b(t) && t.type === ae ? P(t.props.children) : [t]
+  );
+}
+function E(o) {
+  if (!b(o)) return JSON.stringify(o);
+  const t = o.type;
+  return typeof t == "string" ? `<${t}>` : `<${t.displayName ?? t.name ?? "anonymous"}>`;
+}
+const K = (o, t, s) => `${o}/${b(t) && t.key || s}`;
+function be(o, t) {
+  const s = P(o);
+  if (s.length !== 1 && a(`<Calculation> takes exactly one child, the result; it was given ${s.length}.`), t !== void 0) {
+    t.length === 0 && a("<Calculation>: metrics is empty; leave it out for a calculation with one number per quantity.");
+    const n = /* @__PURE__ */ new Set();
+    for (const { id: i } of t)
+      n.has(i) && a(`<Calculation>: the metric id "${i}" is used twice.`), n.add(i);
+  }
+  const m = t?.map((n) => `"${n.id}"`).join(", "), r = (n, i) => {
+    const c = typeof n == "object" && n !== null;
+    if (t === void 0) {
+      c && a(`${i}: value is an object by metric, but the calculation has no metrics.`);
+      return;
+    }
+    c || a(`${i}: with metrics, value is an object with a number for each metric - ${m}.`);
+    for (const { id: e } of t)
+      e in n || a(`${i}: value has no number for the metric "${e}"; write null where it is absent. The metrics: ${m}.`);
+    for (const e of Object.keys(n))
+      t.some((u) => u.id === e) || a(`${i}: value has a number for "${e}", which is no metric. The metrics: ${m}.`);
+  }, l = /* @__PURE__ */ new Map(), v = /* @__PURE__ */ new Map(), S = [], R = (n, i, c) => {
+    const { id: e, ...u } = i;
+    if (t !== void 0) {
+      for (const w of ye)
+        i[w] !== void 0 && a(`${c}: ${w} belongs to the metric once the calculation has metrics, not to a quantity.`);
+      (i.target !== void 0 || i.limits !== void 0) && a(`${c}: target and limits are not assessed in a calculation with metrics.`);
+    }
+    e !== void 0 && (v.has(e) && a(`${c}: the id "${e}" is used twice.`), v.set(e, n));
+    const $ = { ...u, key: n, id: e, operands: [] };
+    return l.set(n, $), $;
+  }, N = (n, i, c) => {
+    if (b(n) && n.type === J) {
+      const e = { key: "", reference: !0 };
+      return S.push({ operand: e, to: n.props.to, where: c }), e;
+    }
+    return { key: L(n, i, c), reference: !1 };
+  }, L = (n, i, c) => {
+    if ((!b(n) || n.type === J || B.has(n.type) || n.type === Q) && a(`${c}: ${E(n)} cannot stand here; a quantity must be ${G}.`), n.type === fe) return H(n.props.children, i, c);
+    const e = $e.get(n.type);
+    n.type !== se && e === void 0 && a(
+      `${c}: ${E(n)} is not an element of the calculation. A calculation reads its children's props and cannot look inside a component of your own; write ${G} or <Ref> directly, or return them from .map.`
+    );
+    const { children: u, value: $, source: w, asOf: I, ages: h, ...q } = n.props, f = `${c} › ${q.label}`;
+    t !== void 0 && (e === "product" || e === "quotient") && a(`${f}: <${U[e]}> - ${Y}`);
+    const C = R(i, q, f);
+    if (e === void 0)
+      return r($, f), C.given = { value: $, source: w, asOf: I, ages: h }, i;
+    C.operator = e;
+    const y = P(u), d = y.length;
+    return (e === "quotient" ? d !== 2 : e !== "sum" && d < 2) && a(
+      `${f}: <${U[e]}> takes ${e === "quotient" ? "exactly two operands" : "two or more operands"}; it was given ${d}.`
+    ), C.operands = y.map((O, T) => N(O, K(i, O, T), f)), i;
+  }, H = (n, i, c) => {
+    const e = `${c} › <Chain>`, [u, ...$] = P(n);
+    (u === void 0 || b(u) && (B.has(u.type) || u.type === Q)) && a(`${e}: a chain starts with a quantity that has no operator - ${G} or <Ref>.`);
+    let w = N(u, K(i, u, 0), e), I = E(u), h = [], q;
+    return $.forEach((f, C) => {
+      const y = K(i, f, C + 1);
+      if (b(f) && f.type === Q) {
+        const g = f.props, D = `${e} › ${g.label}`;
+        h.length === 0 && a(`${D}: an <Interim> needs an operand since the named value before it, ${I}.`);
+        const x = R(y, g, D);
+        x.interim = !0, x.operator = h[0].line.operator, x.operands = [w, ...h.map((oe) => oe.operand)], w = { key: y, reference: !1, previous: !0 }, I = `<Interim label="${g.label}">`, h = [], q = y;
+        return;
+      }
+      const d = b(f) ? B.get(f.type) : void 0;
+      d === void 0 && a(`${e}: ${E(f)} needs an operator in a chain - <Plus>, <Minus>, <Times> or <DividedBy> - or is an <Interim>.`), t !== void 0 && d.operator !== "sum" && a(`${e}: <${d.name}> - ${Y}`);
+      const O = d.operator !== "sum", T = h.find((g) => g.line.operator !== "sum");
+      (O && h.length > 0 || T) && a(
+        `${e}: <${(T ?? { line: d }).line.name}> stands alone between two named values - directly after the first quantity or an <Interim>, and directly before an <Interim>.`
+      );
+      const { children: W, ...M } = f.props, A = P(W), _ = () => a(`${e}: <${d.name}> takes either a label and a value, or exactly one quantity as its child.`);
+      if (A.length > 0) {
+        (A.length > 1 || Object.values(M).some((D) => D !== void 0)) && _();
+        const g = N(A[0], y, e);
+        g.negated = d.negated, h.push({ operand: g, line: d });
+        return;
+      }
+      M.label === void 0 && _();
+      const { value: V, source: X, asOf: Z, ages: ee, ...te } = M, F = `${e} › ${M.label}`, ne = R(y, { ...te, label: M.label }, F);
+      r(V, F), ne.given = { value: V, source: X, asOf: Z, ages: ee }, h.push({ operand: { key: y, reference: !1, negated: d.negated }, line: d });
+    }), (h.length > 0 || q === void 0) && a(`${e}: a chain ends with an <Interim>, which names its value.`), q;
+  }, j = L(s[0], "0", "<Calculation>"), k = l.get(j);
+  (k.emphasis !== void 0 || k.rule !== void 0) && a(`<Calculation> › ${k.label}: emphasis and rule do not stand on the Result, which is already the heaviest line.`);
+  for (const { operand: n, to: i, where: c } of S) {
+    const e = v.get(i);
+    if (e === void 0) {
+      const u = [...v.keys()].map(($) => `"${$}"`).join(", ");
+      a(`${c}: <Ref to="${i}"> names no quantity. ${u ? `The ids that exist: ${u}.` : "No quantity has an id."}`);
+    }
+    n.key = e;
+  }
+  return ve(l), t === void 0 && z(l, j), { result: j, quantities: l, metrics: t };
+}
+function we(o) {
+  return o.metrics ? o.metrics.map((t) => {
+    const s = /* @__PURE__ */ new Map();
+    for (const [m, r] of o.quantities) {
+      const l = r.given && { ...r.given, value: r.given.value[t.id] };
+      s.set(m, { ...r, unit: t.unit, decimals: t.decimals, given: l });
+    }
+    return { result: o.result, quantities: s };
+  }) : [o];
+}
+function z(o, t) {
+  const s = o.get(t);
+  for (const { key: m, reference: r } of s.operands) {
+    if (r) continue;
+    const l = o.get(m);
+    l.decimals === void 0 && l.unit === s.unit && l.format === s.format && (l.decimals = s.decimals), z(o, m);
+  }
+}
+function ve(o) {
+  const t = /* @__PURE__ */ new Set(), s = [], m = (r) => {
+    if (t.has(r)) return;
+    const l = s.indexOf(r);
+    if (l !== -1) {
+      const v = [...s.slice(l), r].map((S) => o.get(S).label);
+      a(`the calculation goes round in a circle through references: ${v.join(" → ")}.`);
+    }
+    s.push(r);
+    for (const v of o.get(r).operands) m(v.key);
+    s.pop(), t.add(r);
+  };
+  for (const r of o.keys()) m(r);
+}
+export {
+  fe as C,
+  ce as D,
+  se as G,
+  Q as I,
+  pe as M,
+  de as P,
+  le as Q,
+  J as R,
+  re as S,
+  me as T,
+  he as a,
+  ue as b,
+  we as p,
+  be as r
+};

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { HTMLAttributes } from 'react';
 import { JSX } from 'react';
 import { Limit } from '@umriss-ui/core';
 import { ReactNode } from 'react';
+import { RefProp } from '@umriss-ui/core';
 
 /** A derivation the package works out itself and shows as a statement, from
  the givens up to the result: one quantity as its child, written with
@@ -10,11 +11,12 @@ import { ReactNode } from 'react';
  operation it shows, the number cannot disagree with the lines above it.
  Every tree below the outermost statement starts folded and opens beneath
  the row that is clicked. */
-export declare function Calculation({ children, className, style, metrics, density, ...rest }: CalculationProps): JSX.Element;
+export declare function Calculation({ children, metrics, ...rest }: CalculationProps): JSX.Element;
 
-/** `className` and `style` size and place the surface; every other attribute -
- `aria-label` first of all - lands on the list the surface holds. */
-export declare interface CalculationProps extends Omit<HTMLAttributes<HTMLUListElement>, "children"> {
+/** A composite: `ref`, `className`, `style` and every other attribute reach the
+ surface; `aria-label`, `aria-labelledby` and `aria-describedby` reach the
+ list it holds, which carries the role they name. */
+export declare interface CalculationProps extends Omit<HTMLAttributes<HTMLDivElement>, "children">, RefProp<HTMLDivElement> {
     /** The result: exactly one quantity - a tree (`<Sum>`, `<Difference>`,
      `<Product>`, `<Quotient>` with their operands, `<Given>` as leaves) or a
      `<Chain>`, the two mixing freely; `<Ref>` for a quantity defined
@@ -144,7 +146,8 @@ export declare interface QuantityProps {
      The quantity stays a ratio in every operation. */
     format?: "percent";
     /** Fixed number of fraction digits as shown. Rounding happens only in
-     presentation; every operation uses the full value.
+     presentation; every operation uses the full value. The places carry down
+     to operands of the same `unit` and `format` that set none of their own.
      @default one digit for a percentage, at most two for a derived number, a
      given as it was given */
     decimals?: number;

package/docs/llms-full.md

@@ -1,4 +1,4 @@
-# @umriss-ui/calculation 0.41.1
+# @umriss-ui/calculation 0.43.0
 
 > React calculation view for data-dense applications - a derivation written as it is shown, evaluated by the library, folded and read line by line.
 
@@ -1054,7 +1054,7 @@ From `OperatorProps` — the full table stands on [Tree](#tree).
 | [`id`](#tree) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`. |
 | [`unit`](#tree) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#tree) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#tree) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#tree) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 | [`target`](#tree) | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`. |
 
 From `RefProps` — the full table stands on [Tree](#tree).
@@ -1070,7 +1070,7 @@ From `ChainOperandProps` — the full table stands on [Chain](#chain).
 | [`id`](#chain) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`. |
 | [`unit`](#chain) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#chain) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 | [`target`](#chain) | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`. |
 
 From `QuantityProps` — the full table stands on [Chain](#chain).
@@ -1081,7 +1081,7 @@ From `QuantityProps` — the full table stands on [Chain](#chain).
 | [`id`](#chain) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. |
 | [`unit`](#chain) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. |
 | [`format`](#chain) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. |
-| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. |
+| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. |
 | [`target`](#chain) | `number` | — | The value this quantity is meant to reach - missed, never violated. |
 
 From `GivenProps` — the full table stands on [Given](#given).
@@ -1093,7 +1093,7 @@ From `GivenProps` — the full table stands on [Given](#given).
 | [`id`](#given) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`. |
 | [`unit`](#given) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#given) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#given) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#given) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 | [`target`](#given) | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`. |
 
 ## Writing a calculation
@@ -1559,15 +1559,16 @@ Name the calculation with `aria-label`, which lands on the list; without it a re
 | `children` *required* | `ReactNode` | — | The result: exactly one quantity - a tree (`<Sum>`, `<Difference>`, `<Product>`, `<Quotient>` with their operands, `<Given>` as leaves) or a `<Chain>`, the two mixing freely; `<Ref>` for a quantity defined elsewhere.<br>Shown in: [Two numbers and a sum](#calculation), [Write a tree](#calculation), [Write a chain](#calculation) and 50 more |
 | `metrics` | `readonly `[`Metric`](#metrics)`[]` | — | Several numbers per quantity, side by side - headcount and full-time equivalents of the same teams ([ADR-0038](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0038-a-calculation-can-carry-several-metrics.md)). Every `value` is then an object with a number for each metric id; unit and places are the metric's. A calculation with metrics only adds and subtracts, and assesses no target or limits.<br>Shown in: [Rows of both signs with metrics (Rows from data)](#rows-from-data), [Headcount and full-time equivalents (Metrics)](#metrics), [A number one metric does not have (Metrics)](#metrics) and 5 more |
 | `density` | `"regular" \| "compact"` | the density of the `UmrissProvider`, else `"regular"` | `"compact"` sets the lines as close as a compact table's rows: smaller type and less room above and below, under a finger still tall enough to tap. Columns, folding and wording stay as they are.<br>Shown in: [Density](#calculation), [A dense staff report (Metrics)](#metrics) |
+| `ref` | `Ref<HTMLDivElement> \| undefined` | — | Receives the component's root element. From `RefProp`. |
 
-Also takes every attribute of the rendered element – without `children`.
+Also takes every attribute of `<div>` – without `children`.
 
 #### Known limits
 
 - No result, formula text or operator of your own: a written-out operation the library did not perform could say something the number does not ([ADR-0027](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0027-a-calculation-is-written-as-it-is-shown.md)).
 - No input: a calculation shows how a figure came about; changing a given is your application's form.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.41.1/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.43.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Tree
 
@@ -1789,7 +1790,7 @@ The keys of [Calculation](#calculation) apply here.
 | `id` | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`.<br>Shown in: [Use a quantity twice](#tree), [The availability of a service (Installation)](#installation), [Write a tree (Calculation)](#calculation) and 10 more |
 | `unit` | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`.<br>Shown in: [Show a share against a target](#tree), [Take several amounts away](#tree), [Multiply quantities with units](#tree) and 42 more |
 | `format` | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`.<br>Shown in: [Show a share against a target](#tree), [Use a quantity twice](#tree), [Build operands from data](#tree) and 17 more |
-| `decimals` | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`.<br>Shown in: [Multiply quantities with units](#tree), [Build operands from data](#tree), [Hold a figure to its limits](#tree) and 29 more |
+| `decimals` | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`.<br>Shown in: [Multiply quantities with units](#tree), [Build operands from data](#tree), [Hold a figure to its limits](#tree) and 29 more |
 | `target` | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`.<br>Shown in: [Show a share against a target](#tree), [The availability of a service (Installation)](#installation), [Write a tree (Calculation)](#calculation) and 6 more |
 | `limits` | `readonly ``Limit``[]` | — | Bounds the quantity is assessed against, through core's `assess()`. From `QuantityProps`.<br>Shown in: [Hold a figure to its limits](#tree), [Density (Calculation)](#calculation), [Hold an interim to its limits (Chain)](#chain) and 5 more |
 | `explanation` | `string` | — | A sentence of plain text beside the line: why the quantity is here, or what it means. From `QuantityProps`.<br>Shown in: [Say where a number came from (Given)](#given), [A number one metric does not have (Metrics)](#metrics), [Staff movement as a chain (Metrics)](#metrics) and 2 more |
@@ -1848,7 +1849,7 @@ type Severity = "warning" | "alarm";
 - Four operators and nothing else – no powers, roots or functions; compute those before and hand them in as givens.
 - A unit is a label and is never converted or checked; the calculation does no unit algebra.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.41.1/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.43.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Chain
 
@@ -2103,7 +2104,7 @@ The keys of [Calculation](#calculation) apply here.
 | `id` | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`.<br>Shown in: [Fold a group of lines into one](#chain), [Put a chain inside a tree](#chain), [The availability of a service (Installation)](#installation) and 10 more |
 | `unit` | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`.<br>Shown in: [Take amounts away from a first quantity](#chain), [Mix additions and deductions](#chain), [Multiply between two interims](#chain) and 42 more |
 | `format` | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`.<br>Shown in: [Fold a group of lines into one](#chain), [Put a chain inside a tree](#chain), [Hold an interim to its limits](#chain) and 17 more |
-| `decimals` | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`.<br>Shown in: [Take amounts away from a first quantity](#chain), [Mix additions and deductions](#chain), [Multiply between two interims](#chain) and 29 more |
+| `decimals` | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`.<br>Shown in: [Take amounts away from a first quantity](#chain), [Mix additions and deductions](#chain), [Multiply between two interims](#chain) and 29 more |
 | `target` | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`.<br>Shown in: [Put a chain inside a tree](#chain), [The availability of a service (Installation)](#installation), [Write a tree (Calculation)](#calculation) and 6 more |
 | `limits` | `readonly ``Limit``[]` | — | Bounds the quantity is assessed against, through core's `assess()`. From `QuantityProps`.<br>Shown in: [Hold an interim to its limits](#chain), [Density (Calculation)](#calculation), [Hold a figure to its limits (Tree)](#tree) and 5 more |
 | `explanation` | `string` | — | A sentence of plain text beside the line: why the quantity is here, or what it means. From `QuantityProps`.<br>Shown in: [Say where a number came from (Given)](#given), [A number one metric does not have (Metrics)](#metrics), [Staff movement as a chain (Metrics)](#metrics) and 2 more |
@@ -2119,7 +2120,7 @@ The keys of [Calculation](#calculation) apply here.
 | `id` | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once.<br>Shown in: [Fold a group of lines into one](#chain), [Put a chain inside a tree](#chain), [The availability of a service (Installation)](#installation) and 10 more |
 | `unit` | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra.<br>Shown in: [Take amounts away from a first quantity](#chain), [Mix additions and deductions](#chain), [Multiply between two interims](#chain) and 42 more |
 | `format` | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation.<br>Shown in: [Fold a group of lines into one](#chain), [Put a chain inside a tree](#chain), [Hold an interim to its limits](#chain) and 17 more |
-| `decimals` | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value.<br>Shown in: [Take amounts away from a first quantity](#chain), [Mix additions and deductions](#chain), [Multiply between two interims](#chain) and 29 more |
+| `decimals` | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own.<br>Shown in: [Take amounts away from a first quantity](#chain), [Mix additions and deductions](#chain), [Multiply between two interims](#chain) and 29 more |
 | `target` | `number` | — | The value this quantity is meant to reach - missed, never violated.<br>Shown in: [Put a chain inside a tree](#chain), [The availability of a service (Installation)](#installation), [Write a tree (Calculation)](#calculation) and 6 more |
 | `limits` | `readonly ``Limit``[]` | — | Bounds the quantity is assessed against, through core's `assess()`.<br>Shown in: [Hold an interim to its limits](#chain), [Density (Calculation)](#calculation), [Hold a figure to its limits (Tree)](#tree) and 5 more |
 | `explanation` | `string` | — | A sentence of plain text beside the line: why the quantity is here, or what it means.<br>Shown in: [Say where a number came from (Given)](#given), [A number one metric does not have (Metrics)](#metrics), [Staff movement as a chain (Metrics)](#metrics) and 2 more |
@@ -2196,7 +2197,7 @@ type Severity = "warning" | "alarm";
 
 - A chain in view does not fold; as an operand of a tree it folds to its last interim.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.41.1/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.43.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Rows from data
 
@@ -2576,7 +2577,7 @@ From `OperatorProps` — the full table stands on [Tree](#tree).
 | [`id`](#tree) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`. |
 | [`unit`](#tree) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#tree) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#tree) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#tree) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 
 From `RefProps` — the full table stands on [Tree](#tree).
 
@@ -2600,7 +2601,7 @@ From `ChainOperandProps` — the full table stands on [Chain](#chain).
 | [`id`](#chain) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`. |
 | [`unit`](#chain) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#chain) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 
 From `QuantityProps` — the full table stands on [Chain](#chain).
 
@@ -2610,7 +2611,7 @@ From `QuantityProps` — the full table stands on [Chain](#chain).
 | [`id`](#chain) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. |
 | [`unit`](#chain) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. |
 | [`format`](#chain) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. |
-| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. |
+| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. |
 
 From `GivenProps` — the full table stands on [Given](#given).
 
@@ -2621,7 +2622,7 @@ From `GivenProps` — the full table stands on [Given](#given).
 | [`id`](#given) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`. |
 | [`unit`](#given) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#given) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#given) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#given) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 
 From `Metric` — the full table stands on [Metrics](#metrics).
 
@@ -2636,7 +2637,7 @@ From `Metric` — the full table stands on [Metrics](#metrics).
 
 - Only a sum takes any count: an empty product, a difference of one and a quotient of anything but two still fail on the first render.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.41.1/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.43.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Given
 
@@ -2749,7 +2750,7 @@ The keys of [Calculation](#calculation) apply here.
 | `id` | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`.<br>Shown in: [Read in German](#given), [The availability of a service (Installation)](#installation), [Write a tree (Calculation)](#calculation) and 10 more |
 | `unit` | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`.<br>Shown in: [Say where a number came from](#given), [State when a number was true](#given), [Read in German](#given) and 42 more |
 | `format` | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`.<br>Shown in: [Say where a number came from](#given), [Read in German](#given), [The availability of a service (Installation)](#installation) and 17 more |
-| `decimals` | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`.<br>Shown in: [Say where a number came from](#given), [State when a number was true](#given), [Read in German](#given) and 29 more |
+| `decimals` | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`.<br>Shown in: [Say where a number came from](#given), [State when a number was true](#given), [Read in German](#given) and 29 more |
 | `target` | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`.<br>Shown in: [The availability of a service (Installation)](#installation), [Write a tree (Calculation)](#calculation), [Density (Calculation)](#calculation) and 6 more |
 | `limits` | `readonly ``Limit``[]` | — | Bounds the quantity is assessed against, through core's `assess()`. From `QuantityProps`.<br>Shown in: [Say where a number came from](#given), [Density (Calculation)](#calculation), [Hold a figure to its limits (Tree)](#tree) and 5 more |
 | `explanation` | `string` | — | A sentence of plain text beside the line: why the quantity is here, or what it means. From `QuantityProps`.<br>Shown in: [Say where a number came from](#given), [A number one metric does not have (Metrics)](#metrics), [Staff movement as a chain (Metrics)](#metrics) and 2 more |
@@ -3322,7 +3323,7 @@ The keys of [Calculation](#calculation) apply here.
 - Unit, format and places belong to the metric; on a quantity they fail on the first render, and so does a missing or unknown metric key in a `value`.
 - No target or limits with metrics: an assessment per cell is not there yet.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.41.1/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.43.0/docs/adr/0032-what-umriss-is-not.md).
 
 ## In practice
 
@@ -3474,7 +3475,7 @@ From `OperatorProps` — the full table stands on [Tree](#tree).
 | [`label`](#tree) *required* | `string` | — | What the quantity is called. It stands on its line, wherever it is an operand, and in the accessible sentence. From `QuantityProps`. |
 | [`unit`](#tree) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#tree) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#tree) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#tree) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 | [`target`](#tree) | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`. |
 | [`limits`](#tree) | `readonly `[`Limit`](#tree)`[]` | — | Bounds the quantity is assessed against, through core's `assess()`. From `QuantityProps`. |
 
@@ -3492,7 +3493,7 @@ From `ChainOperandProps` — the full table stands on [Chain](#chain).
 | [`source`](#chain) | `string` | — | Where the number came from: a system, a report, a person. From `GivenProps`. |
 | [`unit`](#chain) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#chain) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 | [`target`](#chain) | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`. |
 | [`limits`](#chain) | `readonly `[`Limit`](#chain)`[]` | — | Bounds the quantity is assessed against, through core's `assess()`. From `QuantityProps`. |
 
@@ -3503,7 +3504,7 @@ From `QuantityProps` — the full table stands on [Chain](#chain).
 | [`label`](#chain) *required* | `string` | — | What the quantity is called. It stands on its line, wherever it is an operand, and in the accessible sentence. |
 | [`unit`](#chain) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. |
 | [`format`](#chain) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. |
-| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. |
+| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. |
 | [`target`](#chain) | `number` | — | The value this quantity is meant to reach - missed, never violated. |
 | [`limits`](#chain) | `readonly `[`Limit`](#chain)`[]` | — | Bounds the quantity is assessed against, through core's `assess()`. |
 
@@ -3516,7 +3517,7 @@ From `GivenProps` — the full table stands on [Given](#given).
 | [`label`](#given) *required* | `string` | — | What the quantity is called. It stands on its line, wherever it is an operand, and in the accessible sentence. From `QuantityProps`. |
 | [`unit`](#given) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#given) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#given) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#given) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 | [`target`](#given) | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`. |
 | [`limits`](#given) | `readonly `[`Limit`](#given)`[]` | — | Bounds the quantity is assessed against, through core's `assess()`. From `QuantityProps`. |
 
@@ -3989,7 +3990,7 @@ From `OperatorProps` — the full table stands on [Tree](#tree).
 | [`id`](#tree) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`. |
 | [`unit`](#tree) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#tree) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#tree) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#tree) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 | [`target`](#tree) | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`. |
 | [`limits`](#tree) | `readonly `[`Limit`](#tree)`[]` | — | Bounds the quantity is assessed against, through core's `assess()`. From `QuantityProps`. |
 
@@ -4018,7 +4019,7 @@ From `ChainOperandProps` — the full table stands on [Chain](#chain).
 | [`id`](#chain) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`. |
 | [`unit`](#chain) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#chain) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 | [`target`](#chain) | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`. |
 | [`limits`](#chain) | `readonly `[`Limit`](#chain)`[]` | — | Bounds the quantity is assessed against, through core's `assess()`. From `QuantityProps`. |
 
@@ -4030,7 +4031,7 @@ From `QuantityProps` — the full table stands on [Chain](#chain).
 | [`id`](#chain) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. |
 | [`unit`](#chain) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. |
 | [`format`](#chain) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. |
-| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. |
+| [`decimals`](#chain) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. |
 | [`target`](#chain) | `number` | — | The value this quantity is meant to reach - missed, never violated. |
 | [`limits`](#chain) | `readonly `[`Limit`](#chain)`[]` | — | Bounds the quantity is assessed against, through core's `assess()`. |
 
@@ -4046,7 +4047,7 @@ From `GivenProps` — the full table stands on [Given](#given).
 | [`id`](#given) | `string` | — | Makes the quantity referable: `<Ref to>` stands for it elsewhere. Needed only for a quantity used more than once. From `QuantityProps`. |
 | [`unit`](#given) | `string` | — | A label written after the number - "min", "pcs", "€". Never converted and never checked; the calculation does no unit algebra. From `QuantityProps`. |
 | [`format`](#given) | `"percent"` | — | `percent` presents a plain ratio as per cent: 0.916 is shown as 91.6 %. The quantity stays a ratio in every operation. From `QuantityProps`. |
-| [`decimals`](#given) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. From `QuantityProps`. |
+| [`decimals`](#given) | `number` | one digit for a percentage, at most two for a derived number, a given as it was given | Fixed number of fraction digits as shown. Rounding happens only in presentation; every operation uses the full value. The places carry down to operands of the same `unit` and `format` that set none of their own. From `QuantityProps`. |
 | [`target`](#given) | `number` | — | The value this quantity is meant to reach - missed, never violated. From `QuantityProps`. |
 | [`limits`](#given) | `readonly `[`Limit`](#given)`[]` | — | Bounds the quantity is assessed against, through core's `assess()`. From `QuantityProps`. |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umriss-ui/calculation",
-  "version": "0.41.1",
+  "version": "0.43.0",
   "description": "React calculation view for data-dense applications - a derivation written as it is shown, evaluated by the library, folded and read line by line.",
   "license": "MIT",
   "author": "Roman Händler",
@@ -47,7 +47,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/calculation.js"
+      "import": "./dist/calculation.js",
+      "default": "./dist/calculation.js"
     },
     "./styles.css": {
       "types": "./dist/styles.d.ts",
@@ -55,9 +56,9 @@
     }
   },
   "peerDependencies": {
+    "@umriss-ui/core": "^0.43.0",
     "react": ">=19",
-    "react-dom": ">=19",
-    "@umriss-ui/core": "^0.41.1"
+    "react-dom": ">=19"
   },
   "devDependencies": {
     "@fontsource/geist-mono": "^5.3.0",
@@ -71,7 +72,7 @@
     "typescript": "^5.6.3",
     "vite": "^6.0.0",
     "vite-plugin-dts": "^4.3.0",
-    "@umriss-ui/core": "0.41.1",
+    "@umriss-ui/core": "0.43.0",
     "@umriss-ui/demo": "0.0.0"
   },
   "scripts": {
@@ -86,6 +87,6 @@
     "check:site": "pnpm run props -- --check",
     "preview:demo": "vite preview --config vite.demo.config.ts --port 4177 --strictPort",
     "test:unit": "vitest run",
-    "check:dist": "node --disable-warning=ExperimentalWarning --experimental-strip-types ../../scripts/check-dist.ts calculation.js calculation.css"
+    "check:dist": "node --disable-warning=ExperimentalWarning --experimental-strip-types ../../scripts/check-dist.ts calculation.js calculation.css calculation.client.js"
   }
 }