pict-section-formeditor 1.0.0

package/user-documentation/Solver-Expressions-Advanced.md

@@ -0,0 +1,344 @@
+# Solver Expressions Advanced Topics
+
+This article covers scope rules, tabular group solvers, data creation, set operations, MAP/SERIES expressions, and ordinal-based execution control.
+
+## Scope: Global Form vs Tabular Group
+
+Understanding scope is essential for writing correct solver expressions.
+
+### Global Form Scope (Section Solvers)
+
+Section-level solvers operate in the global form scope. They can read and write any input address in the form. When a section solver references a hash like `Price`, it resolves to the top-level form data.
+
+```
+Total = Price * Quantity
+```
+
+This reads `Price` and `Quantity` from the form's AppData and writes `Total` back to the form's AppData.
+
+Section solvers can also read from the broader application state using `getvalue`:
+
+```
+TaxRate = getvalue("AppData.Settings.TaxRate")
+```
+
+### Tabular/RecordSet Scope (Group Solvers)
+
+Tabular and RecordSet groups have their own solver arrays (`RecordSetSolvers`). These solvers execute once per row in the data set. Inside a group solver, hash references resolve to the current row's data rather than the global form.
+
+For example, if a Tabular group displays rows from `AppData.LineItems` and each row has `Price`, `Quantity`, and `LineTotal` fields, a group solver like:
+
+```
+LineTotal = Price * Quantity
+```
+
+runs for each row individually. `Price` refers to that row's price, not a global form input. The result `LineTotal` is written back to that same row.
+
+### Crossing Scope Boundaries
+
+Group solvers can access global form data using `getvalue`:
+
+```
+LineTotal = Price * Quantity * (1 + getvalue("AppData.FormData.TaxRate"))
+```
+
+Conversely, section solvers can aggregate data from tabular groups using array-aware functions:
+
+```
+OrderTotal = sum(flatten(getvalue("AppData.LineItems[].LineTotal")))
+```
+
+The `[]` syntax in `getvalue` gathers a value from every element of the array.
+
+## Creating Data in Scope
+
+Solver expressions can create new data that did not exist in the original form inputs. When you assign to a hash that is not a declared input, the value is stored in the solver's destination object and is available to subsequent solvers.
+
+```
+TaxAmount = Subtotal * TaxRate
+GrandTotal = Subtotal + TaxAmount
+```
+
+Even if `TaxAmount` is not a form input, the second expression can still reference it because it was created by the first expression in the same solver pass.
+
+### Writing to Application State
+
+Use `setvalue` to write data to a specific path in the application state:
+
+```
+setvalue("AppData.Computed.OrderSummary.Total", GrandTotal)
+```
+
+This is useful for making computed results available to other parts of the application, not just the form.
+
+### Null Coalescence for Defaults
+
+Use `?=` to set initial values without overwriting existing data:
+
+```
+DefaultShipping ?= 5.99
+DefaultCurrency ?= "USD"
+```
+
+These only write if the target is currently empty, so user edits are preserved.
+
+## Set Operations and Array Manipulation
+
+Many solver functions work with arrays (called "sets" in the expression language). These are essential for working with lists of data.
+
+### Building Arrays
+
+The comma operator creates a set from individual values:
+
+```
+Colors = "Red", "Green", "Blue"
+```
+
+Use `flatten` to extract arrays from nested data:
+
+```
+AllCities = flatten(getvalue("AppData.Regions[].Cities[].Name"))
+```
+
+Use `getvaluearray` to gather specific paths into a single array:
+
+```
+KeyMetrics = getvaluearray("AppData.Revenue", "AppData.Costs", "AppData.Profit")
+```
+
+### Filtering and Transforming
+
+`uniquearray` removes duplicates:
+
+```
+UniqueStates = uniquearray(AllStates)
+```
+
+`sortarray` sorts values:
+
+```
+SortedNames = sortarray(AllNames)
+```
+
+`slice` extracts a portion:
+
+```
+TopFive = slice(SortedScores, 0, 5)
+```
+
+### Set Algebra
+
+Combine or compare arrays:
+
+```
+AllMembers = unionarrays(TeamA, TeamB)
+OnlyInA = differencearrays(TeamA, TeamB)
+```
+
+### Searching
+
+Find specific values in arrays of objects:
+
+```
+FoundCity = findfirstvaluebyexactmatch(getvalue("AppData.Cities"), "state", "Colorado", "city")
+```
+
+This searches the Cities array for the first entry where `state` equals `"Colorado"` and returns its `city` field.
+
+```
+MatchIndex = match("Denver", CityNames)
+```
+
+This returns the zero-based index of `"Denver"` in the array, similar to a spreadsheet MATCH function.
+
+## MAP Expressions
+
+MAP transforms each element of an array using an expression:
+
+```
+Result = MAP VAR x FROM Values : x * 2
+```
+
+Given `Values = [1, 2, 3, 4, 5]`, this produces `[2, 4, 6, 8, 10]`.
+
+Multiple variables iterate in parallel:
+
+```
+Distances = MAP VAR lat FROM Latitudes VAR lon FROM Longitudes : sqrt(lat^2 + lon^2)
+```
+
+MAP is powerful for transforming tabular data, computing derived columns, or preparing data for charts.
+
+## SERIES Expressions
+
+SERIES generates a sequence of computed values over a numeric range:
+
+```
+XValues = SERIES FROM 0 TO 100 STEP 5 : n
+```
+
+This produces `[0, 5, 10, 15, ..., 100]`. The variable `n` holds the current step value, and `stepIndex` holds the zero-based index.
+
+```
+Curve = SERIES FROM 0 TO 10 STEP 0.5 : n^2 + 2*n + 1
+```
+
+Series variables (FROM, TO, STEP) can reference other solver values:
+
+```
+DataPoints = SERIES FROM StartX TO EndX STEP Resolution : BaseValue + (n * Slope)
+```
+
+## Ordinal-Based Execution Control
+
+### Multi-Pass Computation
+
+Ordinals let you organize solvers into execution phases:
+
+- **Ordinal 1** (default): Core calculations — compute raw values
+- **Ordinal 2**: Derived calculations — aggregate results from ordinal 1
+- **Ordinal 3**: UI updates — color cells, show/hide sections based on computed values
+
+### Dynamic Ordinal Control
+
+You can enable or disable entire ordinals at runtime:
+
+```
+disablesolverordinal(3)
+```
+
+This prevents all ordinal-3 solvers from executing. Re-enable them later:
+
+```
+enablesolverordinal(3)
+```
+
+Or conditionally toggle based on form state:
+
+```
+setsolverordinalenabled(2, IsAdvancedMode)
+```
+
+This is useful for performance optimization — skip expensive calculations when their results are not needed.
+
+## Form UI Control from Solvers
+
+Solvers can directly control form appearance and visibility.
+
+### Section and Group Visibility
+
+Show or hide parts of the form based on data:
+
+```
+setsectionvisibility("AdvancedOptions", ShowAdvanced)
+setsectionvisibility("BasicOptions", if(ShowAdvanced, "==", "true", "0", "1"))
+```
+
+For bulk operations:
+
+```
+showsections(VisibleSections)
+hidesections(HiddenSections)
+```
+
+Where `VisibleSections` and `HiddenSections` are arrays of section hashes.
+
+### Conditional Coloring
+
+Highlight cells or sections based on computed values:
+
+```
+AlertColor = if(Total, ">", Budget, "#FFE0E0", "#E0FFE0")
+colorsectionbackground("Summary", AlertColor)
+```
+
+For individual inputs:
+
+```
+colorinputbackground("S1", "Total", if(Total, ">", Budget, "#FF0000", "#000000"))
+```
+
+For tabular cells, specify the row index:
+
+```
+colorinputbackgroundtabular("Data", "DataGroup", "Status", RowIndex, StatusColor)
+```
+
+### Tabular Row Management
+
+Control the number of rows in a tabular group:
+
+```
+settabularrowlength("DataSection", "DataGroup", DesiredRowCount)
+```
+
+After modifying tabular data, force a display refresh:
+
+```
+refreshtabularsection("DataSection", "DataGroup")
+```
+
+## Histogram and Aggregation
+
+Histograms group and summarize data by field values.
+
+### Distribution Histogram
+
+Count occurrences of each unique value:
+
+```
+StateCounts = distributionhistogram("AppData.Cities", "state")
+```
+
+Result: `{ "Colorado": 21, "New York": 15, "California": 42, ... }`
+
+### Aggregation Histogram
+
+Sum a numeric field grouped by a category:
+
+```
+PopulationByState = aggregationhistogram("AppData.Cities", "state", "population")
+```
+
+Result: `{ "Colorado": "5773714", "New York": "19453561", ... }`
+
+### Working with Histogram Results
+
+Extract keys and values for charting:
+
+```
+StateNames = objectkeystoarray(StateCounts)
+StateValues = objectvaluestoarray(StateCounts)
+SortedHistogram = sorthistogram(StateCounts)
+```
+
+## Regression and Prediction
+
+Fit models to data and make predictions:
+
+```
+Coefficients = linest(flatten(getvalue("AppData.XData")), flatten(getvalue("AppData.YData")))
+PredictedY = predict(Coefficients, NewXValue)
+```
+
+For polynomial regression:
+
+```
+PolyCoefficients = polynomialregression(XValues, YValues, 3)
+```
+
+## Debugging Expressions
+
+Use `logvalues` to print intermediate values to the browser console:
+
+```
+Debug = logvalues("Tax:", TaxRate, "Subtotal:", Subtotal, "Total:", Total)
+```
+
+This logs each value and returns the last one. It helps track down issues in complex solver chains.
+
+## Next Steps
+
+- Browse the [Solver Functions](Solver-Functions.md) reference for every available function
+- Review the [Solver Expression Walkthrough](Solver-Expression-Walkthrough.md) for basics
+- Return to the [Table of Contents](ToC.md)

package/user-documentation/Solver-Functions.md

@@ -0,0 +1,213 @@
+# Solver Functions
+
+A complete reference of all functions available in solver expressions. Functions are case-insensitive.
+
+See the [Solver Expression Walkthrough](Solver-Expression-Walkthrough.md) for an introduction or [Advanced Topics](Solver-Expressions-Advanced.md) for scope rules and complex patterns.
+
+## Conditional
+
+- [if](solverfunctions/if.md) -- Conditional comparison: `if(left, operator, right, trueValue, falseValue)`
+- [when](solverfunctions/when.md) -- Truthy check: `when(value, trueResult, falseResult)`
+
+## Math
+
+- [abs](solverfunctions/abs.md) -- Absolute value
+- [ceil](solverfunctions/ceil.md) -- Round up to nearest integer
+- [compare](solverfunctions/compare.md) -- Compare two values
+- [cos](solverfunctions/cos.md) -- Cosine (radians)
+- [euler](solverfunctions/euler.md) -- Euler's number (e)
+- [exp](solverfunctions/exp.md) -- Exponential (e^x)
+- [floor](solverfunctions/floor.md) -- Round down to nearest integer
+- [log](solverfunctions/log.md) -- Natural logarithm
+- [percent](solverfunctions/percent.md) -- Percentage calculation
+- [pi](solverfunctions/pi.md) -- Pi constant
+- [rad](solverfunctions/rad.md) -- Degrees to radians
+- [round](solverfunctions/round.md) -- Round to decimal places
+- [sin](solverfunctions/sin.md) -- Sine (radians)
+- [sqrt](solverfunctions/sqrt.md) -- Square root
+- [tan](solverfunctions/tan.md) -- Tangent (radians)
+- [tofixed](solverfunctions/tofixed.md) -- Format to fixed decimal places
+
+## Statistics
+
+- [avg](solverfunctions/avg.md) -- Average (alias for mean)
+- [count](solverfunctions/count.md) -- Count elements in array
+- [countset](solverfunctions/countset.md) -- Count set elements
+- [countsetelements](solverfunctions/countsetelements.md) -- Count elements in histogram
+- [max](solverfunctions/max.md) -- Maximum value
+- [mean](solverfunctions/mean.md) -- Arithmetic mean
+- [median](solverfunctions/median.md) -- Median value
+- [min](solverfunctions/min.md) -- Minimum value
+- [mode](solverfunctions/mode.md) -- Most frequent value
+- [stdev](solverfunctions/stdev.md) -- Sample standard deviation
+- [stdeva](solverfunctions/stdeva.md) -- Sample standard deviation (alias)
+- [stdevp](solverfunctions/stdevp.md) -- Population standard deviation
+- [sum](solverfunctions/sum.md) -- Sum of values
+- [var](solverfunctions/var.md) -- Sample variance
+- [vara](solverfunctions/vara.md) -- Sample variance (alias)
+- [varp](solverfunctions/varp.md) -- Population variance
+
+## String
+
+- [concat](solverfunctions/concat.md) -- Concatenate with spaces
+- [concatraw](solverfunctions/concatraw.md) -- Concatenate without spaces
+- [join](solverfunctions/join.md) -- Join with separator
+- [joinraw](solverfunctions/joinraw.md) -- Join without entity resolution
+- [resolvehtmlentities](solverfunctions/resolvehtmlentities.md) -- Resolve HTML entities
+- [stringcountsegments](solverfunctions/stringcountsegments.md) -- Count string segments
+- [stringgetsegments](solverfunctions/stringgetsegments.md) -- Split string into segments
+
+## Array & Set Operations
+
+- [arrayconcat](solverfunctions/arrayconcat.md) -- Concatenate arrays
+- [differencearrays](solverfunctions/differencearrays.md) -- Set difference of two arrays
+- [flatten](solverfunctions/flatten.md) -- Flatten nested arrays
+- [setconcatenate](solverfunctions/setconcatenate.md) -- Concatenate sets
+- [slice](solverfunctions/slice.md) -- Extract a portion of an array
+- [sortarray](solverfunctions/sortarray.md) -- Sort an array
+- [sortset](solverfunctions/sortset.md) -- Sort a set with precision
+- [unionarrays](solverfunctions/unionarrays.md) -- Set union of two arrays
+- [uniquearray](solverfunctions/uniquearray.md) -- Remove duplicates from array
+
+## Set Inspection
+
+- [bucketset](solverfunctions/bucketset.md) -- Bucket values into ranges
+- [entryinset](solverfunctions/entryinset.md) -- Get entry from set by index
+- [largestinset](solverfunctions/largestinset.md) -- Largest value in a set
+- [smallestinset](solverfunctions/smallestinset.md) -- Smallest value in a set
+
+## Cumulative Operations
+
+- [cumulativesummation](solverfunctions/cumulativesummation.md) -- Running total over a set
+- [iterativeseries](solverfunctions/iterativeseries.md) -- Iterative computation over array
+- [subtractingsummation](solverfunctions/subtractingsummation.md) -- Running subtraction over a set
+
+## Histogram & Aggregation
+
+- [aggregationhistogram](solverfunctions/aggregationhistogram.md) -- Sum values grouped by field (from AppData path)
+- [aggregationhistogrambyobject](solverfunctions/aggregationhistogrambyobject.md) -- Sum values grouped by field (from object)
+- [distributionhistogram](solverfunctions/distributionhistogram.md) -- Count occurrences by field (from AppData path)
+- [distributionhistogrambyobject](solverfunctions/distributionhistogrambyobject.md) -- Count occurrences by field (from object)
+- [sorthistogram](solverfunctions/sorthistogram.md) -- Sort histogram by values
+- [sorthistogrambykeys](solverfunctions/sorthistogrambykeys.md) -- Sort histogram by keys
+
+## Value Access
+
+- [getvalue](solverfunctions/getvalue.md) -- Read value from application state
+- [setvalue](solverfunctions/setvalue.md) -- Write value to application state
+- [getvaluearray](solverfunctions/getvaluearray.md) -- Gather multiple values into array
+- [getvalueobject](solverfunctions/getvalueobject.md) -- Gather multiple values into object
+- [createvalueobjectbyhashes](solverfunctions/createvalueobjectbyhashes.md) -- Create object from hash references
+
+## Object & Array Utilities
+
+- [cleanvaluearray](solverfunctions/cleanvaluearray.md) -- Remove empty values from array
+- [cleanvalueobject](solverfunctions/cleanvalueobject.md) -- Remove empty values from object
+- [createarrayfromabsolutevalues](solverfunctions/createarrayfromabsolutevalues.md) -- Create array from absolute values
+- [generatearrayofobjectsfromsets](solverfunctions/generatearrayofobjectsfromsets.md) -- Generate objects from sets
+- [objectkeystoarray](solverfunctions/objectkeystoarray.md) -- Extract object keys as array
+- [objectvaluestoarray](solverfunctions/objectvaluestoarray.md) -- Extract object values as array
+- [objectvaluessortbyexternalobjectarray](solverfunctions/objectvaluessortbyexternalobjectarray.md) -- Sort object values by external array
+
+## Search
+
+- [findfirstvaluebyexactmatch](solverfunctions/findfirstvaluebyexactmatch.md) -- Find first matching entry in array
+- [findfirstvaluebystringincludes](solverfunctions/findfirstvaluebystringincludes.md) -- Find first entry containing a string
+- [match](solverfunctions/match.md) -- Find index of value in array (spreadsheet-style MATCH)
+
+## Date
+
+- [datefromparts](solverfunctions/datefromparts.md) -- Create date from year, month, day, etc.
+- [datemilliseconddifference](solverfunctions/datemilliseconddifference.md) -- Milliseconds between two dates
+- [dateseconddifference](solverfunctions/dateseconddifference.md) -- Seconds between two dates
+- [dateminutedifference](solverfunctions/dateminutedifference.md) -- Minutes between two dates
+- [datehourdifference](solverfunctions/datehourdifference.md) -- Hours between two dates
+- [datedaydifference](solverfunctions/datedaydifference.md) -- Days between two dates
+- [dateweekdifference](solverfunctions/dateweekdifference.md) -- Weeks between two dates
+- [datemonthdifference](solverfunctions/datemonthdifference.md) -- Months between two dates
+- [dateyeardifference](solverfunctions/dateyeardifference.md) -- Years between two dates
+- [datemathadd](solverfunctions/datemathadd.md) -- Add time to a date (generic)
+- [dateaddmilliseconds](solverfunctions/dateaddmilliseconds.md) -- Add milliseconds to a date
+- [dateaddseconds](solverfunctions/dateaddseconds.md) -- Add seconds to a date
+- [dateaddminutes](solverfunctions/dateaddminutes.md) -- Add minutes to a date
+- [dateaddhours](solverfunctions/dateaddhours.md) -- Add hours to a date
+- [dateadddays](solverfunctions/dateadddays.md) -- Add days to a date
+- [dateaddweeks](solverfunctions/dateaddweeks.md) -- Add weeks to a date
+- [dateaddmonths](solverfunctions/dateaddmonths.md) -- Add months to a date
+- [dateaddyears](solverfunctions/dateaddyears.md) -- Add years to a date
+
+## Random Data Generation
+
+- [randominteger](solverfunctions/randominteger.md) -- Random integer
+- [randomintegerbetween](solverfunctions/randomintegerbetween.md) -- Random integer in range
+- [randomintegerupto](solverfunctions/randomintegerupto.md) -- Random integer up to max
+- [randomfloat](solverfunctions/randomfloat.md) -- Random float
+- [randomfloatbetween](solverfunctions/randomfloatbetween.md) -- Random float in range
+- [randomfloatupto](solverfunctions/randomfloatupto.md) -- Random float up to max
+
+## Regression & Matrix
+
+- [gaussianelimination](solverfunctions/gaussianelimination.md) -- Gaussian elimination
+- [leastsquares](solverfunctions/leastsquares.md) -- Least squares regression
+- [linest](solverfunctions/linest.md) -- Linear regression (alias for leastsquares)
+- [matrixinverse](solverfunctions/matrixinverse.md) -- Inverse of a matrix
+- [matrixmultiply](solverfunctions/matrixmultiply.md) -- Multiply two matrices
+- [matrixtranspose](solverfunctions/matrixtranspose.md) -- Transpose a matrix
+- [matrixvectormultiply](solverfunctions/matrixvectormultiply.md) -- Multiply matrix by vector
+- [polynomialregression](solverfunctions/polynomialregression.md) -- Polynomial regression fit
+- [predict](solverfunctions/predict.md) -- Predict from regression model
+
+## Form UI Control
+
+These functions control the visual appearance and behavior of the running form.
+
+- [colorgroupbackground](solverfunctions/colorgroupbackground.md) -- Set group background color
+- [colorinputbackground](solverfunctions/colorinputbackground.md) -- Set input background color
+- [colorinputbackgroundtabular](solverfunctions/colorinputbackgroundtabular.md) -- Set tabular cell background color
+- [colorsectionbackground](solverfunctions/colorsectionbackground.md) -- Set section background color
+- [disablesolverordinal](solverfunctions/disablesolverordinal.md) -- Disable a solver execution ordinal
+- [enablesolverordinal](solverfunctions/enablesolverordinal.md) -- Enable a solver execution ordinal
+- [generatehtmlhexcolor](solverfunctions/generatehtmlhexcolor.md) -- Generate hex color from RGB values
+- [hidesections](solverfunctions/hidesections.md) -- Hide form sections
+- [refreshtabularsection](solverfunctions/refreshtabularsection.md) -- Refresh tabular display
+- [runsolvers](solverfunctions/runsolvers.md) -- Re-run all solver expressions
+- [setgroupvisibility](solverfunctions/setgroupvisibility.md) -- Set group visibility
+- [setsectionvisibility](solverfunctions/setsectionvisibility.md) -- Set section visibility
+- [setsolverordinalenabled](solverfunctions/setsolverordinalenabled.md) -- Enable or disable solver ordinal
+- [settabularrowlength](solverfunctions/settabularrowlength.md) -- Set tabular row count
+- [showsections](solverfunctions/showsections.md) -- Show form sections
+
+## Debugging
+
+- [logvalues](solverfunctions/logvalues.md) -- Log values to browser console
+
+## Operators
+
+| Operator | Description | Precedence |
+|----------|-------------|------------|
+| `^` | Exponentiation | Highest |
+| `*` `/` `%` | Multiply, Divide, Modulus | High |
+| `+` `-` | Add, Subtract | Medium |
+| `,` | Set concatenation | Low |
+| `=` | Assignment | Lowest |
+| `?=` | Null coalescence assignment | Lowest |
+
+## Expression Syntax
+
+### MAP
+
+```
+Result = MAP VAR x FROM ArrayValue : x * 2
+```
+
+### SERIES
+
+```
+Result = SERIES FROM 0 TO 100 STEP 5 : n^2
+```
+
+### MONTECARLO
+
+```
+Result = MONTECARLO SAMPLECOUNT 1000 VAR x PT x 0 PT x 100 : x^2
+```

package/user-documentation/Solvers.md

@@ -0,0 +1,81 @@
+# Solvers
+
+Solvers are expressions that compute values, transform data, or control form behavior. They run when the form renders and can assign calculated results to input fields.
+
+## What is a Solver Expression?
+
+A solver expression is a string written in the Fable expression syntax. It can reference input addresses, perform arithmetic, call built-in functions, and assign results to data paths. Solvers are attached to sections or to tabular/recordset groups.
+
+## Where Solvers Live
+
+- **Section Solvers** -- Attached to a section and evaluated in the context of that section's data. Most solvers are section-level.
+- **Group Solvers (RecordSet)** -- Attached to a Tabular or RecordSet group and evaluated for each record in the set. Only groups with a Tabular or RecordSet layout can have their own solvers.
+
+## The Solver Editor Tab
+
+The **Solver Editor** tab provides a focused environment for writing and editing solver expressions. It has three areas:
+
+### Code Editor
+
+The main editing area uses a syntax-highlighted code editor. Write your solver expression here. The editor supports the Fable expression language with highlighting for operators, addresses, and functions.
+
+### Ordinal
+
+Each solver has an ordinal number that controls its execution order. Solvers with lower ordinals run first. The default ordinal is 1. If you need a solver to run before or after others, adjust its ordinal value.
+
+- When a solver has the default ordinal (1), it is stored as a simple string in the manifest.
+- When you set a non-default ordinal, the solver is promoted to an object with `Expression` and `Ordinal` properties.
+- Clearing the ordinal (or setting it back to 1) demotes the solver back to a simple string.
+
+### Reference List
+
+A searchable list of all inputs in the form, organized by section. Each entry shows:
+
+- The input name and hash
+- The data address
+- An **Insert** button that pastes the address into the code editor at the cursor
+
+Use the search box to filter inputs by name, hash, address, or section.
+
+## The Solvers Tab
+
+The **Solvers** tab provides a read-only overview of all solver expressions across the form. It is organized into sections:
+
+### Solver Health
+
+At the top, a health summary shows any potential issues:
+
+- **Expressions with no hash** -- Solver expressions that do not assign a value to any input. These may be intentional (side-effect expressions) or may indicate a missing assignment.
+- **Unresolved references** -- Addresses referenced in solver expressions that do not match any input in the form. These may indicate typos or deleted inputs.
+
+### Solver List
+
+Below the health section, all solvers are listed grouped by their parent section or group. Each solver expression is clickable and opens directly in the Solver Editor.
+
+### Input Solver Info
+
+When you select an input in the visual editor, the Input tab in the properties panel shows solver information for that input:
+
+- **Assigned by** -- Which solver expression assigns a value to this input (if any). Clickable to open in the Solver Editor.
+- **Referenced by** -- All solver expressions that read this input's value. Each is clickable.
+
+## Adding a Solver
+
+There are two ways to add a solver:
+
+1. **From the properties panel** -- In the Section tab, use the solvers list to add a new solver to the selected section.
+2. **From the Add Solver helper** -- At the bottom of both the Solvers tab and the Solver Editor tab, a dropdown lets you select a target section or group, then click **+ Add Solver** to create a new empty solver and open it in the editor.
+
+## Managing Solvers
+
+- **Edit** -- Click any solver expression in the Solvers tab or properties panel to open it in the Solver Editor.
+- **Reorder** -- Use the up/down arrow buttons next to each solver in the properties panel. When drag-and-drop is enabled, solvers can be dragged to reorder.
+- **Delete** -- Click the delete button next to a solver in the properties panel.
+
+## Next Steps
+
+- Read the [Solver Expression Walkthrough](Solver-Expression-Walkthrough.md) for a step-by-step introduction to writing expressions
+- Explore [Solver Expressions Advanced Topics](Solver-Expressions-Advanced.md) for scope rules, set operations, and MAP/SERIES
+- Browse the [Solver Functions](Solver-Functions.md) reference for every available function
+- Learn about [Inputs & Data Types](Inputs.md) to understand what solvers reference
+- Return to the [Table of Contents](ToC.md)

package/user-documentation/ToC.md

@@ -0,0 +1,18 @@
+# Form Editor Help
+
+Welcome to the Form Editor. Use the links below to learn about each part of the editor.
+
+## Topics
+
+- [Getting Started](Getting-Started.md) -- Overview of the form editor and how to begin building forms
+- [Sections](Sections.md) -- How to create and configure form sections
+- [Groups](Groups.md) -- Organizing inputs into groups within sections
+- [Inputs & Data Types](Inputs.md) -- Adding inputs, choosing data types and input types
+- [Solvers](Solvers.md) -- Writing solver expressions for computed values
+- [Keyboard Shortcuts](Shortcuts.md) -- Productivity shortcuts for the form editor
+
+## Solver Expression Guides
+
+- [Solver Expression Walkthrough](Solver-Expression-Walkthrough.md) -- Step-by-step introduction to writing solver expressions
+- [Solver Expressions Advanced Topics](Solver-Expressions-Advanced.md) -- Scope rules, tabular solvers, set operations, and MAP/SERIES
+- [Solver Functions](Solver-Functions.md) -- Complete categorized reference of all available functions