@cs-object/react 0.1.0

package/dist/index.js

@@ -0,0 +1,2194 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/formula-sheet/tokens.ts
+var headerTextClass = "font-['Plus_Jakarta_Sans'] text-[12px] text-black/50";
+var valueTextClass = "font-['KaTeX_Main'] text-[16.335px]";
+var FORMULA_SHEET_SPACER_CELL_CLASS = "w-[1.5%] p-[3px]";
+var FORMULA_SHEET_DESCRIPTION_CELL_CLASS = `flex w-[37%] flex-col justify-start py-[3px] ${headerTextClass}`;
+var FORMULA_SHEET_COMMENT_CELL_CLASS = `flex w-[23.5%] flex-col justify-start py-[3px] text-right ${headerTextClass}`;
+var FORMULA_SHEET_SYMBOL_CELL_BASE_CLASS = "flex w-[14%] min-w-[14%] items-center justify-end overflow-visible border-r border-gray-300";
+var FORMULA_SHEET_SYMBOL_CELL_HEADER_CLASS = `p-[3px] ${headerTextClass}`;
+var FORMULA_SHEET_SYMBOL_CELL_VALUE_CLASS = `p-[3px] pr-[5px] ${valueTextClass}`;
+var FORMULA_SHEET_VALUE_CELL_BASE_CLASS = "flex w-[14.5%] items-center justify-end border-r border-gray-300";
+var FORMULA_SHEET_VALUE_CELL_HEADER_CLASS = `p-[3px] ${headerTextClass}`;
+var FORMULA_SHEET_VALUE_CELL_VALUE_CLASS = `p-[3px] ${valueTextClass}`;
+var FORMULA_SHEET_UNIT_CELL_BASE_CLASS = "flex w-[9.5%] items-center overflow-hidden";
+var FORMULA_SHEET_UNIT_CELL_HEADER_CLASS = `p-[3px] ${headerTextClass}`;
+var FORMULA_SHEET_UNIT_CELL_VALUE_CLASS = "p-[5px]";
+
+// src/formula-sheet/cells/FormulaSheetCommentCell.tsx
+import { jsx } from "react/jsx-runtime";
+var FormulaSheetCommentCell = ({
+  children,
+  className = ""
+}) => {
+  return /* @__PURE__ */ jsx("div", { className: `${FORMULA_SHEET_COMMENT_CELL_CLASS} ${className}`, children });
+};
+
+// src/formula-sheet/cells/FormulaSheetDescriptionCell.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var FormulaSheetDescriptionCell = ({
+  children,
+  className = ""
+}) => {
+  return /* @__PURE__ */ jsx2("div", { className: `${FORMULA_SHEET_DESCRIPTION_CELL_CLASS} ${className}`, children });
+};
+
+// src/formula-sheet/cells/FormulaSheetSpacerCell.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var FormulaSheetSpacerCell = ({
+  className = ""
+}) => {
+  return /* @__PURE__ */ jsx3("div", { className: `${FORMULA_SHEET_SPACER_CELL_CLASS} ${className}` });
+};
+
+// src/formula-sheet/cells/FormulaSheetSymbolCell.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var FormulaSheetSymbolCell = ({
+  children,
+  className = "",
+  initColumn = false
+}) => {
+  const variantClass = initColumn ? FORMULA_SHEET_SYMBOL_CELL_HEADER_CLASS : FORMULA_SHEET_SYMBOL_CELL_VALUE_CLASS;
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      className: `${FORMULA_SHEET_SYMBOL_CELL_BASE_CLASS} ${variantClass} ${className}`,
+      children
+    }
+  );
+};
+
+// src/formula-sheet/cells/FormulaSheetUnitCell.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var FormulaSheetUnitCell = ({
+  children,
+  className = "",
+  initColumn = false
+}) => {
+  const variantClass = initColumn ? FORMULA_SHEET_UNIT_CELL_HEADER_CLASS : FORMULA_SHEET_UNIT_CELL_VALUE_CLASS;
+  return /* @__PURE__ */ jsx5(
+    "div",
+    {
+      className: `${FORMULA_SHEET_UNIT_CELL_BASE_CLASS} ${variantClass} ${className}`,
+      children
+    }
+  );
+};
+
+// src/formula-sheet/cells/FormulaSheetValueCell.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var FormulaSheetValueCell = ({
+  children,
+  className = "",
+  initColumn = false
+}) => {
+  const variantClass = initColumn ? FORMULA_SHEET_VALUE_CELL_HEADER_CLASS : FORMULA_SHEET_VALUE_CELL_VALUE_CLASS;
+  return /* @__PURE__ */ jsx6(
+    "div",
+    {
+      className: `${FORMULA_SHEET_VALUE_CELL_BASE_CLASS} ${variantClass} ${className}`,
+      children
+    }
+  );
+};
+
+// src/formula-sheet/FormulaSheetHeader.tsx
+import { jsx as jsx7, jsxs } from "react/jsx-runtime";
+var FormulaSheetHeader = () => /* @__PURE__ */ jsxs("header", { className: "min-w-0", children: [
+  /* @__PURE__ */ jsx7("h2", { className: "text-[18px] font-semibold text-black", children: "Calculations" }),
+  /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-row border-t border-gray-300", children: [
+    /* @__PURE__ */ jsx7(FormulaSheetSpacerCell, {}),
+    /* @__PURE__ */ jsx7(FormulaSheetDescriptionCell, { children: "Description" }),
+    /* @__PURE__ */ jsx7(FormulaSheetSymbolCell, { initColumn: true, children: "Symbol Name" }),
+    /* @__PURE__ */ jsx7(FormulaSheetValueCell, { initColumn: true, children: "Value" }),
+    /* @__PURE__ */ jsx7(FormulaSheetUnitCell, { initColumn: true, children: "Unit" }),
+    /* @__PURE__ */ jsx7(FormulaSheetCommentCell, { children: "Comment" })
+  ] })
+] });
+
+// src/formula-sheet/FormulaSheetItemIndex.tsx
+import { jsxs as jsxs2 } from "react/jsx-runtime";
+var FormulaSheetItemIndex = ({
+  index
+}) => {
+  return /* @__PURE__ */ jsxs2("span", { "data-formula-sheet-item-index": "true", className: "tabular-nums", children: [
+    index,
+    "."
+  ] });
+};
+
+// src/formula-sheet/FormulaSheetSectionRow.tsx
+import { jsx as jsx8, jsxs as jsxs3 } from "react/jsx-runtime";
+var FormulaSheetSectionRow = ({
+  sheetItemIndex,
+  item: section
+}) => {
+  return /* @__PURE__ */ jsx8("div", { className: "flex flex-col", children: /* @__PURE__ */ jsx8("div", { className: "block flex-1 border-t border-gray-300 px-[3mm] py-[5px] font-['Plus_Jakarta_Sans'] text-[13px] font-semibold text-black/80 min-md:px-0", children: /* @__PURE__ */ jsxs3("span", { children: [
+    /* @__PURE__ */ jsx8(FormulaSheetItemIndex, { index: sheetItemIndex }),
+    " ",
+    section.title || "Untitled Section"
+  ] }) }) });
+};
+
+// src/ascii-math/AsciiMathView.tsx
+import { parseNotation } from "@cs-object/core";
+
+// src/ascii-math/NotationMathmlView.tsx
+import { assertNever } from "@cs-object/core";
+
+// src/mathml/constants.ts
+var MATHML_FONT_SIZE = "15px";
+
+// src/ascii-math/NotationMathmlView.tsx
+import { jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
+var fenceCharacters = {
+  round: ["(", ")"],
+  square: ["[", "]"]
+};
+var flattenTransparentGroups = (expression) => expression.flatMap(
+  (node) => node.kind === "group" && node.fence === "none" ? flattenTransparentGroups(node.body) : [node]
+);
+var NotationMathmlView = (_a) => {
+  var _b = _a, {
+    expression,
+    identifierMathVariant
+  } = _b, mathProps = __objRest(_b, [
+    "expression",
+    "identifierMathVariant"
+  ]);
+  return /* @__PURE__ */ jsx9("mrow", __spreadProps(__spreadValues({}, mathProps), { children: flattenTransparentGroups(expression).map((node, index) => /* @__PURE__ */ jsx9(
+    NotationNodeMathmlView,
+    {
+      node,
+      identifierMathVariant
+    },
+    `${node.kind}-${index}`
+  )) }));
+};
+var NotationGroupMathmlView = ({
+  group,
+  identifierMathVariant
+}) => {
+  if (group.fence === "none") {
+    const nodes = flattenTransparentGroups(group.body);
+    const onlyNode = nodes[0];
+    if (nodes.length === 1 && onlyNode !== void 0) {
+      return /* @__PURE__ */ jsx9(
+        NotationNodeMathmlView,
+        {
+          node: onlyNode,
+          identifierMathVariant
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx9(
+      NotationMathmlView,
+      {
+        expression: group.body,
+        identifierMathVariant
+      }
+    );
+  }
+  const [opening, closing] = fenceCharacters[group.fence];
+  return /* @__PURE__ */ jsxs4("mrow", { children: [
+    /* @__PURE__ */ jsx9("mo", { fence: "true", children: opening }),
+    /* @__PURE__ */ jsx9(
+      NotationMathmlView,
+      {
+        expression: group.body,
+        identifierMathVariant
+      }
+    ),
+    /* @__PURE__ */ jsx9("mo", { fence: "true", children: closing })
+  ] });
+};
+var NotationNodeMathmlView = ({
+  node,
+  identifierMathVariant
+}) => {
+  const renderNode = (child) => /* @__PURE__ */ jsx9(
+    NotationNodeMathmlView,
+    {
+      node: child,
+      identifierMathVariant
+    }
+  );
+  switch (node.kind) {
+    case "identifier":
+      return /* @__PURE__ */ jsx9("mi", { mathvariant: identifierMathVariant, children: node.value });
+    case "number":
+      return /* @__PURE__ */ jsx9("mn", { children: node.value });
+    case "operator":
+      return /* @__PURE__ */ jsx9("mo", { children: node.value });
+    case "text":
+      return /* @__PURE__ */ jsx9("mtext", { children: node.value });
+    case "group":
+      return /* @__PURE__ */ jsx9(
+        NotationGroupMathmlView,
+        {
+          group: node,
+          identifierMathVariant
+        }
+      );
+    case "fraction":
+      return /* @__PURE__ */ jsxs4("mfrac", { children: [
+        /* @__PURE__ */ jsx9("mstyle", { style: { fontSize: MATHML_FONT_SIZE }, children: renderNode(node.numerator) }),
+        /* @__PURE__ */ jsx9("mstyle", { style: { fontSize: MATHML_FONT_SIZE }, children: renderNode(node.denominator) })
+      ] });
+    case "subscript":
+      return /* @__PURE__ */ jsxs4("msub", { children: [
+        renderNode(node.base),
+        renderNode(node.subscript)
+      ] });
+    case "superscript":
+      return /* @__PURE__ */ jsxs4("msup", { children: [
+        renderNode(node.base),
+        renderNode(node.superscript)
+      ] });
+    case "subsup":
+      return /* @__PURE__ */ jsxs4("msubsup", { children: [
+        renderNode(node.base),
+        renderNode(node.subscript),
+        renderNode(node.superscript)
+      ] });
+    default:
+      return assertNever(node);
+  }
+};
+
+// src/ascii-math/AsciiMathView.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var AsciiMathView = (_a) => {
+  var _b = _a, {
+    expression,
+    identifierMathVariant,
+    optional
+  } = _b, mathProps = __objRest(_b, [
+    "expression",
+    "identifierMathVariant",
+    "optional"
+  ]);
+  const parsed = parseNotation(expression);
+  if (!parsed.ok) {
+    return /* @__PURE__ */ jsx10("mi", __spreadProps(__spreadValues({ mathcolor: "red" }, mathProps), { children: optional && expression.length === 0 ? "" : "?" }));
+  }
+  return /* @__PURE__ */ jsx10(
+    NotationMathmlView,
+    __spreadValues({
+      expression: parsed.value,
+      identifierMathVariant
+    }, mathProps)
+  );
+};
+
+// src/mathml/props.ts
+var defaultMathBlockProps = {
+  style: {
+    // fontFamily: 'Latin Modern Math',
+    fontSize: MATHML_FONT_SIZE,
+    display: "inline-flex",
+    flexWrap: "wrap",
+    rowGap: "15px",
+    borderWidth: "0px",
+    borderColor: "#FFFFFF",
+    mathStyle: "normal"
+  }
+};
+
+// src/mathml/GlyphMathBlock.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+var GlyphMathBlock = (_a) => {
+  var _b = _a, {
+    glyph,
+    mathProps
+  } = _b, props = __objRest(_b, [
+    "glyph",
+    "mathProps"
+  ]);
+  return /* @__PURE__ */ jsx11("math", __spreadProps(__spreadValues(__spreadValues({}, defaultMathBlockProps), mathProps), { children: /* @__PURE__ */ jsx11(AsciiMathView, __spreadValues({ expression: glyph }, props)) }));
+};
+
+// src/mathml/UnitMathBlock.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+var UnitMathBlock = ({
+  unit,
+  mathProps,
+  optional
+}) => /* @__PURE__ */ jsx12("math", __spreadProps(__spreadValues(__spreadValues({}, defaultMathBlockProps), mathProps), { children: /* @__PURE__ */ jsx12(
+  AsciiMathView,
+  {
+    expression: unit,
+    identifierMathVariant: "normal",
+    optional
+  }
+) }));
+
+// src/formula-sheet/FormulaSheetSymbolRow.tsx
+import { getValueNodeByKey as getValueNodeByKey2 } from "@cs-object/core";
+
+// src/formula-sheet/FormulaSheetResultCell.tsx
+import {
+  isSheetLiteralEmpty,
+  sheetLiteralToDisplayString
+} from "@cs-object/core";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var FormulaSheetResultCell = ({
+  literal
+}) => {
+  const formattedValue = sheetLiteralToDisplayString(literal);
+  return /* @__PURE__ */ jsx13(FormulaSheetValueCell, { children: isSheetLiteralEmpty(literal) ? /* @__PURE__ */ jsx13("span", { className: "rounded-sm bg-orange-500 px-1.5 py-0 text-black opacity-70", children: "NaN" }) : formattedValue });
+};
+
+// src/formula-sheet/FormulaSheetValueTree.tsx
+import {
+  SheetOperatorPriority,
+  getFunctionBinaryOperatorById as getFunctionBinaryOperatorById2
+} from "@cs-object/core";
+
+// src/mathml/symbol-value/ValueTreeMathmlRenderer.tsx
+import {
+  emptyLiteral,
+  getFunctionBinaryOperatorById,
+  getFunctionSpec,
+  getSymbolById as getSymbolById2,
+  getValueNodeByKey,
+  getValueNodeByKeyOrUndefined
+} from "@cs-object/core";
+
+// src/mathml/function-renderers.tsx
+import { jsx as jsx14, jsxs as jsxs5 } from "react/jsx-runtime";
+var baseStyle = { fontSize: MATHML_FONT_SIZE, textAlign: "left" };
+var fontSizeStyle = { fontSize: MATHML_FONT_SIZE };
+var ConditionalFunctionMathml = ({
+  argCnd,
+  argTrue,
+  argFalse
+}) => {
+  return /* @__PURE__ */ jsxs5("mrow", { style: baseStyle, children: [
+    /* @__PURE__ */ jsx14("mo", { style: fontSizeStyle, children: "{" }),
+    /* @__PURE__ */ jsxs5("mtable", { columnalign: "left", style: baseStyle, children: [
+      /* @__PURE__ */ jsxs5("mtr", { style: fontSizeStyle, children: [
+        /* @__PURE__ */ jsx14("mtd", { style: __spreadProps(__spreadValues({}, baseStyle), { paddingRight: "0.5em" }), children: argTrue }),
+        /* @__PURE__ */ jsxs5("mtd", { style: baseStyle, children: [
+          /* @__PURE__ */ jsx14("mtext", { style: fontSizeStyle, children: "if " }),
+          /* @__PURE__ */ jsx14("mspace", { width: "5px" }),
+          argCnd
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs5("mtr", { style: fontSizeStyle, children: [
+        /* @__PURE__ */ jsx14("mtd", { style: __spreadProps(__spreadValues({}, baseStyle), { paddingRight: "0.5em" }), children: argFalse }),
+        /* @__PURE__ */ jsx14("mtd", { style: baseStyle, children: /* @__PURE__ */ jsx14("mtext", { style: fontSizeStyle, children: "otherwise." }) })
+      ] })
+    ] })
+  ] });
+};
+var FractionFunctionMathml = ({
+  numerator,
+  denominator
+}) => {
+  return /* @__PURE__ */ jsxs5("mfrac", { children: [
+    /* @__PURE__ */ jsx14("mstyle", { style: { fontSize: MATHML_FONT_SIZE }, children: numerator }),
+    /* @__PURE__ */ jsx14("mstyle", { style: { fontSize: MATHML_FONT_SIZE }, children: denominator })
+  ] });
+};
+var PowerFunctionMathml = ({
+  base,
+  exponent
+}) => {
+  return /* @__PURE__ */ jsxs5("msup", { children: [
+    /* @__PURE__ */ jsx14("mstyle", { style: { fontSize: MATHML_FONT_SIZE }, children: base }),
+    /* @__PURE__ */ jsx14("mstyle", { style: { scale: "0.8" }, children: exponent })
+  ] });
+};
+var SquareRootFunctionMathml = ({
+  value
+}) => {
+  return /* @__PURE__ */ jsx14("msqrt", { children: /* @__PURE__ */ jsx14("mstyle", { style: { padding: "3px", fontSize: MATHML_FONT_SIZE }, children: value }) });
+};
+var AbsoluteValueFunctionMathml = ({
+  value
+}) => {
+  return /* @__PURE__ */ jsxs5("mrow", { style: fontSizeStyle, children: [
+    /* @__PURE__ */ jsx14("mo", { fence: "true", stretchy: "true", children: "|" }),
+    value,
+    /* @__PURE__ */ jsx14("mo", { fence: "true", stretchy: "true", children: "|" })
+  ] });
+};
+var UnaryMinusFunctionMathml = ({
+  value
+}) => {
+  return /* @__PURE__ */ jsxs5("mrow", { style: { fontSize: MATHML_FONT_SIZE }, children: [
+    /* @__PURE__ */ jsx14("mo", { style: { fontSize: MATHML_FONT_SIZE }, children: "-" }),
+    value
+  ] });
+};
+var renderSpecialValueFunction = ({
+  functionId,
+  argReactNodes
+}) => {
+  if (functionId === "fg.abs" && argReactNodes.length === 1) {
+    return /* @__PURE__ */ jsx14(AbsoluteValueFunctionMathml, { value: argReactNodes[0] });
+  }
+  if (functionId === "fg.sqrt" && argReactNodes.length === 1) {
+    return /* @__PURE__ */ jsx14(SquareRootFunctionMathml, { value: argReactNodes[0] });
+  }
+  if (functionId === "fg.uminus" && argReactNodes.length === 1) {
+    return /* @__PURE__ */ jsx14(UnaryMinusFunctionMathml, { value: argReactNodes[0] });
+  }
+  if (functionId === "fg.cnd" && argReactNodes.length === 3) {
+    return /* @__PURE__ */ jsx14(
+      ConditionalFunctionMathml,
+      {
+        argCnd: argReactNodes[0],
+        argTrue: argReactNodes[1],
+        argFalse: argReactNodes[2]
+      }
+    );
+  }
+  if (functionId === "fg.divide" && argReactNodes.length === 2) {
+    return /* @__PURE__ */ jsx14(
+      FractionFunctionMathml,
+      {
+        numerator: argReactNodes[0],
+        denominator: argReactNodes[1]
+      }
+    );
+  }
+  if (functionId === "fg.pow" && argReactNodes.length === 2) {
+    return /* @__PURE__ */ jsx14(
+      PowerFunctionMathml,
+      {
+        base: argReactNodes[0],
+        exponent: argReactNodes[1]
+      }
+    );
+  }
+  return void 0;
+};
+
+// src/mathml/symbol-value/components.tsx
+import { assertNever as assertNever2, formatNumerical } from "@cs-object/core";
+import { isValidElement } from "react";
+import { Fragment, jsx as jsx15, jsxs as jsxs6 } from "react/jsx-runtime";
+var isDraftPositionValid = ({
+  draft,
+  position
+}) => {
+  return !Number.isNaN(position) && position >= 0 && position <= draft.length;
+};
+var stableReactNodeKey = (node) => {
+  var _a, _b;
+  if (node === null) {
+    return "null";
+  }
+  if (node === void 0) {
+    return "undefined";
+  }
+  if (typeof node === "string" || typeof node === "number") {
+    return String(node);
+  }
+  if (typeof node === "boolean") {
+    return node ? "true" : "false";
+  }
+  if (isValidElement(node)) {
+    if (node.key != null) {
+      return String(node.key);
+    }
+    if (typeof node.type === "string") {
+      return node.type;
+    }
+    const maybeNamed = node.type;
+    return (_b = (_a = maybeNamed.displayName) != null ? _a : maybeNamed.name) != null ? _b : "component";
+  }
+  return "node";
+};
+var SymbolValueRootMathmlView = ({
+  children
+}) => {
+  return /* @__PURE__ */ jsx15("math", { children: children != null ? children : "Tree Without Root" });
+};
+var SymbolValueDraftMathmlView = ({
+  draft,
+  position
+}) => {
+  const textStyle = { fontSize: MATHML_FONT_SIZE };
+  return position !== void 0 && isDraftPositionValid({ draft, position }) ? /* @__PURE__ */ jsxs6("mrow", { style: { fontSize: MATHML_FONT_SIZE }, children: [
+    position > 0 && /* @__PURE__ */ jsx15("mtext", { style: textStyle, children: draft.substring(0, position) }),
+    position < draft.length && /* @__PURE__ */ jsx15("mtext", { style: textStyle, children: draft.substring(position) })
+  ] }) : /* @__PURE__ */ jsx15("mrow", { style: { fontSize: MATHML_FONT_SIZE }, children: /* @__PURE__ */ jsx15("mtext", { style: textStyle, children: draft }) });
+};
+var SymbolValueLiteralMathmlView = ({
+  literal
+}) => {
+  const mathProps = {
+    style: { fontSize: MATHML_FONT_SIZE }
+  };
+  switch (literal == null ? void 0 : literal.kind) {
+    case void 0:
+    case "empty":
+      return /* @__PURE__ */ jsx15("mi", __spreadProps(__spreadValues({}, mathProps), { children: "\u25A2" }));
+    case "boolean":
+      return /* @__PURE__ */ jsx15("mi", __spreadProps(__spreadValues({}, mathProps), { children: literal.value ? "true" : "false" }));
+    case "number":
+      return /* @__PURE__ */ jsx15("mn", __spreadProps(__spreadValues({}, mathProps), { children: formatNumerical(literal.value) }));
+    case "string":
+      return /* @__PURE__ */ jsx15("mtext", __spreadProps(__spreadValues({}, mathProps), { children: literal.value }));
+    default:
+      return assertNever2(literal);
+  }
+};
+var SymbolValueGlyphMathmlView = ({
+  glyph
+}) => {
+  const mathProps = {};
+  return /* @__PURE__ */ jsx15(AsciiMathView, __spreadValues({ expression: glyph }, mathProps));
+};
+var SymbolValueGroupMathmlView = ({
+  prefix,
+  children,
+  cursor,
+  empty = "omit"
+}) => {
+  const mathProps = {
+    mathbackground: cursor ? "lightgray" : void 0
+  };
+  return /* @__PURE__ */ jsxs6("mrow", __spreadProps(__spreadValues({}, mathProps), { children: [
+    prefix,
+    (children.length > 0 || empty === "fence") && /* @__PURE__ */ jsxs6(Fragment, { children: [
+      /* @__PURE__ */ jsx15("mo", { fence: "true", children: "(" }),
+      children.flatMap((child, argIndex, arr) => {
+        const next = arr[argIndex + 1];
+        const separatorKey = `sep-${stableReactNodeKey(child)}-to-${stableReactNodeKey(next)}`;
+        return [
+          child,
+          ...argIndex < arr.length - 1 ? [
+            /* @__PURE__ */ jsx15("mo", { separator: "true", children: "," }, separatorKey)
+          ] : []
+        ];
+      }),
+      /* @__PURE__ */ jsx15("mo", { fence: "true", children: ")" })
+    ] })
+  ] }));
+};
+var SymbolValueBinaryOperatorMathmlView = ({
+  operator,
+  argLeft,
+  argRight
+}) => {
+  const spacing = operator.id === "fg.and" || operator.id === "fg.or" ? "0.3em" : void 0;
+  return /* @__PURE__ */ jsxs6("mrow", { children: [
+    argLeft,
+    /* @__PURE__ */ jsx15("mo", { lspace: spacing, rspace: spacing, children: operator.glyph }),
+    argRight
+  ] });
+};
+
+// src/mathml/symbol-value/literal-display.ts
+import { isSheetLiteralEmpty as isSheetLiteralEmpty2 } from "@cs-object/core";
+var displayedLiteralDraft = ({
+  node,
+  literalsAsDrafts
+}) => {
+  var _a;
+  return (literalsAsDrafts || isSheetLiteralEmpty2(node.value)) && ((_a = node.draft) != null ? _a : "").length > 0 ? node.draft : void 0;
+};
+
+// src/mathml/symbol-value/operand-grouping.ts
+import {
+  getSymbolById
+} from "@cs-object/core";
+var requiresExplicitOperandGroup = ({
+  sheet,
+  node,
+  numerical,
+  literalsAsDrafts,
+  parentFunctionId,
+  argumentIndex
+}) => {
+  var _a;
+  let literal;
+  let draft;
+  switch (node.kind) {
+    case "literal":
+      draft = displayedLiteralDraft({ node, literalsAsDrafts });
+      literal = node.value;
+      break;
+    case "symbol":
+      literal = numerical ? (_a = getSymbolById(sheet, node.symbolId)) == null ? void 0 : _a.valueTree.result : void 0;
+      break;
+    case "function":
+      break;
+    default: {
+      const exhaustive = node;
+      return exhaustive;
+    }
+  }
+  const negative = draft !== void 0 ? /^\s*[-−]/u.test(draft) : (literal == null ? void 0 : literal.kind) === "number" && (literal.value < 0 || Object.is(literal.value, -0));
+  return argumentIndex === 0 && (parentFunctionId === "fg.pow" && (node.kind === "function" || negative) || parentFunctionId === "fg.uminus" && node.kind === "function") || argumentIndex === 1 && (parentFunctionId === "fg.add" || parentFunctionId === "fg.multiply" || parentFunctionId === "fg.subtract") && (negative || node.kind === "function" && node.functionId === "fg.uminus");
+};
+
+// src/mathml/symbol-value/ValueTreeMathmlRenderer.tsx
+import { Fragment as Fragment2, jsx as jsx16, jsxs as jsxs7 } from "react/jsx-runtime";
+var ValueTreeMathmlRenderer = ({
+  sheet,
+  valueTree,
+  viewOptions,
+  noRootContainer
+}) => {
+  const rootNode = getValueNodeByKeyOrUndefined(valueTree, valueTree.rootKey);
+  if (!rootNode) {
+    return /* @__PURE__ */ jsx16(Fragment2, { children: "Empty Value" });
+  }
+  const rootValue = /* @__PURE__ */ jsx16(
+    ValueTreeNodeMathmlView,
+    {
+      sheet,
+      valueTree,
+      node: rootNode,
+      viewOptions
+    }
+  );
+  return noRootContainer ? rootValue : /* @__PURE__ */ jsx16(SymbolValueRootMathmlView, { children: rootValue });
+};
+var ValueTreeNodeMathmlView = ({
+  sheet,
+  valueTree,
+  node,
+  viewOptions
+}) => {
+  var _a;
+  if (node.kind === "literal") {
+    const draft = displayedLiteralDraft({
+      node,
+      literalsAsDrafts: viewOptions.literalsAsDrafts
+    });
+    if (draft !== void 0) {
+      return /* @__PURE__ */ jsx16(SymbolValueDraftMathmlView, { draft });
+    }
+    return /* @__PURE__ */ jsx16(SymbolValueLiteralMathmlView, { literal: node.value });
+  }
+  if (node.kind === "symbol") {
+    const nodeSymbol = getSymbolById2(sheet, node.symbolId);
+    if (!viewOptions.numerical) {
+      return /* @__PURE__ */ jsx16(SymbolValueGlyphMathmlView, { glyph: (nodeSymbol == null ? void 0 : nodeSymbol.glyph) || "" });
+    }
+    return /* @__PURE__ */ jsx16(
+      SymbolValueLiteralMathmlView,
+      {
+        literal: (_a = nodeSymbol == null ? void 0 : nodeSymbol.valueTree.result) != null ? _a : emptyLiteral()
+      }
+    );
+  }
+  if (node.kind === "function") {
+    return /* @__PURE__ */ jsx16(
+      ValueTreeFunctionMathmlView,
+      {
+        sheet,
+        valueTree,
+        node,
+        viewOptions
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx16(Fragment2, { children: "Error (Unknown value-tree node)" });
+};
+var ValueTreeFunctionMathmlView = ({
+  sheet,
+  valueTree,
+  node,
+  viewOptions
+}) => {
+  if (node.kind !== "function") {
+    return /* @__PURE__ */ jsx16(Fragment2, { children: "Error (Expected function value-tree node)" });
+  }
+  const argNodes = node.argKeys.map(
+    (argKey) => getValueNodeByKey(valueTree, argKey)
+  );
+  const argReactNodes = argNodes.map((argNode, index) => {
+    const rendered = /* @__PURE__ */ jsx16(
+      ValueTreeNodeMathmlView,
+      {
+        sheet,
+        valueTree,
+        node: argNode,
+        viewOptions
+      },
+      argNode.key
+    );
+    const grouped = requiresExplicitOperandGroup({
+      sheet,
+      node: argNode,
+      numerical: Boolean(viewOptions.numerical),
+      literalsAsDrafts: Boolean(viewOptions.literalsAsDrafts),
+      parentFunctionId: node.functionId,
+      argumentIndex: index
+    });
+    return grouped ? /* @__PURE__ */ jsx16(SymbolValueGroupMathmlView, { cursor: void 0, children: [rendered] }, argNode.key) : rendered;
+  });
+  const specialFunction = renderSpecialValueFunction({
+    functionId: node.functionId,
+    argReactNodes
+  });
+  if (specialFunction) {
+    return specialFunction;
+  }
+  const operator = getFunctionBinaryOperatorById(node.functionId);
+  if (operator && argNodes.length > 2 && (node.functionId === "fg.and" || node.functionId === "fg.or")) {
+    return /* @__PURE__ */ jsx16("mrow", { children: argReactNodes.map((argument, index) => {
+      const child = argNodes[index];
+      const childOperator = child.kind === "function" ? getFunctionBinaryOperatorById(child.functionId) : void 0;
+      const grouped = childOperator !== void 0 && childOperator.priority < operator.priority;
+      return /* @__PURE__ */ jsxs7("mrow", { children: [
+        index > 0 && /* @__PURE__ */ jsx16("mo", { form: "infix", lspace: "0.3em", rspace: "0.3em", children: operator.glyph }),
+        grouped ? /* @__PURE__ */ jsx16(SymbolValueGroupMathmlView, { cursor: void 0, children: [argument] }) : argument
+      ] }, child.key);
+    }) });
+  }
+  if (operator && argNodes.length === 2) {
+    const [argOperatorLeft, argOperatorRight] = argNodes.map(
+      (argNode) => argNode.kind === "function" ? getFunctionBinaryOperatorById(argNode.functionId) : void 0
+    );
+    const implicitParenthesisLeft = argOperatorLeft && argOperatorLeft.priority < operator.priority;
+    const implicitParenthesisRight = argOperatorRight && argOperatorRight.priority <= operator.priority;
+    const argLeft = implicitParenthesisLeft ? /* @__PURE__ */ jsx16(SymbolValueGroupMathmlView, { cursor: void 0, children: [argReactNodes[0]] }) : argReactNodes[0];
+    const argRight = implicitParenthesisRight ? /* @__PURE__ */ jsx16(SymbolValueGroupMathmlView, { cursor: void 0, children: [argReactNodes[1]] }) : argReactNodes[1];
+    return /* @__PURE__ */ jsx16(
+      SymbolValueBinaryOperatorMathmlView,
+      {
+        operator,
+        argLeft,
+        argRight
+      }
+    );
+  }
+  const nodeFunction = getFunctionSpec(node.functionId);
+  const functionNameGlyph = (nodeFunction == null ? void 0 : nodeFunction.glyph) || "";
+  const groupPrefix = node.functionId === "fg.noop" ? "" : node.functionId === "fg.stub" ? /* @__PURE__ */ jsx16(SymbolValueDraftMathmlView, { draft: "" }) : /* @__PURE__ */ jsx16(SymbolValueGlyphMathmlView, { glyph: functionNameGlyph });
+  return /* @__PURE__ */ jsx16(
+    SymbolValueGroupMathmlView,
+    {
+      prefix: groupPrefix,
+      cursor: void 0,
+      empty: node.functionId === "fg.pi" || node.functionId === "fg.noop" || node.functionId === "fg.stub" ? "omit" : "fence",
+      children: node.argKeys.map((key) => getValueNodeByKey(valueTree, key)).map((argNode) => /* @__PURE__ */ jsx16(
+        ValueTreeNodeMathmlView,
+        {
+          sheet,
+          valueTree,
+          node: argNode,
+          viewOptions
+        },
+        `${argNode.key}`
+      ))
+    }
+  );
+};
+
+// src/mathml/symbol-value/SymbolValueMathmlView.tsx
+import { jsx as jsx17 } from "react/jsx-runtime";
+var SymbolValueMathmlView = ({
+  sheet,
+  valueTree,
+  viewOptions,
+  noRootContainer
+}) => {
+  return /* @__PURE__ */ jsx17(
+    ValueTreeMathmlRenderer,
+    {
+      sheet,
+      valueTree,
+      viewOptions,
+      noRootContainer
+    }
+  );
+};
+
+// src/mathml/SymbolValueMathBlock.tsx
+import { jsx as jsx18, jsxs as jsxs8 } from "react/jsx-runtime";
+var SymbolValueMathBlock = ({
+  sheet,
+  symbol,
+  mathProps,
+  showGlyph,
+  showSymbolic,
+  showNumeric
+}) => {
+  var _a, _b;
+  const baseMathProps = __spreadProps(__spreadValues(__spreadValues({}, defaultMathBlockProps), mathProps), {
+    // Use MathML display attribute (not CSS) for cross-browser compatibility
+    display: "inline",
+    style: __spreadProps(__spreadValues(__spreadValues({}, defaultMathBlockProps.style), mathProps == null ? void 0 : mathProps.style), {
+      // Remove CSS display since we're using MathML display attribute
+      display: void 0,
+      fontSize: ((_a = defaultMathBlockProps.style) == null ? void 0 : _a.fontSize) || ((_b = mathProps == null ? void 0 : mathProps.style) == null ? void 0 : _b.fontSize) || MATHML_FONT_SIZE
+    })
+  });
+  const divProps = {
+    style: {
+      display: "inline-flex",
+      alignItems: "flex-start",
+      margin: "5px 0px",
+      minWidth: "0",
+      flexShrink: "0"
+    }
+  };
+  return /* @__PURE__ */ jsxs8("div", { children: [
+    showGlyph && /* @__PURE__ */ jsx18("div", __spreadProps(__spreadValues({}, divProps), { children: /* @__PURE__ */ jsx18("math", __spreadProps(__spreadValues({}, baseMathProps), { children: /* @__PURE__ */ jsx18("mrow", { children: /* @__PURE__ */ jsx18(AsciiMathView, { expression: symbol.glyph }) }) })) })),
+    showSymbolic && showGlyph && /* @__PURE__ */ jsx18("div", __spreadProps(__spreadValues({}, divProps), { children: /* @__PURE__ */ jsx18("math", __spreadProps(__spreadValues({}, baseMathProps), { children: /* @__PURE__ */ jsx18("mrow", { children: /* @__PURE__ */ jsx18("mo", { className: "px-1 py-2", children: "=" }) }) })) })),
+    showSymbolic && /* @__PURE__ */ jsx18("div", __spreadProps(__spreadValues({}, divProps), { children: /* @__PURE__ */ jsx18("math", __spreadProps(__spreadValues({}, baseMathProps), { children: /* @__PURE__ */ jsx18("mrow", { children: /* @__PURE__ */ jsx18(
+      SymbolValueMathmlView,
+      {
+        sheet,
+        valueTree: symbol.valueTree,
+        noRootContainer: true,
+        viewOptions: { literalsAsDrafts: true }
+      }
+    ) }) })) })),
+    showNumeric && (showGlyph || showSymbolic) && /* @__PURE__ */ jsx18("div", __spreadProps(__spreadValues({}, divProps), { children: /* @__PURE__ */ jsx18("math", __spreadProps(__spreadValues({}, baseMathProps), { children: /* @__PURE__ */ jsx18("mrow", { children: /* @__PURE__ */ jsx18("mo", { className: "px-1 py-2", children: "=" }) }) })) })),
+    showNumeric && /* @__PURE__ */ jsx18("div", __spreadProps(__spreadValues({}, divProps), { children: /* @__PURE__ */ jsx18("math", __spreadProps(__spreadValues({}, baseMathProps), { children: /* @__PURE__ */ jsx18("mrow", { children: /* @__PURE__ */ jsx18(
+      SymbolValueMathmlView,
+      {
+        sheet,
+        valueTree: symbol.valueTree,
+        noRootContainer: true,
+        viewOptions: { numerical: true, literalsAsDrafts: true }
+      }
+    ) }) })) }))
+  ] });
+};
+
+// src/formula-sheet/FormulaSheetValueTree.tsx
+import { jsx as jsx19, jsxs as jsxs9 } from "react/jsx-runtime";
+var additionTerms = (tree, key, ancestors = /* @__PURE__ */ new Set()) => {
+  if (ancestors.has(key)) {
+    throw new Error(`Recursive formula node '${key}'`);
+  }
+  const node = tree.nodes.find((node2) => node2.key === key);
+  if ((node == null ? void 0 : node.kind) !== "function" || node.functionId !== "fg.add" || node.argKeys.length !== 2) {
+    return [key];
+  }
+  const [left, right] = node.argKeys;
+  if (!(left && right)) {
+    return [key];
+  }
+  return [...additionTerms(tree, left, /* @__PURE__ */ new Set([...ancestors, key])), right];
+};
+var hasActiveSymbol = (tree) => {
+  const nodes = new Map(tree.nodes.map((node) => [node.key, node]));
+  const pending = [tree.rootKey];
+  const visited = /* @__PURE__ */ new Set();
+  while (pending.length > 0) {
+    const key = pending.pop();
+    if (key === void 0 || visited.has(key)) continue;
+    visited.add(key);
+    const node = nodes.get(key);
+    if ((node == null ? void 0 : node.kind) === "symbol") return true;
+    if ((node == null ? void 0 : node.kind) === "function") pending.push(...node.argKeys);
+  }
+  return false;
+};
+var FormulaSheetValueTree = ({
+  sheet,
+  symbol
+}) => {
+  const showSymbolic = hasActiveSymbol(symbol.valueTree);
+  const terms = additionTerms(symbol.valueTree, symbol.valueTree.rootKey);
+  if (terms.length > 4) {
+    return /* @__PURE__ */ jsx19("div", { className: "cso-long-formula", children: (showSymbolic ? [false, true] : [true]).map((numerical) => (
+      // biome-ignore lint/a11y/useSemanticElements: This labels a formula group, not a fieldset of form controls.
+      /* @__PURE__ */ jsx19(
+        "div",
+        {
+          className: "cso-formula-terms",
+          role: "group",
+          "aria-label": numerical ? "Substitution" : "Formula",
+          children: terms.map((rootKey, index) => {
+            const node = symbol.valueTree.nodes.find(
+              (node2) => node2.key === rootKey
+            );
+            const operator = (node == null ? void 0 : node.kind) === "function" ? getFunctionBinaryOperatorById2(node.functionId) : void 0;
+            const grouped = operator !== void 0 && (operator.priority < SheetOperatorPriority.AddSubtract || index > 0 && operator.priority === SheetOperatorPriority.AddSubtract) || node !== void 0 && requiresExplicitOperandGroup({
+              sheet,
+              node,
+              numerical,
+              literalsAsDrafts: true,
+              parentFunctionId: "fg.add",
+              argumentIndex: index === 0 ? 0 : 1
+            });
+            return /* @__PURE__ */ jsx19("span", { className: "cso-formula-term", children: /* @__PURE__ */ jsxs9("math", { display: "inline", children: [
+              index === 0 && /* @__PURE__ */ jsx19(AsciiMathView, { expression: symbol.glyph }),
+              /* @__PURE__ */ jsx19("mo", { children: index === 0 ? "=" : "+" }),
+              grouped && /* @__PURE__ */ jsx19("mo", { children: "(" }),
+              /* @__PURE__ */ jsx19(
+                SymbolValueMathmlView,
+                {
+                  sheet,
+                  valueTree: __spreadProps(__spreadValues({}, symbol.valueTree), { rootKey }),
+                  noRootContainer: true,
+                  viewOptions: { numerical, literalsAsDrafts: true }
+                }
+              ),
+              grouped && /* @__PURE__ */ jsx19("mo", { children: ")" })
+            ] }) }, `${index}-${rootKey}`);
+          })
+        },
+        String(numerical)
+      )
+    )) });
+  }
+  return /* @__PURE__ */ jsx19(
+    SymbolValueMathBlock,
+    {
+      sheet,
+      symbol,
+      showGlyph: true,
+      showSymbolic,
+      showNumeric: true
+    }
+  );
+};
+
+// src/formula-sheet/FormulaSheetSymbolRow.tsx
+import { jsx as jsx20, jsxs as jsxs10 } from "react/jsx-runtime";
+var FormulaSheetSymbolRow = ({
+  sheet,
+  sheetItemIndex,
+  item: symbol
+}) => {
+  var _a, _b;
+  const { glyph: symbolGlyph } = symbol;
+  const symbolUnit = (_a = symbol.unit) != null ? _a : "";
+  const symbolDescription = symbol.description;
+  const symbolComment = (_b = symbol.comment) != null ? _b : "";
+  const rootNode = getValueNodeByKey2(
+    symbol.valueTree,
+    symbol.valueTree.rootKey
+  );
+  const symbolIsSolidLiteral = rootNode.kind === "literal";
+  return /* @__PURE__ */ jsx20("div", { className: "cso-symbol-row flex min-w-0 flex-col", children: /* @__PURE__ */ jsxs10("div", { className: "min-w-0", children: [
+    /* @__PURE__ */ jsxs10("div", { className: "flex min-w-0 border-t border-gray-300", children: [
+      /* @__PURE__ */ jsx20(FormulaSheetSpacerCell, {}),
+      /* @__PURE__ */ jsx20(FormulaSheetDescriptionCell, { children: /* @__PURE__ */ jsxs10("span", { children: [
+        /* @__PURE__ */ jsx20(FormulaSheetItemIndex, { index: sheetItemIndex }),
+        " ",
+        symbolDescription
+      ] }) }),
+      /* @__PURE__ */ jsx20(FormulaSheetSymbolCell, { children: /* @__PURE__ */ jsx20(
+        GlyphMathBlock,
+        {
+          glyph: symbolGlyph,
+          mathProps: { className: "shrink-0" }
+        }
+      ) }),
+      /* @__PURE__ */ jsx20(FormulaSheetResultCell, { literal: symbol.valueTree.result }),
+      /* @__PURE__ */ jsx20(FormulaSheetUnitCell, { children: /* @__PURE__ */ jsx20(UnitMathBlock, { unit: symbolUnit, optional: true }) }),
+      /* @__PURE__ */ jsx20(FormulaSheetCommentCell, { children: symbolComment || " " })
+    ] }),
+    !symbolIsSolidLiteral && /* @__PURE__ */ jsx20("div", { className: "flex min-w-0", children: /* @__PURE__ */ jsx20("div", { className: "w-full min-w-0 overflow-visible border-t border-gray-300 text-[14px]", children: /* @__PURE__ */ jsxs10("div", { className: "my-2 flex min-w-0", children: [
+      /* @__PURE__ */ jsx20(FormulaSheetSpacerCell, {}),
+      /* @__PURE__ */ jsx20("div", { className: "min-w-0 max-w-full flex-1 overflow-visible", children: /* @__PURE__ */ jsx20(FormulaSheetValueTree, { sheet, symbol }) })
+    ] }) }) })
+  ] }) });
+};
+
+// src/formula-sheet/FormulaSheetItem.tsx
+import { jsx as jsx21, jsxs as jsxs11 } from "react/jsx-runtime";
+var FormulaSheetItem = ({
+  sheet,
+  item,
+  sheetItemIndex
+}) => {
+  return /* @__PURE__ */ jsxs11("div", { className: "relative min-w-0", children: [
+    item.kind === "section" && /* @__PURE__ */ jsx21(
+      FormulaSheetSectionRow,
+      {
+        sheet,
+        sheetItemIndex,
+        item: item.section
+      }
+    ),
+    item.kind === "symbol" && /* @__PURE__ */ jsx21(
+      FormulaSheetSymbolRow,
+      {
+        sheet,
+        sheetItemIndex,
+        item: item.symbol
+      }
+    )
+  ] });
+};
+
+// src/FormulaSheet.tsx
+import {
+  getRootSectionItems
+} from "@cs-object/core";
+import { jsx as jsx22, jsxs as jsxs12 } from "react/jsx-runtime";
+var getFormulaSheetItemKey = (item, sheetItemIndex) => `${sheetItemIndex}-${item.kind}-${item.kind === "section" ? item.section.id : item.symbol.id}`;
+var FormulaSheet = ({ sheet }) => {
+  const sheetItems = getRootSectionItems(sheet);
+  return /* @__PURE__ */ jsxs12(
+    "article",
+    {
+      "data-formula-sheet": "true",
+      className: "flex min-h-[297mm] w-[210mm] min-w-[210mm] max-w-none flex-col items-stretch border border-gray-300 bg-white p-[5mm] [&_*:focus-visible]:outline-hidden",
+      children: [
+        /* @__PURE__ */ jsx22(FormulaSheetHeader, {}),
+        sheetItems.map((item, sheetItemIndex) => /* @__PURE__ */ jsx22(
+          FormulaSheetItem,
+          {
+            sheet,
+            item,
+            sheetItemIndex
+          },
+          getFormulaSheetItemKey(item, sheetItemIndex)
+        ))
+      ]
+    }
+  );
+};
+
+// src/formula-sheet/print.ts
+var DEFAULT_FORMULA_SHEET_SELECTOR = "[data-formula-sheet]";
+var FORMULA_SHEET_PRINT_BODY_CLASS = "formula-sheet-printing";
+var FORMULA_SHEET_PRINT_ROOT_ATTRIBUTE = "data-formula-sheet-print-root";
+var PRINT_CLEANUP_DELAY_MS = 1e3;
+var IMAGE_PREPARATION_TIMEOUT_MS = 15e3;
+var getBrowserPrintGlobals = () => {
+  if (typeof window === "undefined" || typeof document === "undefined" || typeof window.print !== "function" || !document.body) {
+    return void 0;
+  }
+  return { document, window };
+};
+var resolvePrintTarget = (document2, target) => {
+  var _a, _b;
+  if (typeof target === "string") {
+    return (_a = document2.querySelector(target)) != null ? _a : void 0;
+  }
+  return (_b = target != null ? target : document2.querySelector(DEFAULT_FORMULA_SHEET_SELECTOR)) != null ? _b : void 0;
+};
+var printFormulaSheet = (options = {}) => {
+  const browser = getBrowserPrintGlobals();
+  if (!browser) {
+    return false;
+  }
+  if (browser.document.querySelector(`[${FORMULA_SHEET_PRINT_ROOT_ATTRIBUTE}]`)) {
+    return false;
+  }
+  const target = resolvePrintTarget(browser.document, options.target);
+  if (!target) {
+    return false;
+  }
+  const printRoot = browser.document.createElement("div");
+  const printClone = target.cloneNode(true);
+  const originalTitle = options.title === void 0 ? void 0 : browser.document.title;
+  let cleanedUp = false;
+  let cleanupTimeout;
+  let preparationTimeout;
+  const cleanup = () => {
+    if (cleanedUp) {
+      return;
+    }
+    cleanedUp = true;
+    if (cleanupTimeout !== void 0) {
+      browser.window.clearTimeout(cleanupTimeout);
+    }
+    if (preparationTimeout !== void 0) {
+      browser.window.clearTimeout(preparationTimeout);
+    }
+    browser.window.removeEventListener("afterprint", cleanup);
+    printRoot.remove();
+    browser.document.body.classList.remove(FORMULA_SHEET_PRINT_BODY_CLASS);
+    if (originalTitle !== void 0) {
+      browser.document.title = originalTitle;
+    }
+  };
+  printRoot.setAttribute(FORMULA_SHEET_PRINT_ROOT_ATTRIBUTE, "true");
+  printRoot.appendChild(printClone);
+  browser.document.body.appendChild(printRoot);
+  browser.document.body.classList.add(FORMULA_SHEET_PRINT_BODY_CLASS);
+  if (options.title !== void 0) {
+    browser.document.title = options.title;
+  }
+  browser.window.addEventListener("afterprint", cleanup, { once: true });
+  const printReady = () => {
+    if (cleanedUp) {
+      return;
+    }
+    if (preparationTimeout !== void 0) {
+      browser.window.clearTimeout(preparationTimeout);
+    }
+    cleanupTimeout = browser.window.setTimeout(cleanup, PRINT_CLEANUP_DELAY_MS);
+    try {
+      browser.window.print();
+    } catch (error) {
+      cleanup();
+      throw error;
+    }
+  };
+  const images = Array.from(printClone.querySelectorAll("img"));
+  if (images.length === 0) {
+    printReady();
+  } else {
+    const preparationFailed = (error) => {
+      var _a;
+      if (cleanedUp) {
+        return;
+      }
+      cleanup();
+      (_a = options.onError) == null ? void 0 : _a.call(options, error);
+    };
+    preparationTimeout = browser.window.setTimeout(() => {
+      preparationFailed(
+        new Error("Image preparation timed out before printing.")
+      );
+    }, IMAGE_PREPARATION_TIMEOUT_MS);
+    void Promise.all(
+      images.map((image) => Promise.resolve().then(() => image.decode()))
+    ).then(() => {
+      var _a;
+      try {
+        printReady();
+      } catch (error) {
+        (_a = options.onError) == null ? void 0 : _a.call(options, error);
+      }
+    }, preparationFailed);
+  }
+  return true;
+};
+
+// src/PreparedFormulaSheet.tsx
+import {
+  PreparedDocumentSchema,
+  createSheetFromCalculationSourceObject
+} from "@cs-object/core";
+
+// src/EngineeringMetadata.tsx
+import { Fragment as Fragment3, jsx as jsx23, jsxs as jsxs13 } from "react/jsx-runtime";
+var ContextValue = ({
+  value
+}) => {
+  switch (value.kind) {
+    case "text":
+      return /* @__PURE__ */ jsx23("span", { "data-engineering-value": value.path, children: String(value.value) });
+    case "math":
+      return /* @__PURE__ */ jsx23(
+        "span",
+        {
+          "data-engineering-value": value.path,
+          "data-engineering-notation": "math",
+          "data-engineering-source": value.value,
+          children: /* @__PURE__ */ jsx23(GlyphMathBlock, { glyph: value.value })
+        }
+      );
+    case "list":
+      return /* @__PURE__ */ jsx23("ul", { children: value.items.map((item, index) => (
+        // biome-ignore lint/suspicious/noArrayIndexKey: prepared order identifies repeated entries
+        /* @__PURE__ */ jsx23("li", { children: /* @__PURE__ */ jsx23(ContextValue, { value: item }) }, index)
+      )) });
+    case "record":
+      return /* @__PURE__ */ jsx23("dl", { children: value.entries.map((entry) => /* @__PURE__ */ jsxs13("div", { children: [
+        /* @__PURE__ */ jsx23("dt", { children: entry.label }),
+        /* @__PURE__ */ jsx23("dd", { children: /* @__PURE__ */ jsx23(ContextValue, { value: entry.value }) })
+      ] }, entry.label)) });
+    default: {
+      const exhaustive = value;
+      return exhaustive;
+    }
+  }
+};
+var EngineeringMetadata = ({
+  entries,
+  subject
+}) => entries.length > 0 ? /* @__PURE__ */ jsx23("dl", { className: "cso-engineering-context", children: entries.map(({ label, path, value }) => /* @__PURE__ */ jsxs13("div", { "data-engineering-field": path, children: [
+  /* @__PURE__ */ jsxs13("dt", { children: [
+    subject && /* @__PURE__ */ jsxs13(Fragment3, { children: [
+      subject,
+      ": "
+    ] }),
+    label
+  ] }),
+  /* @__PURE__ */ jsx23("dd", { children: /* @__PURE__ */ jsx23(ContextValue, { value }) })
+] }, path)) }) : null;
+
+// src/PreparedFormulaSheet.tsx
+import { Fragment as Fragment4, jsx as jsx24, jsxs as jsxs14 } from "react/jsx-runtime";
+var mathSheet = (document2) => createSheetFromCalculationSourceObject(
+  {
+    schemaVersion: "1.0.0",
+    title: document2.title,
+    source: { id: "prepared-math", metadata: {} },
+    rootSectionIds: document2.rootSectionIds,
+    sections: document2.sections.map((section) => ({
+      id: section.id,
+      title: section.title,
+      items: section.items.flatMap((item) => {
+        if (item.kind === "section") {
+          return [{ kind: "section", id: item.id }];
+        }
+        if (item.kind === "symbol") {
+          return [{ kind: "symbol", symbol: item.symbol }];
+        }
+        if (item.kind === "symbolRef") {
+          return [{ kind: "symbolRef", id: item.id }];
+        }
+        return [];
+      })
+    })),
+    detachedItems: document2.detachedSymbols.map((symbol) => ({
+      kind: "symbol",
+      symbol
+    }))
+  },
+  { id: "prepared-math", label: document2.title }
+).sheet;
+var requiredItem = (items, id) => {
+  const item = items.get(id);
+  if (!item) {
+    throw new Error(`Missing prepared item '${id}'`);
+  }
+  return item;
+};
+var PreparedFormulaSheet = ({
+  document: input,
+  showSourceDetails = true
+}) => {
+  const document2 = PreparedDocumentSchema.parse(input);
+  const sheet = mathSheet(document2);
+  const sections = new Map(
+    document2.sections.map((section) => [section.id, section])
+  );
+  const assets = new Map(
+    document2.assets.map((asset) => [asset.asset.id, asset])
+  );
+  const symbols = new Map(sheet.symbols.map((symbol) => [symbol.id, symbol]));
+  let symbolIndex = 0;
+  const renderSection = (section) => /* @__PURE__ */ jsxs14(
+    "section",
+    {
+      "data-section-id": section.id,
+      className: "cso-section",
+      children: [
+        /* @__PURE__ */ jsx24(
+          "h2",
+          {
+            "data-source-placement": section.sourcePlacementId,
+            className: "cso-section-heading",
+            children: section.title
+          }
+        ),
+        /* @__PURE__ */ jsx24(EngineeringMetadata, { entries: section.context }),
+        section.items.map((item) => {
+          switch (item.kind) {
+            case "section": {
+              const child = requiredItem(sections, item.id);
+              return /* @__PURE__ */ jsxs14(
+                "div",
+                {
+                  "data-source-placement": item.sourcePlacementId,
+                  children: [
+                    /* @__PURE__ */ jsx24(EngineeringMetadata, { entries: item.context }),
+                    renderSection(child)
+                  ]
+                },
+                item.sourcePlacementId
+              );
+            }
+            case "text": {
+              return /* @__PURE__ */ jsxs14(
+                "div",
+                {
+                  "data-source-placement": item.sourcePlacementId,
+                  className: "cso-text",
+                  children: [
+                    item.text.content,
+                    /* @__PURE__ */ jsx24(EngineeringMetadata, { entries: item.context })
+                  ]
+                },
+                item.sourcePlacementId
+              );
+            }
+            case "figure": {
+              const asset = requiredItem(assets, item.figure.assetId);
+              return /* @__PURE__ */ jsxs14(
+                "figure",
+                {
+                  "data-source-placement": item.sourcePlacementId,
+                  "data-asset-sha256": asset.asset.sha256,
+                  className: "cso-figure",
+                  children: [
+                    /* @__PURE__ */ jsx24(
+                      "img",
+                      {
+                        src: asset.dataUrl,
+                        alt: item.figure.alt,
+                        style: item.figure.width === void 0 ? void 0 : { width: item.figure.width }
+                      }
+                    ),
+                    item.figure.caption && /* @__PURE__ */ jsx24("figcaption", { children: item.figure.caption }),
+                    /* @__PURE__ */ jsx24(EngineeringMetadata, { entries: item.context })
+                  ]
+                },
+                item.sourcePlacementId
+              );
+            }
+            case "symbol":
+            case "symbolRef": {
+              const symbolId = item.kind === "symbol" ? item.symbol.id : item.id;
+              const symbol = requiredItem(symbols, symbolId);
+              const index = symbolIndex++;
+              return /* @__PURE__ */ jsxs14(
+                "div",
+                {
+                  "data-source-placement": item.sourcePlacementId,
+                  "data-symbol-id": symbolId,
+                  className: "cso-symbol-placement",
+                  children: [
+                    /* @__PURE__ */ jsx24(EngineeringMetadata, { entries: item.context }),
+                    item.operands.map(({ symbolId: id, context }) => /* @__PURE__ */ jsx24(
+                      EngineeringMetadata,
+                      {
+                        entries: context,
+                        subject: /* @__PURE__ */ jsxs14(Fragment4, { children: [
+                          "Operand",
+                          " ",
+                          /* @__PURE__ */ jsx24(
+                            GlyphMathBlock,
+                            {
+                              glyph: requiredItem(symbols, id).glyph
+                            }
+                          )
+                        ] })
+                      },
+                      id
+                    )),
+                    /* @__PURE__ */ jsx24(
+                      FormulaSheetSymbolRow,
+                      {
+                        sheet,
+                        item: symbol,
+                        sheetItemIndex: index
+                      }
+                    )
+                  ]
+                },
+                item.sourcePlacementId
+              );
+            }
+            default: {
+              const exhaustive = item;
+              return exhaustive;
+            }
+          }
+        })
+      ]
+    },
+    section.id
+  );
+  return /* @__PURE__ */ jsxs14(
+    "article",
+    {
+      "data-formula-sheet": "true",
+      "data-prepared-document": "true",
+      className: "cso-document",
+      children: [
+        /* @__PURE__ */ jsxs14("header", { className: "cso-document-header", children: [
+          /* @__PURE__ */ jsx24("h1", { children: document2.title }),
+          showSourceDetails && /* @__PURE__ */ jsx24("p", { children: document2.source.kind === "legacy" ? "Development preservation rendering. Numerical agreement has not been verified." : "Execution-bound document. Numerical verification is reported separately." }),
+          showSourceDetails && document2.source.kind === "execution" && /* @__PURE__ */ jsxs14("p", { children: [
+            "Function ",
+            document2.source.function,
+            ". Inputs",
+            " ",
+            Object.entries(document2.source.resolvedInputs).map(
+              ([key, value]) => `${key} = ${Object.is(value, -0) ? "-0" : value}`
+            ).join(", "),
+            "."
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx24(EngineeringMetadata, { entries: document2.context }),
+        document2.rootSectionIds.map((id) => {
+          const section = sections.get(id);
+          if (!section) {
+            throw new Error(`Missing prepared root '${id}'`);
+          }
+          return renderSection(section);
+        })
+      ]
+    }
+  );
+};
+
+// src/prepare-document.ts
+import {
+  executionBindingFrom,
+  AssetRecordSchema,
+  BoundPreparedDocumentSchema,
+  CalculationSourceObjectSchema,
+  ExecutionPayloadSchema,
+  HistoricalReviewSchema as HistoricalReviewSchema2,
+  LegacyAssetManifestSchema,
+  PreparedDocumentItemSchema,
+  PreparedDocumentSchema as PreparedDocumentSchema2,
+  PreparedDocumentSectionSchema,
+  ResolvedAssetSchema,
+  contractIssuesToDiagnostics
+} from "@cs-object/core";
+
+// src/active-symbols.ts
+var activeSymbolIds = (initialIds, definitionsById) => {
+  var _a;
+  const reachableSymbolIds = new Set(initialIds);
+  for (const id of reachableSymbolIds) {
+    const symbol = definitionsById.get(id);
+    if (!symbol) continue;
+    const nodes = new Map(
+      symbol.valueTree.nodes.map((node) => [node.key, node])
+    );
+    const pending = [symbol.valueTree.rootKey];
+    const visited = /* @__PURE__ */ new Set();
+    while (pending.length > 0) {
+      const key = pending.pop();
+      if (key === void 0 || visited.has(key)) continue;
+      visited.add(key);
+      const node = nodes.get(key);
+      if ((node == null ? void 0 : node.mode) === "SYMBOL" && node.symbol) {
+        reachableSymbolIds.add(node.symbol.id);
+      } else if ((node == null ? void 0 : node.mode) === "FUNCTION") {
+        pending.push(...((_a = node.funcArgs) != null ? _a : []).map((argument) => argument.key));
+      }
+    }
+  }
+  return reachableSymbolIds;
+};
+
+// src/prepare-context.ts
+import {
+  HistoricalReviewSchema
+} from "@cs-object/core";
+var fields = /* @__PURE__ */ new Map([
+  ["purpose", "Purpose"],
+  ["explanation", "Explanation"],
+  ["method", "Method"],
+  ["criteria", "Criteria"],
+  ["applicability", "Applicability"],
+  ["tolerances", "Tolerances"],
+  ["description", "Description"],
+  ["assumptions", "Assumptions"],
+  ["assumption", "Assumption"],
+  ["designBasis", "Design basis"],
+  ["limitations", "Limitations"],
+  ["designStandard", "Design standard"],
+  ["standard", "Standard"],
+  ["references", "References"],
+  ["reference", "Reference"],
+  ["notes", "Notes"],
+  ["note", "Note"],
+  ["comment", "Comment"],
+  ["credit", "Credit"],
+  ["license", "License"]
+]);
+var pointer = (key) => key.replaceAll("~", "~0").replaceAll("/", "~1");
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var evidenceKeys = /* @__PURE__ */ new Set([
+  "localId",
+  "invocationId",
+  "location",
+  "key",
+  "draft",
+  "tags",
+  "valueTree",
+  "nodes",
+  "rootKey",
+  "funcSpec",
+  "funcArgs",
+  "owner",
+  "acl",
+  "canEdit",
+  "canShare",
+  "__typename",
+  "__proto__",
+  "constructor"
+]);
+var evidenceRole = /audit|review|approv|checked|submission|verification|transport/i;
+var engineeringChild = (key) => !(evidenceKeys.has(key) || evidenceRole.test(key));
+var contextValue = (value, path) => {
+  if (value === null || value === "") {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    const items = value.flatMap((entry, index) => {
+      const selected = contextValue(entry, `${path}/${index}`);
+      return selected ? [selected] : [];
+    });
+    return items.length > 0 ? { kind: "list", items } : void 0;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).flatMap(([key, entry]) => {
+      if (!engineeringChild(key)) {
+        return [];
+      }
+      const selected = contextValue(entry, `${path}/${pointer(key)}`);
+      return selected ? [{ label: key, value: selected }] : [];
+    });
+    return entries.length > 0 ? { kind: "record", entries } : void 0;
+  }
+  return { kind: "text", value, path };
+};
+var engineeringFields = (value, path) => {
+  if (value === void 0) {
+    return [];
+  }
+  const object = HistoricalReviewSchema.shape.originalFields.parse(value);
+  return Object.entries(object).flatMap(([key, value2]) => {
+    const sourcePath = `${path}/${pointer(key)}`;
+    if (key === "additionalFields" && record(value2)) {
+      return engineeringFields(value2, sourcePath);
+    }
+    const label = fields.get(key);
+    const selected = label ? contextValue(value2, sourcePath) : void 0;
+    return label && selected ? [{ label, value: selected, path: sourcePath }] : [];
+  });
+};
+var prepareDocumentContext = (document2) => {
+  const definitions = new Map([
+    ...document2.sections.flatMap(
+      (section, sectionIndex) => section.items.flatMap(
+        (item, itemIndex) => item.kind === "symbol" ? [
+          [
+            item.symbol.id,
+            {
+              symbol: item.symbol,
+              path: `/sections/${sectionIndex}/items/${itemIndex}/symbol`
+            }
+          ]
+        ] : []
+      )
+    ),
+    ...document2.detachedSymbols.map(
+      (symbol, index) => [symbol.id, { symbol, path: `/detachedSymbols/${index}` }]
+    )
+  ]);
+  const placed = new Set(
+    document2.sections.flatMap(
+      (section) => section.items.flatMap(
+        (item) => item.kind === "symbol" ? [item.symbol.id] : item.kind === "symbolRef" ? [item.id] : []
+      )
+    )
+  );
+  const symbols = new Map(
+    [...definitions].map(([id, definition]) => [id, definition.symbol])
+  );
+  const symbolContext = (id) => {
+    const definition = definitions.get(id);
+    if (!definition) {
+      throw new Error(`Missing prepared symbol '${id}'`);
+    }
+    return engineeringFields(
+      definition.symbol.metadata,
+      `${definition.path}/metadata`
+    );
+  };
+  const operandContext = (symbolId) => {
+    const definition = definitions.get(symbolId);
+    if (!definition) {
+      throw new Error(`Missing prepared operand '${symbolId}'`);
+    }
+    const context = ["description", "unit", "comment"].flatMap(
+      (key) => {
+        const value = definition.symbol[key];
+        if (value === void 0 || value === "") {
+          return [];
+        }
+        const path = `${definition.path}/${key}`;
+        return key === "unit" ? [{ label: "Unit", path, value: { kind: "math", path, value } }] : engineeringFields({ [key]: value }, definition.path);
+      }
+    );
+    return { symbolId, context: [...context, ...symbolContext(symbolId)] };
+  };
+  return __spreadProps(__spreadValues({}, document2), {
+    context: engineeringFields(document2.sourceMetadata, "/sourceMetadata"),
+    sections: document2.sections.map((section, sectionIndex) => __spreadProps(__spreadValues({}, section), {
+      context: engineeringFields(
+        section.metadata,
+        `/sections/${sectionIndex}/metadata`
+      ),
+      items: section.items.map((item, itemIndex) => {
+        const path = `/sections/${sectionIndex}/items/${itemIndex}/contextSource`;
+        const context = [
+          "metadata",
+          "contentMetadata",
+          "additionalFields"
+        ].flatMap(
+          (key) => {
+            var _a;
+            return engineeringFields((_a = item.contextSource) == null ? void 0 : _a[key], `${path}/${key}`);
+          }
+        );
+        if (item.kind !== "symbol" && item.kind !== "symbolRef") {
+          return __spreadProps(__spreadValues({}, item), { context });
+        }
+        const id = item.kind === "symbol" ? item.symbol.id : item.id;
+        return __spreadProps(__spreadValues({}, item), {
+          context: [...symbolContext(id), ...context],
+          operands: [...activeSymbolIds([id], symbols)].filter((id2) => !placed.has(id2)).map(operandContext)
+        });
+      })
+    }))
+  });
+};
+
+// src/prepare-document.ts
+var DocumentPreparationError = class extends Error {
+  constructor(diagnostics) {
+    super(diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+    this.name = "DocumentPreparationError";
+    this.diagnostics = diagnostics;
+  }
+};
+function fail(code, message) {
+  throw new DocumentPreparationError([{ code, message, stage: "document" }]);
+}
+var pointerKey = (key) => key.replaceAll("~", "~0").replaceAll("/", "~1");
+var assertDocumentJson = (value, path, ancestors = /* @__PURE__ */ new Set()) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return;
+  if (typeof value === "number" && Number.isFinite(value)) return;
+  if (typeof value !== "object" || value === null || ancestors.has(value) || !Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null || Object.getOwnPropertySymbols(value).some(
+    (key) => Object.prototype.propertyIsEnumerable.call(value, key)
+  )) {
+    fail(
+      "NON_JSON_DOCUMENT_FIELD",
+      `Document field '${path}' must contain finite JSON values without cycles or custom objects`
+    );
+  }
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    if (Object.keys(value).length !== value.length)
+      fail(
+        "NON_JSON_DOCUMENT_FIELD",
+        `Document array '${path}' must be dense and contain only indexed values`
+      );
+    for (let index = 0; index < value.length; index++)
+      assertDocumentJson(value[index], `${path}/${index}`, ancestors);
+  } else {
+    for (const [key, entry] of Object.entries(value))
+      assertDocumentJson(entry, `${path}/${pointerKey(key)}`, ancestors);
+  }
+  ancestors.delete(value);
+};
+var restoreContentFields = (cso, original) => __spreadProps(__spreadValues({}, cso), {
+  sections: cso.sections.map((section, sectionIndex) => __spreadProps(__spreadValues({}, section), {
+    items: section.items.map((item, index) => {
+      var _a;
+      const raw = (_a = original.sections[sectionIndex]) == null ? void 0 : _a.items[index];
+      if (item.kind === "text" && (raw == null ? void 0 : raw.kind) === "text")
+        return __spreadProps(__spreadValues({}, item), { text: __spreadValues(__spreadValues({}, item.text), raw.text) });
+      if (item.kind === "figure" && (raw == null ? void 0 : raw.kind) === "figure")
+        return __spreadProps(__spreadValues({}, item), { figure: __spreadValues(__spreadValues({}, item.figure), raw.figure) });
+      return item;
+    })
+  }))
+});
+var parseContent = (schema, value) => {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    throw new DocumentPreparationError(
+      contractIssuesToDiagnostics(parsed.error.issues).map((diagnostic) => __spreadProps(__spreadValues({}, diagnostic), {
+        stage: "document"
+      }))
+    );
+  }
+  return parsed.data;
+};
+var parseHistoricalReview = (value) => {
+  assertDocumentJson(value, "/historicalReview");
+  return parseContent(HistoricalReviewSchema2, value);
+};
+var parseDocument = (candidate) => parseContent(PreparedDocumentSchema2, candidate);
+var reachableSections = (cso) => {
+  const sections = new Map(
+    cso.sections.map((section) => [section.id, section])
+  );
+  const visited = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const visit = (id) => {
+    if (visited.has(id)) {
+      fail(
+        "DUPLICATE_SECTION_PLACEMENT",
+        `Section '${id}' is repeated or recursive`
+      );
+    }
+    const section = sections.get(id);
+    if (!section) {
+      return fail("UNRESOLVED_DOCUMENT_SECTION", `Section '${id}' is missing`);
+    }
+    visited.add(id);
+    ordered.push(section);
+    for (const item of section.items) {
+      if (item.kind === "section") {
+        visit(item.id);
+      }
+    }
+  };
+  for (const id of cso.rootSectionIds) {
+    visit(id);
+  }
+  return ordered;
+};
+var symbolDefinitions = (cso) => {
+  var _a;
+  return [
+    ...cso.sections.flatMap(
+      (section) => section.items.flatMap(
+        (item) => item.kind === "symbol" ? [item.symbol] : []
+      )
+    ),
+    ...((_a = cso.detachedItems) != null ? _a : []).flatMap(
+      (item) => item.kind === "symbol" ? [item.symbol] : []
+    )
+  ];
+};
+var assertExtensionFields = (cso) => {
+  var _a;
+  const fields2 = (record2, names, path) => {
+    for (const [key, value] of Object.entries(record2)) {
+      if (names.includes(key))
+        assertDocumentJson(value, `${path}/${pointerKey(key)}`);
+    }
+  };
+  fields2(cso.source, ["metadata"], "/source");
+  if (cso.source.origin)
+    fields2(cso.source.origin, ["metadata"], "/source/origin");
+  const contentFields = (item, path) => {
+    fields2(item, ["metadata"], path);
+    if (item.kind === "text" || item.kind === "figure") {
+      const content = item.kind === "text" ? item.text : item.figure;
+      if (content) assertDocumentJson(content, `${path}/${item.kind}`);
+    }
+  };
+  cso.sections.forEach((section, index) => {
+    const path = `/sections/${index}`;
+    fields2(section, ["metadata"], path);
+    section.items.forEach((item, itemIndex) => {
+      const itemPath = `${path}/items/${itemIndex}`;
+      contentFields(item, itemPath);
+    });
+  });
+  (_a = cso.detachedItems) == null ? void 0 : _a.forEach((item, index) => {
+    contentFields(item, `/detachedItems/${index}`);
+  });
+  symbolDefinitions(cso).forEach((symbol, index) => {
+    const path = `/definitions/${index}`;
+    fields2(symbol, ["aliases", "metadata"], path);
+    fields2(symbol.valueTree, ["metadata"], `${path}/valueTree`);
+    symbol.valueTree.nodes.forEach((node, nodeIndex) => {
+      fields2(
+        node,
+        ["metadata", "tags"],
+        `${path}/valueTree/nodes/${nodeIndex}`
+      );
+    });
+  });
+};
+var placementId = (sectionId, index) => JSON.stringify([sectionId, index]);
+var itemFields = (item) => {
+  var _a, _b, _c, _d, _e;
+  if (item.kind === "text") {
+    return {
+      kind: item.kind,
+      id: item.id,
+      text: { content: (_a = item.text) == null ? void 0 : _a.content }
+    };
+  }
+  if (item.kind === "figure") {
+    return {
+      kind: item.kind,
+      id: item.id,
+      figure: {
+        assetId: (_b = item.figure) == null ? void 0 : _b.assetId,
+        caption: (_c = item.figure) == null ? void 0 : _c.caption,
+        alt: (_d = item.figure) == null ? void 0 : _d.alt,
+        width: (_e = item.figure) == null ? void 0 : _e.width
+      }
+    };
+  }
+  const _f = item, { metadata: _ } = _f, fields2 = __objRest(_f, ["metadata"]);
+  return __spreadValues(__spreadValues({}, fields2), item.kind === "symbol" || item.kind === "symbolRef" ? { operands: [] } : {});
+};
+var retainedMetadata = (metadata, executionContext) => {
+  if (!metadata || !executionContext || Object.keys(metadata).length === 0)
+    return metadata;
+  const authored = Object.fromEntries(
+    Object.entries(metadata).filter(
+      ([key]) => !["localId", "invocationId", "location"].includes(key)
+    )
+  );
+  return Object.keys(authored).length > 0 ? authored : void 0;
+};
+var symbolMetadataHistory = (cso, executionContext = false) => {
+  const definitions = symbolDefinitions(cso);
+  const definitionsById = new Map(
+    definitions.map((symbol) => [symbol.id, symbol])
+  );
+  const placedSymbolIds = new Set(
+    reachableSections(cso).flatMap(
+      (section) => section.items.flatMap(
+        (item) => item.kind === "symbol" ? [item.symbol.id] : item.kind === "symbolRef" ? [item.id] : []
+      )
+    )
+  );
+  const reachableSymbolIds = activeSymbolIds(placedSymbolIds, definitionsById);
+  const historicalDefinitions = definitions.flatMap((symbol) => {
+    var _a;
+    if (!reachableSymbolIds.has(symbol.id)) return [];
+    const metadata = retainedMetadata(symbol.metadata, executionContext);
+    const additionalFields = Object.fromEntries(
+      Object.entries(symbol).filter(
+        ([key, value]) => (["glyphPlaintext", "aliases"].includes(key) || ["description", "unit", "comment"].includes(key) && (!placedSymbolIds.has(symbol.id) || value === "")) && value !== void 0
+      )
+    );
+    const treeMetadata = retainedMetadata(
+      symbol.valueTree.metadata,
+      executionContext
+    );
+    const nodesByKey = new Map(
+      symbol.valueTree.nodes.map((node) => [node.key, node])
+    );
+    const active = /* @__PURE__ */ new Set();
+    const pending = [symbol.valueTree.rootKey];
+    while (pending.length > 0) {
+      const key = pending.pop();
+      if (key === void 0 || active.has(key)) continue;
+      active.add(key);
+      const node = nodesByKey.get(key);
+      if ((node == null ? void 0 : node.mode) === "FUNCTION")
+        pending.push(...((_a = node.funcArgs) != null ? _a : []).map((arg) => arg.key));
+    }
+    const nodes = symbol.valueTree.nodes.flatMap((node) => {
+      if (!active.has(node.key)) return [];
+      const nodeMetadata = retainedMetadata(node.metadata, executionContext);
+      const context2 = __spreadValues(__spreadValues(__spreadValues({}, node.draft !== void 0 ? { draft: node.draft } : {}), node.tags !== void 0 ? { tags: node.tags } : {}), nodeMetadata !== void 0 ? { metadata: nodeMetadata } : {});
+      return Object.keys(context2).length > 0 ? [__spreadValues({ key: node.key }, context2)] : [];
+    });
+    const valueTree = __spreadValues(__spreadValues({}, treeMetadata !== void 0 ? { metadata: treeMetadata } : {}), nodes.length > 0 ? { nodes } : {});
+    const context = __spreadValues(__spreadValues(__spreadValues({}, metadata !== void 0 ? { metadata } : {}), Object.keys(additionalFields).length > 0 ? { additionalFields } : {}), Object.keys(valueTree).length > 0 ? { valueTree } : {});
+    return Object.keys(context).length > 0 ? [__spreadValues({ id: symbol.id, glyph: symbol.glyph }, context)] : [];
+  });
+  const symbolHistory = historicalDefinitions.filter(
+    (symbol) => placedSymbolIds.has(symbol.id)
+  );
+  const referencedSymbolHistory = historicalDefinitions.filter(
+    (symbol) => !placedSymbolIds.has(symbol.id)
+  );
+  return { definitions, symbolHistory, referencedSymbolHistory };
+};
+var consumedContentFields = (item, executionContext) => {
+  if (item.kind === "text") return ["content", "metadata"];
+  if (executionContext)
+    return ["assetId", "caption", "alt", "width", "metadata"];
+  return ["originalUrl", "width", "metadata"];
+};
+var retainItemContextSource = (item, executionContext = false) => {
+  const metadata = retainedMetadata(item.metadata, executionContext);
+  const content = item.kind === "text" ? item.text : item.kind === "figure" ? item.figure : void 0;
+  const hasContentMetadata = content !== void 0 && Object.hasOwn(content, "metadata");
+  const consumed = consumedContentFields(item, executionContext);
+  const additionalFields = content ? Object.fromEntries(
+    Object.entries(content).filter(([key]) => !consumed.includes(key))
+  ) : {};
+  if (metadata === void 0 && !hasContentMetadata && Object.keys(additionalFields).length === 0) {
+    return void 0;
+  }
+  return __spreadValues(__spreadValues(__spreadValues({}, metadata !== void 0 ? { metadata } : {}), hasContentMetadata ? { contentMetadata: content == null ? void 0 : content.metadata } : {}), Object.keys(additionalFields).length > 0 ? { additionalFields } : {});
+};
+var itemMetadataHistory = (cso, executionContext = false) => reachableSections(cso).flatMap(
+  (section) => section.items.flatMap((item, index) => {
+    const contextSource = retainItemContextSource(item, executionContext);
+    return contextSource ? [
+      __spreadValues({
+        id: item.kind === "symbol" ? item.symbol.id : item.id,
+        kind: item.kind,
+        sourcePlacementId: placementId(section.id, index)
+      }, contextSource)
+    ] : [];
+  })
+);
+var resolveExecutionPlacementProvenance = (execution, item) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const symbolId = item.kind === "symbol" ? item.symbol.id : item.kind === "symbolRef" ? item.id : void 0;
+  const definition = execution.invocations.flatMap((invocation) => invocation.symbols).find((symbol) => symbol.symbolId === symbolId);
+  const targetSection = item.kind === "section" ? execution.cso.sections.find((target) => target.id === item.id) : void 0;
+  const targetInvocation = targetSection && execution.invocations.find(
+    (invocation) => {
+      var _a2;
+      return invocation.id === ((_a2 = targetSection.metadata) == null ? void 0 : _a2.invocationId);
+    }
+  );
+  const metadata = (_a = item.metadata) != null ? _a : item.kind === "symbol" ? item.symbol.metadata : void 0;
+  const definitionInvocation = definition && execution.invocations.find(
+    (invocation) => invocation.symbols.includes(definition)
+  );
+  const targetCallSite = targetInvocation && "callSite" in targetInvocation ? targetInvocation.callSite : void 0;
+  const definitionLocation = item.kind === "symbol" ? definition == null ? void 0 : definition.definitionLocation : void 0;
+  return {
+    localId: (_d = (_c = (_b = targetSection == null ? void 0 : targetSection.metadata) == null ? void 0 : _b.localId) != null ? _c : definition == null ? void 0 : definition.localId) != null ? _d : metadata == null ? void 0 : metadata.localId,
+    invocationId: (_g = (_f = (_e = targetSection == null ? void 0 : targetSection.metadata) == null ? void 0 : _e.invocationId) != null ? _f : definitionInvocation == null ? void 0 : definitionInvocation.id) != null ? _g : metadata == null ? void 0 : metadata.invocationId,
+    location: (_i = (_h = metadata == null ? void 0 : metadata.location) != null ? _h : targetCallSite) != null ? _i : definitionLocation
+  };
+};
+var prepareExecutionDocument = (options) => {
+  var _a, _c;
+  const execution = parseContent(ExecutionPayloadSchema, options.execution);
+  assertExtensionFields(options.execution.cso);
+  for (const review of (_a = options.historicalReviews) != null ? _a : [])
+    assertDocumentJson(review, "/historicalReview");
+  const cso = restoreContentFields(execution.cso, options.execution.cso);
+  if (Object.hasOwn(cso.source, "metadata"))
+    assertDocumentJson(cso.source.metadata, "/source/metadata");
+  const assets = options.assets.map(
+    (asset) => parseContent(ResolvedAssetSchema, asset)
+  );
+  for (const resolved of assets) {
+    const declared = execution.assets.find(
+      (asset) => asset.id === resolved.asset.id
+    );
+    if (!declared || JSON.stringify(AssetRecordSchema.parse(declared)) !== JSON.stringify(resolved.asset)) {
+      fail(
+        "DOCUMENT_ASSET_BINDING_MISMATCH",
+        `Captured asset '${resolved.asset.id}' differs from the execution asset record`
+      );
+    }
+  }
+  const sections = reachableSections(cso).map((section) => {
+    var _a2, _b2, _c2;
+    return {
+      id: section.id,
+      title: section.title,
+      sourcePlacementId: placementId(section.id, "heading"),
+      context: [],
+      localId: (_a2 = section.metadata) == null ? void 0 : _a2.localId,
+      invocationId: (_b2 = section.metadata) == null ? void 0 : _b2.invocationId,
+      location: (_c2 = section.metadata) == null ? void 0 : _c2.location,
+      metadata: retainedMetadata(section.metadata, true),
+      items: section.items.map((item, index) => {
+        return __spreadValues(__spreadProps(__spreadValues({}, itemFields(item)), {
+          context: [],
+          contextSource: retainItemContextSource(item, true),
+          sourcePlacementId: placementId(section.id, index)
+        }), resolveExecutionPlacementProvenance(execution, item));
+      })
+    };
+  });
+  const displayed = new Set(
+    sections.flatMap(
+      (section) => section.items.flatMap(
+        (item) => item.kind === "symbol" ? [item.symbol.id] : []
+      )
+    )
+  );
+  const { definitions, symbolHistory, referencedSymbolHistory } = symbolMetadataHistory(cso, true);
+  const itemHistory = itemMetadataHistory(cso, true);
+  const contentHistory = itemHistory.filter(
+    (item) => item.kind === "text" || item.kind === "figure"
+  );
+  const placementHistory = itemHistory.filter(
+    (item) => item.kind !== "text" && item.kind !== "figure"
+  );
+  const _b = cso.source, { metadata: _sourceMetadata } = _b, sourceProvenance = __objRest(_b, ["metadata"]);
+  const document2 = parseDocument({
+    documentVersion: "2",
+    context: [],
+    source: __spreadValues({
+      kind: "execution"
+    }, executionBindingFrom(execution)),
+    sourceMetadata: cso.source.metadata,
+    title: cso.title,
+    rootSectionIds: cso.rootSectionIds,
+    sections,
+    detachedSymbols: definitions.filter((symbol) => !displayed.has(symbol.id)),
+    assets,
+    historicalReviews: [
+      parseHistoricalReview({
+        scope: "historical",
+        originalSource: {
+          id: execution.entry.moduleId,
+          sha256: execution.entry.sourceHash,
+          format: "CalculationSourceObject execution"
+        },
+        attribution: "Source provenance and authored metadata from the captured source. Review fields are historical and do not approve this execution or rendering.",
+        originalFields: __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
+          source: sourceProvenance
+        }, (() => {
+          const sections2 = reachableSections(cso).flatMap((section) => {
+            const metadata = retainedMetadata(section.metadata, true);
+            return metadata !== void 0 ? [{ id: section.id, title: section.title, metadata }] : [];
+          });
+          return sections2.length > 0 ? { sections: sections2 } : {};
+        })()), symbolHistory.length > 0 ? { symbols: symbolHistory } : {}), referencedSymbolHistory.length > 0 ? { referencedSymbols: referencedSymbolHistory } : {}), contentHistory.length > 0 ? { content: contentHistory } : {}), placementHistory.length > 0 ? { placements: placementHistory } : {})
+      }),
+      ...(_c = options.historicalReviews) != null ? _c : []
+    ]
+  });
+  return parseContent(BoundPreparedDocumentSchema, {
+    execution,
+    document: prepareDocumentContext(document2)
+  }).document;
+};
+var legacyFigure = (options, manifest, item, sourcePlacementId) => {
+  var _a, _b, _c, _d, _e, _f;
+  const entry = manifest.entries.find(
+    (entry2) => entry2.originalFixtureSha256 === options.fixtureSha256 && entry2.figureId === item.id
+  );
+  if (!entry) {
+    return fail(
+      "UNRESOLVED_LEGACY_FIGURE",
+      `Original figure '${item.id}' has no recovered asset mapping`
+    );
+  }
+  if (((_a = item.figure) == null ? void 0 : _a.originalUrl) !== entry.originalUrl) {
+    return fail(
+      "LEGACY_FIGURE_URL_MISMATCH",
+      `Figure '${item.id}' original URL differs from its manifest`
+    );
+  }
+  const asset = options.assets.find(
+    (resolved) => resolved.asset.sha256 === entry.contentSha256 && resolved.asset.path === entry.localPath
+  );
+  if (!asset) {
+    return fail(
+      "UNRESOLVED_DOCUMENT_ASSET",
+      `Original figure '${item.id}' captured bytes are missing`
+    );
+  }
+  return parseContent(PreparedDocumentItemSchema, {
+    kind: "figure",
+    id: item.id,
+    sourcePlacementId,
+    context: [],
+    contextSource: retainItemContextSource(item),
+    figure: __spreadValues({
+      assetId: asset.asset.id,
+      caption: (_c = (_b = entry.additions) == null ? void 0 : _b.caption) != null ? _c : "",
+      alt: (_e = (_d = entry.additions) == null ? void 0 : _d.alt) != null ? _e : ""
+    }, ((_f = item.figure) == null ? void 0 : _f.width) !== void 0 ? { width: item.figure.width } : {})
+  });
+};
+var prepareLegacyDocument = (options) => {
+  var _a, _b, _c, _d;
+  const cso = restoreContentFields(
+    parseContent(CalculationSourceObjectSchema, options.cso),
+    options.cso
+  );
+  assertExtensionFields(options.cso);
+  for (const review of (_a = options.historicalReviews) != null ? _a : [])
+    assertDocumentJson(review, "/historicalReview");
+  const manifest = parseContent(LegacyAssetManifestSchema, options.manifest);
+  const sections = reachableSections(cso).map(
+    (section) => parseContent(PreparedDocumentSectionSchema, {
+      id: section.id,
+      title: section.title,
+      sourcePlacementId: placementId(section.id, "heading"),
+      context: [],
+      metadata: section.metadata,
+      items: section.items.map((item, index) => {
+        const sourcePlacementId = placementId(section.id, index);
+        if (item.kind === "figure") {
+          return legacyFigure(options, manifest, item, sourcePlacementId);
+        }
+        return parseContent(PreparedDocumentItemSchema, __spreadProps(__spreadValues({}, itemFields(item)), {
+          sourcePlacementId,
+          context: [],
+          contextSource: retainItemContextSource(item)
+        }));
+      })
+    })
+  );
+  const displayed = new Set(
+    sections.flatMap(
+      (section) => section.items.flatMap(
+        (item) => item.kind === "symbol" ? [item.symbol.id] : []
+      )
+    )
+  );
+  const { definitions, symbolHistory, referencedSymbolHistory } = symbolMetadataHistory(cso);
+  const itemHistory = itemMetadataHistory(cso);
+  const contentHistory = itemHistory.filter(
+    (item) => item.kind === "text" || item.kind === "figure"
+  );
+  const placementHistory = itemHistory.filter(
+    (item) => item.kind !== "text" && item.kind !== "figure"
+  );
+  const historical = parseHistoricalReview({
+    scope: "historical",
+    originalSource: {
+      id: options.fixtureId,
+      sha256: options.fixtureSha256,
+      format: (_c = (_b = cso.source.origin) == null ? void 0 : _b.format) != null ? _c : "CalculationSourceObject"
+    },
+    attribution: "Historical source metadata. It does not approve this rendering or a current execution.",
+    originalFields: __spreadValues(__spreadValues(__spreadValues(__spreadValues({
+      source: cso.source,
+      sections: reachableSections(cso).map(({ id, title, metadata }) => __spreadValues({
+        id,
+        title
+      }, metadata ? { metadata } : {}))
+    }, contentHistory.length > 0 ? { content: contentHistory } : {}), placementHistory.length > 0 ? { placements: placementHistory } : {}), symbolHistory.length > 0 ? { symbols: symbolHistory } : {}), referencedSymbolHistory.length > 0 ? { referencedSymbols: referencedSymbolHistory } : {})
+  });
+  const document2 = parseDocument({
+    documentVersion: "2",
+    context: [],
+    source: {
+      kind: "legacy",
+      fixtureId: options.fixtureId,
+      fixtureSha256: options.fixtureSha256
+    },
+    title: cso.title,
+    sourceMetadata: cso.source.metadata,
+    rootSectionIds: cso.rootSectionIds,
+    sections,
+    detachedSymbols: definitions.filter((symbol) => !displayed.has(symbol.id)),
+    assets: options.assets,
+    historicalReviews: [historical, ...(_d = options.historicalReviews) != null ? _d : []]
+  });
+  return parseDocument(prepareDocumentContext(document2));
+};
+export {
+  AsciiMathView,
+  DocumentPreparationError,
+  FormulaSheet,
+  PreparedFormulaSheet,
+  prepareExecutionDocument,
+  prepareLegacyDocument,
+  printFormulaSheet
+};