Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/sheet/src/model/pivot/aggregate.ts`:
- Around line 48-74: The switch in aggregateValues currently only handles
'SUM','AVERAGE','MIN','MAX' and can fall through returning undefined for
unexpected aggregation values; add an explicit default branch (or a final guard
after the switch) that throws a descriptive Error (including the invalid
aggregation value and relevant context like nums) or returns a safe fallback
string, so the function never returns undefined for malformed input; update the
switch handling in aggregateValues to include this default/error path and ensure
the thrown message references the aggregation identifier to aid debugging.

In `@packages/sheet/src/model/pivot/calculate.ts`:
- Around line 150-155: The branch that calls aggregateValues(valueFields[0]) can
crash when valueFields is empty; add a guard in the same conditional that checks
valueFields.length === 0 and handle it deterministically (e.g., push a
placeholder cell like { value: null, type: 'value' } or skip/return early)
instead of dereferencing valueFields[0]. Update the block around hasColumns /
the single-value-field branch so functions aggregateValues and code that
consumes the cell always receive a valid cell object or an early exit when
valueFields is empty.

In `@packages/sheet/src/model/sheet.ts`:
- Around line 897-898: The structural mutation methods insertRows, deleteRows,
insertColumns, and deleteColumns currently lack the pivot-sheet guard present in
setData/removeData/paste; update each of these methods in class Sheet
(insertRows, deleteRows, insertColumns, deleteColumns) to early-return (or
throw) when this.pivotDefinition is set—mirroring the check in setData—or
alternatively add inline documentation and tests explaining and asserting that
structural edits are allowed on pivot sheets; also add unit tests covering
pivotBehavior for these four methods to make the intended behavior explicit.

---

Nitpick comments:
In `@design/pivot-table.md`:
- Around line 46-59: Add a language identifier (e.g., text or plaintext) to the
fenced code blocks in design/pivot-table.md—specifically update the ASCII
architecture diagram block (the three-backtick fenced block containing the box
diagram with Frontend/Sheet Engine/Store) and the other unnamed fenced blocks
flagged by the linter (lines noted in the review) so they become ```text (or
```plaintext); this satisfies markdown linters while preserving the diagram
content and formatting.

In `@packages/sheet/test/store/store.test.ts`:
- Around line 263-266: The test currently only mutates the local `def` to prove
clone-on-write; extend it to also verify clone-on-read by mutating the object
returned from `store.getPivotDefinition()` and asserting the subsequent call
still returns the original values. Specifically, after `const result2 = await
store.getPivotDefinition()`, change `result2.rowFields[0].label` (or another
fetched property) and then call `await store.getPivotDefinition()` again and
assert its `rowFields[0].label` remains `'Category'`; this ensures
`getPivotDefinition()` returns a defensive clone rather than a live reference.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/frontend/src/app/spreadsheet/pivot/use-pivot-table.ts`:
- Around line 47-62: The effect in useEffect that reads the pivot definition
(using doc, tabId, root, ws and ws.pivotTable) only sets definition when pivot
metadata exists but never clears it; update the effect to call
setDefinition(undefined) (or reset to an empty/default PivotTableDefinition)
whenever doc or tabId change and there is no ws.pivotTable present so stale
pivot state is cleared when switching to a non-pivot sheet or when pivot
metadata is removed; keep the existing branch that JSON-parses and sets the
definition for the positive case (including
rowFields/columnFields/valueFields/filterFields/showTotals) and add an explicit
else that clears/resets via setDefinition.
- Around line 64-77: The updater currently runs doc.update(...) inside the
setDefinition functional updater (updateDefinition -> setDefinition), causing
side effects inside a React state updater; instead, compute the new
PivotTableDefinition outside the state updater (e.g., const next =
updater(definition) after guarding definition and doc), then call
setDefinition(() => next) and finally call doc.update(root => { const ws =
root.sheets[tabId]; if (ws) ws.pivotTable = next; }); Ensure you null-check doc
and definition/PivotTableDefinition before computing next and performing
doc.update.

---

Nitpick comments:
In `@packages/frontend/src/app/spreadsheet/pivot/use-pivot-table.ts`:
- Around line 122-137: The removeField callback weakens type safety by casting
def[section] to unknown[]; update it to index into the definition with the
actual typed key instead of an unknown cast — make section be the keyof the
pivot definition type (the same type used by updateDefinition, e.g.,
PivotDefinition keys "rowFields"|"columnFields"|"valueFields"|"filterFields")
and read const list = def[section] (typed as the correct array type) then return
{ ...def, [section]: list.filter((_, i) => i !== index) } so TypeScript
preserves element types; adjust the removeField signature and body (referencing
removeField and updateDefinition) to use the real PivotDefinition key type
instead of unknown[].

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/frontend/src/app/spreadsheet/pivot/use-pivot-table.ts`:
- Around line 69-80: The effect can write a stale definition when doc or tabId
change because isInitialLoad is computed from definitionRef before updating it;
fix by reading and updating the ref in the correct order: capture the previous
value (e.g., const prevDef = definitionRef.current), then immediately set
definitionRef.current = definition, then compute isInitialLoad as prevDef ===
null && definition !== null, and only then return early if isInitialLoad || !doc
|| !definition; this ensures the doc.update call (and ws.pivotTable =
definition) always uses the latest definition for the current tabId and
document.

---

Nitpick comments:
In `@packages/sheet/src/model/pivot/aggregate.ts`:
- Around line 49-57: The SUM and AVERAGE branches in the pivot aggregation
(cases 'SUM' and 'AVERAGE' in aggregate.ts) both compute the sum by iterating
nums; refactor by computing the sum once before the switch (or in a shared
helper) and then use that value in the 'SUM' return and in the 'AVERAGE' return
(divide by nums.length); keep the same return format (String(...)) and ensure
you still handle empty nums appropriately if needed.

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@packages/sheet/src/index.ts`:
- Around line 108-110: The file currently imports parseRange separately from
'./model/coordinates'; consolidate that into the existing import block that
already imports from './model/coordinates' (add parseRange to that import) and
remove the standalone import of parseRange so there's a single import statement
for './model/coordinates' (refer to the parseRange symbol and the existing
coordinates import block to locate and update the code).

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@packages/frontend/src/app/spreadsheet/pivot/use-pivot-table.ts`:
- Around line 58-69: The sync effect still uses a stale definition when tabId or
doc changes; fix by tracking the source of the cached definition and skipping
sync if the source changed: keep a ref (e.g., definitionRef with an associated
sourceRef or previousTabIdRef) that stores both the definition and the tabId it
came from, and in the useEffect that calls doc.update compare
sourceRef.currentTabId to the current tabId and return early if they differ
(also keep the isInitialLoad guard). Update the ref values only after verifying
a safe sync is permitted so doc.update never writes a definition that was
captured for a different tabId; reference definitionRef,
sourceRef/previousTabIdRef, tabId, definition, and doc.update.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@design/pivot-table.md`:
- Around line 297-307: The design doc's pivot-sheet protection section is out of
sync: implementation now detects pivots with the TabMeta.kind === "pivot" check
(used in Sheet.setData()) instead of reading the pivot definition via
isPivotSheet() (which previously read from the store), and internal
materialization bypasses the guard via a private method; update the text to
state that pivot detection is based on TabMeta.kind === "pivot", describe that
Sheet.setData() early-returns for TabMeta.kind === "pivot" to block edits, and
note the internal materialization path uses a private/internal method that
bypasses this guard rather than reading pivot definitions from the store.
- Around line 46-59: The fenced ASCII diagram blocks (the ones containing
strings like "Frontend (React)", "PivotEditorPanel", "Sheet Engine
(packages/sheet)", "PivotCalculator", and "Store / Yorkie
CRDT"/"PivotTableDefinition") need language identifiers on their triple-backtick
fences to satisfy markdownlint; edit each fence to use a neutral identifier such
as ```text (or ```text/plain) so the blocks render and lint cleanly. Update the
primary diagram fence and the other similar fenced blocks referenced in the
comment (the ones containing the same unique labels like PivotEditorPanel,
PivotCalculator, PivotMaterializer, PivotTableDefinition) to use the same
language tag for consistency.

In `@packages/frontend/src/app/spreadsheet/pivot/pivot-editor-panel.tsx`:
- Around line 104-121: The editor currently prevents adding the same source
column to multiple valueFields because usedColumns and availableColumns exclude
any column once used and keys like `val-${field.sourceColumn}` collide; change
the logic so usedColumns is built only from rowFields, columnFields and
filterFields (exclude valueFields) so valueFields may reference the same
sourceColumn, and update any element keys that use just `field.sourceColumn`
(e.g., `val-${field.sourceColumn}`) to include a unique per-field identifier or
the field array index (e.g., `val-${field.sourceColumn}-${i}` or a field.id) to
avoid key collisions; ensure calculatePivot usage remains unchanged since it
already supports duplicate valueFields.

In `@packages/frontend/src/app/spreadsheet/pivot/use-pivot-table.ts`:
- Around line 91-120: The sourceGrid computed by the useMemo hook (sourceGrid)
becomes stale because it only depends on [doc, definition] and Yorkie document
content changes don’t change those refs; fix by either (A) adding a
document-change signal as a memo dependency — subscribe to doc changes
(doc.subscribe) and increment a local version/state (e.g., sourceVersion) then
include sourceVersion in the useMemo deps so sourceGrid recomputes on edits, or
(B) remove the useMemo and move the grid-building logic into the existing
refresh() and getSourceHeaders() call sites so they always build a fresh grid
from doc.getRoot()/sourceWs when invoked; apply the change around the sourceGrid
creation code and update any callers that expect sourceGrid to remain valid
(refresh(), getSourceHeaders()) accordingly.
- Around line 235-237: The bulk clear loop iterates Object.keys directly on the
Yorkie CRDT proxy (ws.sheet), which can throw "ownKeys duplicate" errors; change
it to first take a plain snapshot of the sheet and iterate that snapshot's keys
(e.g., use the { ...ws.sheet } / snapshotObject pattern used in yorkie-store.ts)
and then delete each key from ws.sheet, or alternatively delete cells
individually by building keysToDelete = Object.keys({ ...ws.sheet }) and then
running delete ws.sheet[key] for each key; update the loop that references
ws.sheet accordingly to avoid reading keys from the proxy directly.

In `@packages/frontend/src/app/spreadsheet/sheet-view.tsx`:
- Around line 876-893: The PivotEditorPanel is being mounted even when the sheet
is read-only; update the conditional that renders PivotEditorPanel so it also
checks the readOnly flag (e.g., only render when doc && isPivotTab &&
pivotEditorOpen && !readOnly). Ensure the onClose/onRefresh handlers remain the
same (references: PivotEditorPanel, setPivotEditorOpen, sheetRef,
setSheetRenderVersion) so the panel is never mounted or usable in read-only
mode.

In `@packages/frontend/src/app/spreadsheet/yorkie-store.ts`:
- Around line 1205-1208: The getPivotDefinition method currently returns
structuredClone(ws.pivotTable) which fails for Yorkie CRDT proxies; replace the
structuredClone usage in getPivotDefinition with manual extraction of each pivot
property (e.g., use the same pattern as in use-pivot-table.ts: use
readField(...) for scalar fields and Array.from(...) for arrays or iterables) to
build and return a plain PivotTableDefinition object detached from the Yorkie
proxy so loadPivotDefinition and pivot guards won't throw; ensure you reference
ws.pivotTable and populate the exact PivotTableDefinition fields when returning.

In `@packages/frontend/src/components/mobile-selection-handles.tsx`:
- Around line 30-35: The touchmove handler currently re-reads the selection via
spreadsheet.getSelectionRangeOrActiveCell(), causing the anchor to drift;
instead capture the opposite corner once in onTouchStart (e.g., store the
bottom-right cell in a ref like fixedAnchorRef) and reuse that stored anchor
inside onTouchMove when calling spreadsheet.selectStart/selectEnd so the
opposite corner stays fixed for the whole gesture; also clear the ref on
onTouchEnd/onTouchCancel. Ensure you update the handlers that reference
spreadsheet.getSelectionRangeOrActiveCell()
(onTouchStart/onTouchMove/onTouchEnd) to use the captured anchor ref.

In `@packages/sheet/src/model/pivot/aggregate.ts`:
- Around line 24-31: The COUNTA branch counts undefined as non-empty; update the
loop in the aggregation === 'COUNTA' branch to treat missing cells as empty by
first reading const val = records[i][sourceColumn] and only incrementing count
when val is neither undefined nor the empty string (e.g., if (val !== undefined
&& val !== '') { count++; }), mirroring the guard used in the numeric
aggregation branches so out-of-range/stale sourceColumn values don't inflate the
count.

In `@packages/sheet/src/model/pivot/materialize.ts`:
- Around line 4-12: The docstring for materialize is inconsistent with the
implementation: update the comment in the materialize function (the block
describing PivotResult -> Grid and cell styling) to remove "gray background" and
state that total cells receive bold styling only (matching the implementation
that sets { b: true } for totals); reference materialize, PivotResult, Grid and
Cell so reviewers can find and reconcile the docstring with the code.

In `@packages/sheet/src/model/sheet.ts`:
- Around line 446-449: Initialize the pivotDefinition cache in the Sheet
constructor (set this.pivotDefinition to undefined or call
this.loadPivotDefinition() during bootstrap) and add calls to await
this.loadPivotDefinition() inside the existing cache-reload sequences in both
undo() and redo() so pivotDefinition is refreshed alongside the other cached
state; update references to pivotDefinition in guards to rely on the freshly
loaded cache from loadPivotDefinition (function names: constructor,
loadPivotDefinition, undo, redo, pivotDefinition, store.getPivotDefinition).

In `@packages/sheet/src/model/shifting.ts`:
- Around line 80-88: The rewrite drops leading '$' markers because
parseRef/toSref lose absolute flags; fix by preserving and reapplying absolute
markers around moved refs: before calling parseRef on each token (both single
and range branches in the blocks using parseRef/moveRef/toSref), detect and
store the original column/row absolute flags (presence of '$' in startStr/endStr
or text), pass those flags through or attach them to the Ref object (or extend
moveRef/toSref to accept an absolute mask), then after moveRef reserialize using
a toSref variant that reintroduces the stored absolute markers; apply the same
change for all other occurrences of parseRef→moveRef→toSref (the other blocks
you noted).

In `@packages/sheet/test/sheet/pivot-aggregate.test.ts`:
- Around line 19-25: The test currently treats aggregation: 'COUNT' as counting
all rows including blanks and "N/A", which is incorrect for spreadsheet
semantics; update the test in pivot-aggregate.test.ts so that when using
PivotValueField with aggregation: 'COUNT' (in the it('COUNT counts all values
including empty') case referencing sumField, aggregateValues, and records) the
expected value is '3' (numeric-only count) while leaving the COUNTA test
expecting '4'; alternatively, if you intended row-count semantics, rename the
aggregation to a distinct name and adjust the assertion accordingly.

---

Outside diff comments:
In `@packages/sheet/src/view/cellinput.ts`:
- Around line 137-159: The prime() method currently always calls
this.input.focus(), causing unwanted focus/keyboard on non-edit selection flows;
change prime to accept an optional boolean parameter (e.g., focus?: boolean =
false) or a second "editing" flag and only call this.input.focus() when that
flag is true, leaving applyPrimedAppearance(), renderInput(), adjustSize()
behavior unchanged; update any callers that expect immediate focus to pass true
(or call a new enterEdit()/focusEditor() helper that focuses) and ensure
existing non-edit selection/tap flows keep the opt-out by not passing the focus
flag.

---

Duplicate comments:
In `@packages/frontend/src/app/spreadsheet/pivot/use-pivot-table.ts`:
- Around line 78-86: The effect using definitionRef currently writes stale
`definition` into the new sheet on tab switches; modify the useEffect that calls
doc.update so it tracks previous `doc` and `tabId` (e.g., via refs like
prevDocRef and prevTabIdRef) and returns early when either `doc` or `tabId` has
changed since the last render to suppress syncing during a source transition;
keep the existing initial-load guard (definitionRef) and only perform
doc.update((root) => { const ws = root.sheets[tabId]; if (ws) ws.pivotTable =
definition; }) when doc and tabId are stable and not in a transition.

---

Nitpick comments:
In `@packages/frontend/src/components/datasource-selector.tsx`:
- Around line 36-44: Refactor the useEffect callback in the datasource-selector
component to use async/await instead of .then() chains: inside the effect when
open is true, create an async function (e.g., loadDatasources) that sets
setLoading(true), awaits fetchDataSources(), calls setDatasources with the
result, catches errors to call setDatasources([]), and ensures setLoading(false)
in a finally block; invoke that async function from useEffect and keep the
dependency on open.
- Around line 128-132: Replace the .then()/.catch() chain used to refresh
datasources with an async/await pattern: mark the surrounding handler that runs
after the dialog closes as async, call const updated = await fetchDataSources()
inside a try block, then call setDatasources(updated), and handle errors in the
catch block (instead of .catch(()=>{})). This change targets the
fetchDataSources and setDatasources calls so the refresh uses explicit await and
proper error handling.

In `@packages/sheet/src/model/pivot/calculate.ts`:
- Around line 141-146: The inner loop recreates the same Set for each colLeaf:
move the creation of rowSet = new Set(rowLeaf.indices) out of the colLeaves loop
so it is built once per rowLeaf (i.e., compute rowSet before iterating over
colLeaves in the block guarded by hasColumns), then use that single rowSet when
computing intersection = colLeaf.indices.filter(i => rowSet.has(i)); update the
references in calculate.ts accordingly to avoid per-column allocations.

In `@packages/sheet/src/model/pivot/materialize.ts`:
- Around line 23-31: The switch in materializePivot (handling pivotCell.type)
duplicates the same assignment for 'rowHeader', 'colHeader', 'empty', and
'total'; consolidate these into a single case group (e.g., case 'rowHeader':
case 'colHeader': case 'empty': case 'total':) that assigns cell = { v:
pivotCell.value, s: { b: true } } to remove duplication while preserving
behavior.

In `@packages/sheet/src/model/pivot/parse.ts`:
- Around line 20-23: The loop that builds headers uses headers.push(cell?.v ??
'') but cell.v can be non-string; change to explicitly convert to string (e.g.,
headers.push(String(cell?.v ?? ''))) to make types explicit and robust, and
apply the same explicit String(...) conversion to the other analogous push in
this module where cell?.v is added (the other header/value push that mirrors
this loop using grid.get and toSref).

In `@packages/sheet/test/sheet/pivot-calculate.test.ts`:
- Around line 27-45: The test is not asserting the totals cells for the pivot so
regressions removing grand-total row/column would go unnoticed; update the test
that constructs the PivotTableDefinition (using calculatePivot and showTotals)
to explicitly assert the values of the totals cells when showTotals.rows/columns
are true (e.g., check the bottom-row grand total and right-column grand total
cells) and add a complementary test case (or extend the existing one at the
other block) that sets showTotals.rows/columns to false and asserts those total
cells are absent or empty; locate usages of calculatePivot and the
PivotTableDefinition in the failing test blocks to add these assertions.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@design/pivot-table.md`:
- Around line 223-225: Update the documentation text in the "Type coercion" /
pivot table section to reflect the implemented COUNT semantics: change the
sentence that currently reads "COUNT counts all values, COUNTA counts non-empty
values" to state that "COUNT counts numeric values only (non-numeric values are
ignored), while COUNTA counts non-empty values." Keep the existing notes about
parsing cell strings to numbers and skipping non-numeric values for
SUM/AVERAGE/MIN/MAX, and ensure the terms COUNT and COUNTA are used exactly so
readers can map them to the implemented functions.

In `@packages/frontend/src/app/spreadsheet/pivot/pivot-editor-panel.tsx`:
- Around line 152-159: The inline Close button (IconX) in pivot-editor-panel.tsx
currently calls onClose which hides the editor with no in-tab way to re-open it;
change this to a toggle-style API and surface a reopen control in the sheet
chrome: replace the onClick handler to call a new prop like onToggleEditor (or
emit a "pivotEditorToggle" event) instead of onClose, update the parent to
implement onToggleEditor and render a persistent reopen action in the sheet
chrome (e.g., a toolbar button) that toggles the editor visibility, or
alternatively remove the IconX button entirely if you prefer only the chrome
reopen path.

In `@packages/frontend/src/app/spreadsheet/pivot/use-pivot-table.ts`:
- Around line 36-74: The effect in use-pivot-table.ts only runs on doc or tabId
change and misses remote updates; inside the existing useEffect that reads the
pivot definition, subscribe to the Yorkie document remote changes via
doc.subscribe((e) => { if (e.type === "remote-change") { /* re-read pivot for
current tabId and call setDefinition like the existing pt logic */ } }) and
store/return the unsubscribe function to cleanup on unmount or dependency
change; ensure the subscription callback re-uses the same read logic (the pt
handling / readField, Array.from(...) and setDefinition) to update when
root.sheets[tabId].pivotTable mutates and only act when the affected tabId
matches the current tabId.
- Around line 225-259: The refresh callback currently mutates the Yorkie
document directly via doc.update() (in the refresh function that calls
buildSourceGrid(), calculatePivot(), materialize()) which bypasses the Store and
leaves YorkieStore.getGrid()'s cached CellIndex stale; change the implementation
to route writes through the Store API (call store.setGrid(tabId, grid) or
equivalent) or accept the store in this hook and after performing the update
call store.invalidate(tabId) so the cache is updated; replace direct writes to
root.sheets[tabId].sheet inside refresh with a call to the store method (or call
store.invalidate() immediately after the doc.update()) and keep buildSourceGrid,
calculatePivot and materialize usage intact.

---

Duplicate comments:
In `@design/pivot-table.md`:
- Around line 297-307: Update the "protection" and mitigation text to reflect
that pivot detection now uses TabMeta.kind === "pivot" at the tab level (not the
cached Sheet.pivotDefinition / isPivotSheet guard). Replace any guidance that
says to check or rely on Sheet.setData early-returns like "if
(this.pivotDefinition) return" with a description that editors should check
TabMeta.kind === "pivot" and note that internal materialization writes go
through doc.update (which bypasses Sheet mutation methods). Also update the
mitigation row to instruct consumers/guard code to consult TabMeta.kind when
preventing edits or showing UI state, and remove references to the outdated
cached pivotDefinition behavior (including mentions of loadPivotDefinition).

In `@packages/frontend/src/app/spreadsheet/pivot/use-pivot-table.ts`:
- Around line 76-87: The effect can run with a stale `definition` when `tabId`
changes and write old pivot metadata into the new sheet; add a lightweight guard
by tracking the last-seen tab and only applying `doc.update` when the effect's
`tabId` matches that last-seen value. Concretely, introduce a ref like
`lastTabRef = useRef(tabId)`, check `if (lastTabRef.current !== tabId) {
lastTabRef.current = tabId; definitionRef.current = definition; return; }` (keep
the existing `isInitialLoad` logic), and only call `doc.update` when
`lastTabRef.current === tabId`; update the ref as needed so stale `definition`
from the previous tab never gets written to the new sheet in `doc.update`
(references: `definitionRef`, `lastTabRef`, `useEffect`, `doc.update`, `tabId`,
`definition`).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/frontend/src/app/spreadsheet/pivot/use-pivot-table.ts`:
- Around line 92-106: The subscription currently only updates when
ws?.pivotTable exists; change the doc.subscribe callback (in the useEffect that
references doc, tabId, doc.subscribe, loadedTabIdRef, setDefinition,
readPivotProxy) to also handle the case where ws?.pivotTable is missing by
clearing local state: when event.type === "remote-change" and ws?.pivotTable is
falsy, setDefinition(undefined) (or the appropriate empty value) and reset
loadedTabIdRef.current (e.g., to undefined/null) so the UI immediately reflects
a remote deletion of the pivot definition.

---

Nitpick comments:
In `@packages/frontend/src/app/spreadsheet/pivot/use-pivot-table.ts`:
- Around line 31-61: readPivotProxy duplicates the field-extraction logic from
YorkieStore.getPivotDefinition; remove the duplication by extracting the common
mapping into a shared utility (e.g., export a function like
normalizePivotDefinition or mapPivotFields) and have both readPivotProxy and
YorkieStore.getPivotDefinition call that utility, or else have the hook call
YorkieStore.getPivotDefinition directly where synchronous access permits; update
references to PivotTableDefinition, readField, and the value/filter field
mappings so the single shared implementation handles rowFields, columnFields,
valueFields (with aggregation), filterFields (with hiddenValues) and showTotals.
- Around line 237-249: The toggleSort handler currently maps sort with f.sort
=== "desc" ? "asc" : "desc", which turns undefined -> "desc"; change the toggle
logic in toggleSort so an undefined sort becomes "asc" and the cycle is
undefined → "asc" → "desc" → "asc" (e.g., use f.sort === "asc" ? "desc" :
"asc"), updating the mapping for (def[section] as PivotField[]).map(...) inside
toggleSort to set the correct initial "asc" state while keeping updateDefinition
and PivotField intact.

In `@packages/frontend/src/app/spreadsheet/sheet-view.tsx`:
- Around line 885-903: The onRefresh callback on the PivotEditorPanel currently
uses a .then() chain; change it to an async function and use await to handle the
promise from sheet.reloadDimensions() instead. Locate the onRefresh prop passed
to PivotEditorPanel and modify its handler (the inline function that references
sheetRef, sheet.invalidateStore(), sheet.reloadDimensions(), sheet.render(), and
setSheetRenderVersion) to be async, call await sheet.reloadDimensions(), then
run sheet.render() and setSheetRenderVersion((v) => v + 1); keep the existing
null checks for sheet and preserve behavior otherwise.