What’s New in Grid

Explore significant capabilities and recent releases. Featured capabilities are selected for their usefulness, independently of release date.

Featured capabilities

Symbolic Mathematics

Work with exact symbolic expressions, simplification, differentiation, and solving in Grid models.

Recent releases

Code, Data, App, and Chat — 0.66.8

Grid 0.66.8 includes the Code, Data, App, Chat, document and presentation work developed during 0.66.7. Move between source, spreadsheet, focused views and conversation while working with one model.

Code checks local scopes and preserves independent errors — 0.66.8

Code follows sequential LET bindings and lambda parameters, reports malformed local bindings, and keeps unrelated missing-name diagnostics visible alongside named-function argument-count and type errors.

Stop bounded iterations early and reuse callable helpers — 0.66.8

UNTIL ends a bounded iteration at its first satisfying state, ITERATE.REPORT explains convergence or limit exhaustion, and pure helpers can accept callable parameters and invoke local lambdas. Interval timer rules with SKIP MISSED fire the latest elapsed occurrence once per observed tick, so jitter and intervals shorter than the scheduler tick no longer starve or drop firings.

Use camera and video connector images in AI questions — 0.66.8

Choose Images for AI to capture bounded color snapshots from cameras, recordings and streams, then attach the latest image directly in Chat without switching workbooks.

Choose a local model for image questions — 0.66.8

Find a compatible image model, see its accepted inputs before downloading, and return to Chat with your question and attachments intact.

Author interactive Grid Views in source — 0.66.8

Declare views, pages, local state, reusable elements, model actions, layouts, and presentation choices. Code provides View-aware completion and embedded JavaScript/CSS diagnostics; explicit CLI tooling derives installed React contracts, checks private model copies, and reports App migration differences. The selected-element Properties panel edits supported bindings, visibility, availability, actions, and layouts through compiler-checked source transactions with editor undo. Preview at phone, tablet, desktop or custom sizes, inspect elements without invoking controls, and explicitly enter live interaction for model writes and page parameters. Experiment with analyzed drafts through a private native model copy, with reset and cleanup that keep experimental writes away from the live model. Move, duplicate and remove supported source blocks from the outline, preserving comments and sharing editor undo; move elements between sections and pages with explicit destinations, and reorder explicitly nested pages from the same controls. Add standard controls, labels, sections, model value/input placements, actions and named pages from a compiler-derived palette with explicit placement and binding fields. Standard element options support adding, updating and removing properties with number fields, contract choices, Yes/No controls, text and expression modes, preserving source and undo. Native component controls use admitted local/imported contracts and phrasebooks, including fixed presets, arguments, writable bindings and variant guidance; edits stay at the caller use site. Embedded view options derive column fields, fixed configuration values, contract choices, constant arrays and model data bindings from the renderer inventory. Reusable Grid element instances expose required named arguments with separate text, number, Yes/No and expression modes; checked edits preserve caller scope and library definitions. Native and embedded components expose declared event handlers with their event values; add, update or remove checked handler source, including keys, guards and refusal actions, while preserving neighboring settings, slots and events. Named native slots offer add/update/remove content controls with scoped values listed; edits check slot scope and preserve neighboring events and properties. Direct native arrow headers expose checked property controls and activation event-value guidance, preserving action keys, guards, nested actions and refusal handlers. Imported native slot content, event actions and property values retain caller scope; nested imported component aliases work without library-private helpers overriding caller names. Contract presets, converters and styles keep their defining-library origin. Native main values and bindings have checked add/update/remove controls in ordinary component blocks and direct arrow headers, with declared value types and protection against conflicting aliases or fixed settings. Unnamed native component content has its own Content field with checked add/update/remove operations. Interleaved content is gathered at its first location while preserving other properties, events, named slots, attached comments and multiline payloads in one editor undo step. Automatic standard controls expose shared presentation options while retaining inference. Direct bindings offer a deliberate Use [component] action that pins the current component type and unlocks its full options in one checked, undoable edit. Direct named model inputs expose their owning validation declaration, with navigation to Whole model that retains the View inspector. Add, update or remove VALIDATE through a checked source transaction and editor undo, preserving neighboring clauses and comments; the contract applies to every use of the input. Duplicate named pages with distinct names and non-overlapping routes. Copies retain nested and flat page contents, comments, exact multiline payloads, parameter bindings and navigation destinations, and receive their own page/action identities through one source-editor undo transaction. Add local and imported components from the outline before their first use, using the selected View's import aliases and phrasebooks. Declared arguments and native main bindings use checked caller-source insertion, with missing-library, writable-target and stale-contract refusals. Local native preset parameters are recognized in Code diagnostics without hiding unrelated missing references. Named region layouts have a visual cell-assignment editor with row/column controls, coordinated renaming and region/content addition or removal. Bare region blocks support element insertion, moves and child property editing. Compiler-checked source edits preserve retained content and use one Undo transaction. Availability and recovery shows host authoring support, actual trust restrictions, required capabilities and unresolved imports. Inspect installed library locks without executing assets, open dependency tools, refresh current analysis across Code panes and reload the preview in Inspect mode. Private preview controls stage literal input/local batches, restore defaults with validation and revision checks, and manually advance native rule time. Uncertain clock acknowledgements require resetting the copy; browser timers retain real time. Computed button values can trigger rules through guarded private touches in preview copies and CHECK runs. Repeated clicks retain distinct identities; uncertain touches require reset. Named button cells also resolve in the live workbench. Save selected staged preview inputs or locals as a named source CHECK, retaining literal types, structured JSON, exact numeric strings and explicit default restorations. The checked insertion uses one Code Undo step; the saved setup reopens in a private preview. CHECK reset steps restore defaults through the existing fixture/local paths, and literal JSON/type constructors add no production calculations. The validation inspector follows plain aliases and direct component arguments to their declarations, and edits direct, nested and transitive component-local contracts through a named owner selector. Shared definition edits apply to every instance while local state stays private; imported locals remain in library source. Page controls copy, reorder and remove nested and flat page content while preserving View-wide declarations interleaved between page headers, including their attached comments and embedded payloads. Shared declaration order remains intact; the starting page follows page order. Inline named-region content appears as selectable children with text, bindings and contract properties. Structural and native event/slot edits expand the affected region automatically, preserving conditions, comments, multiline payloads and source Undo. Custom automatic PRESENT components expose shared options and checked explicit-use actions for caller-visible aliases. Closed composite argument lists retain shared labels/layout phrases, conditions, caller bodies and model access. Private library presentations explain their boundary; source changes may restart component-local preview state. Automatic tables and maps expose shared options and checked component conversion, preserving data bindings, columns, filters, paging and matrix headers. Setting-named columns gain explicit show prefixes in the same Undo step. Generated record forms retain their field lenses and Save action while opening shared options; the schema remains owned by the input or local declaration. Availability controls edit needs conditions and explanations as one checked source transaction. Supported controls and ordinary arrow actions expose paired fields; multiple and nested action requirements remain separate, with their actions, keys and refusal handlers preserved. Inline region actions expand and receive the requirement in one Undo step. Reusable Grid elements combine required argument fields with shared presentation and availability controls. Adding the first shared option preserves bare argument expressions and caller content; removing the last header option preserves remaining property continuations in the same source Undo step. Local and imported definitions remain unchanged. Ordinary action requirements can be added and removed individually from Properties. New requirements follow existing checks; removing a grouped requirement keeps its nested actions, other requirements, keys, refusal handlers, comments and multiline payloads in one Undo step. The inspector provides dedicated add/remove controls and cancellation for unfinished additions. Direct native arrows have a separate Action requirements section alongside component options. Add, update or remove paired conditions and explanations using the selected activation event’s values, preserving header availability, bindings, keys, nested actions and refusal handlers in one Undo step. Contract changes and unavailable host support cancel pending drafts. Named native and embedded event handlers expose individual requirement controls beneath their component options and when selected in the outline. Edits preserve each event’s scope, neighboring handlers, slots, nested steps and refusal actions; source navigation and Undo use the existing Code editor. Availability groups wrap supported blocks, including attached refusal actions, with a shared condition and explanation or page/View redirect. Update or remove the wrapper while preserving contents, comments, multiline payloads and separate visibility in one Code Undo step. Availability grouping across declaration scopes uses checked source review. Nested helper validation uses admitted instance provenance and retained source declarations, with definition paths in the owner selector. Repeated instances share one declaration entry; unused helpers and unconsumed caller content contribute none. Native slots and automatic component placements retain ownership. Edits preserve source, scope and Undo; imported locals remain in library source. Table and picker columns have compiler-owned add, update, remove and adjacent reorder controls. Edit display expressions, headings, format source, alignment, width and presentation, or switch to a keyed inline-edit field. Row actions, filters, paging, empty messages, comments and neighboring source are preserved; source navigation and Undo include inline-region expansion. The UI explains implicit all-field display, whole-input versus row-field validation and unsupported source forms. Literal table-column patterns now use the native TEXT formatter in the workbench, private previews, CHECKs and published Views. Bounded display batches retain dates, raw numeric sorting and edit values, cancel stale responses and expose retry; print/PDF and HTML capture respect pending or failed formatting. Record inspectors edit nested source defaults and add, rename or remove fields at proven input/local owners, preserving other fields, whole-record validation and Code Undo. Table and picker inspectors create keyed row actions, edit captions and inline bodies, manage row-scoped requirements, and move or remove whole action blocks with their nested steps and attached refusal handlers. Existing keys, visibility, comments and table settings remain in source, with one Code Undo transaction. Moves across repeater, page or declaration scopes now prepare a compiler-checked source review with Apply and Cancel. The review identifies affected scopes and carried declarations, preserves source payloads and comments, and applies the exact candidate through Code Undo only while the draft, model, partition and editor remain current. Declaration-owning availability groups now prepare wrapping and lifting through the shared source review with Apply/Cancel. Condition-only edits remain direct; invalid names, duplicate declarations and destinations are refused. Generic grouping is withheld for table row actions, whose requirements remain in the table editor. Failed CHECKs and private-copy setup now offer source and recovery controls; structured host refusals retain their meaning, stale outcomes clear, and model/environment changes return previews to Inspect. Code preview failures now have source-bound reports for script/library startup, SCRIPT callbacks and component rendering, with private-draft markers, bounded detached arguments and late-error isolation. Scalar Text, Metric, Stat and Badge patterns use native formatting with declared/host/line precedence, private local values, unit labels, bounded batching, cancellation and export readiness. Row-source validation now reaches table columns, row actions, pickers and repeated controls, preserving nearest-collection ownership, separate selected-value contracts, exact source/declaration navigation and checked Code Undo. Admitted aliases and View locals retain ownership; computed/native sources without a direct owner and bounded inventory overflow keep navigation with an explanation. These contracts apply to the whole collection, not individual rows or fields. Keyed row edits now follow plain aliases to named/cell inputs or defaults and native tables. Admission preserves the actual qualified owner, committed-source reads and exact row/event payload scope. Local shadowing, calculations, cycles, lazy/typed bindings and separate alias assertions do not grant unintended model writes. Checked column edits and the request picker example exercise alias ownership; local-array repeaters and live native acceptance remain outstanding. Local lists now admit stored-field keys, and literal, dotted-local, nested-row and synchronous JavaScript collections reach the shared Table/Repeater renderer with paging, empty states and print. Checked row-identity edits retain browser ownership; stable keys preserve Form drafts through reorder. Computed browser Grid expressions remain refused; local-array row editing remains open. Keyed row instances now own component and direct FOR-body locals for the open View lifetime, preserving values through reorder, paging and temporary removal. Inputs, actions, constraints, reset, native lenses/events and explicit glue aliases retain row identity. Nested state requires keys at every ancestor; missing or duplicate keys report an error. Properties edits the exact shared/local declaration, preserving same-named outer state. Compiler-produced canonical fixtures exercise the shared renderer. Local-array inline editing and wider native acceptance remain open. Numeric View inputs now use native section/precision/locale plans with the scalar format precedence. Resting display honors the pattern; focused editing retains full precision and display units. Untouched blur does not write. Active drafts keep their parsing units through format changes or retry; localized sliders keep machine values separate from display punctuation. Decimal affixes and scaling parse through bounded native hints, with explicit fallback/retry on older or unavailable hosts. Editable table/picker columns now retain literal format, heading, alignment and width through Code and Properties. Shared editors use native numeric plans, preserve draft units and untouched values, await keyed writes, and retain failed or conflicted drafts for explicit retry/reapplication. Sorting keeps each draft with its typed row key; editor keys do not select picker rows. Tables now inherit model FORMAT policies through retained row/range field tags and scalar roots. Native tag-lattice selection respects the most specific policy, reactive updates and explicit column overrides; active drafts keep their conversion plan. Exact numeric strings preserve their text under inherited numeric policies. Compiler-owned field metadata retains uniform declared tags in browser-local and replacement rows, preserves live refined tags, and carries policies into nested numeric record forms. Shared Form drafts keep one guarded Save and active units through policy changes. Local numeric literals reuse native lowering; decimal/bigint defaults retain exact text. Native tables and table views now use live column types and units for inherited model formats, with native currency/percentage/unit/date selection, explicit overrides, numeric blank repair and active-draft unit retention. Rows remain paged and writes retain their native keys. Generated date, date-time, text and boolean record fields now show native formatted readouts beside their original controls. Zoned date-time text, raw edits and one guarded Save are preserved. Pending formatting stays editable, stale results are discarded, failed requests can retry and print shares the selected display. Declared local arrays and arrays inside local records now support keyed inline edits, including lists owned by repeated elements. Compiler-owned private operations preserve vector shape, neighboring data, whole-local validation and model isolation. Sorting, paging, formats, print, reset and checked column Properties share the same renderer; conflicts keep drafts for reapplication. Compiled table captions survive the shared document boundary. Nested private tables now follow compiler-owned parent keys through multiple repeaters, stored record paths and component arguments. Updates select the current parent and child, preserve neighboring data and keep repeated component roots separate. The canonical private-orders example and checked nested column transaction cover this authoring path. Nested private row sources now expose their exact containing local contract in Properties, including read-only collections and repeated-body locals. Source navigation remains on the row expression, while checked validation edits target the whole owning declaration. The inspector explains that scope and cancels edits when it changes. Direct columns with dynamic schemas keep their row identity in Code diagnostics. Numeric inputs and table cells accept mixed/improper fractions and decorated accounting, scientific and scaled entry across native format sections, with ambiguity refusal, retained precision and draft-safe recovery. Private table record/list fields now open bounded JSON drafts with explicit Save/Cancel, current-value conflict review and retry. Keyed updates preserve neighboring fields; private row projection preserves nested pair lists and kind/value records. Array/object hints retain blank repair, and print shows JSON. Model input/default record lists now support bounded JSON field drafts with retained native types, exact/date text and matrix axes. Native record actions preserve typed keys and fields through the existing model rule and outcome. Hidden type changes cause conflicts; individual field contracts and native-host acceptance remain outstanding. Stored model record paths now support keyed scalar and structured table edits at the containing input/default. Current ancestors and neighboring rows survive. Code exposes checked column edits and the containing input contract, with distinct source/declaration navigation and reusable-owner ambiguity refusal. Tables inside keyed model rows and shared elements support scalar and record edits with native ancestor keys, retained drafts through reorder and atomic rejection of missing or duplicate keys. Shared definitions expose checked column controls and the containing input contract. Model text predicates and text/Boolean equality now reach controls with author messages; direct model operands and plain aliases read staged Form values. Invalid drafts stay visible, and dependency changes refresh field feedback and Save availability. Code edits the owning rule through checked source transactions. Computed operands retain committed native results; numeric/structured equality feedback and separate record/table field declarations remain unfinished. Native input batches validate their complete proposed state before committing any member, including computed operands and restored defaults. Detached ordinary calculation preserves live input/history/rule state and crosses the process-worker protocol. Unresolved/error operands and unsupported snapshot capabilities refuse the operation. Browser computed-draft feedback remains unfinished. Native proposed-input validation now reaches View Forms and standalone controls: Check values returns field messages without mutation, Save rechecks before commit, canceled or obsolete results cannot save, and rejected drafts remain. Private Code copies validate their owned session; packaged Views require model.write and each allowed input. Old/malformed hosts refuse; managed learning batches remain unsupported. Native runtime tests are authored but not executed; focused UI/transport coverage and syntax checks do not establish live-host or performance closure. Conditional record defaults and row sets now preserve only common nested field tags, and whole-row selection/reordering retains those tags. Generated Forms and tables preserve currency/percentage/date formatting; plain date rows retain their native formatting carrier without interpreting ordinary text. Code column override/removal remains a checked source edit. Use the computed field formats canonical example; unknown/conflicting schemas and computed local initializers retain their boundaries. Workbench navigation now protects live and private-copy Form drafts across page, surface, layer, tab, model and folder changes. Refused Grid-owned Back/Forward restores the history cursor; cross-surface page moves are atomic. Close/update protection includes registered drafts. Private copies receive only a host-local leave registration, never live bindings. Published/embedded host integration and live desktop closure remain to be assessed. Code preview page and mode controls now protect unsaved Form fields. Interactive page changes use the mounted View guard and wait for native parameter acknowledgement; failures retain the previous page and draft. Inspect pauses a live draft, canceled copy/CHECK switches keep their session, and explicit Reset/Reload still discard. Pending page preflight is canceled on mode/context changes and cannot resume writes or report into a later preview, even after returning to live mode. Already accepted writes are not undone. Published Views protect unsaved Forms through the owning app, with host leave prompts and outer browser history. Canceled moves and unloads retain the draft; initial and dirty/clean signals carry no field values. Newly published View runtimes require an updated host with navigation protection. React ejections and Vue/Svelte/Solid exports share mounted navigation and removal guards. Refused source/model/page changes retain drafts; route parameters wait for native acknowledgement. Hosts receive retained-path results and must check removal before unmount. Code preview selection now opens admitted model values and explicit WHY traces. Generated targets and dependencies show authored expressions and source lines; stale or ambiguous locations are withheld. Mounted Code previews now report failed model reads with source-linked markers and live-only value inspection. Native error objects and generated identifiers have readable details; private copies retain separate recovery. Named local SCRIPT helpers carry per-use component contract checks into Code, with source-linked result mismatches and distinct property-context versus asks-callback signatures. Native event contracts preserve admitted callback types for JavaScript completion and diagnostics. Declared event fields reach inline and named glue through the browser callback, with explicit USING precedence and independent Code metadata for identical expressions in different scopes. Built-in Kanban, Calendar and Map events expose fixed payload types and bounded known-row scalar hints to Code. Calendar end-column continuations are distinguished from closing END lines. Grid event handlers now check direct known-row fields and fixed scalar member reads in model/local updates, guards, notifications and navigation arguments. Code marks the authored expression; unknown/truncated rows and foreign callback shapes remain open, with lexical shadowing preserved. Grid event member completion offers the admitted row fields at the exact source suffix, preserves optional access, quotes nonidentifier names and respects lexical shadowing. Shared local element definitions offer only fields common to their uses. Imported event contracts now supply Grid completion for nested records and array items, retaining optional access and common union fields. View SCRIPT supports React element and component-valued helpers with compiler-retained language, source-mapped Code/CHECK diagnostics and prepared modules for preview, packaged Views and framework archives. React uses the renderer instance; library namespaces stay isolated. Native contracts select JSX adapters with contract-named props, lens pairs, tells, slots, explicit part attributes and availability state. Component imports use the View’s exact locked libraries. Hooks and refs retain identity. Existing lens conversions, Form staging and action guards remain authoritative. Code completes declared phrase/part names and marks invalid event calls. Library adapters retain definition scope, and phrasebooks can replace them locally. Imported helpers retain independent Code/CHECK contracts; full package declarations remain incomplete. Native Form and packaged-module acceptance is recorded in the audit ledger. Locked component imports now expose the native props retained by their admitted contracts in Code and CHECK. Per-View declarations supply JSX completion, hover and source-linked errors without leaking names or versions. Unknown exports/imports remain errors; full package types, requiredness and unmapped props remain outside this projection. Code exports portable reusable ELEMENTs as .gridui packages with explicit parameter types, compiler preparation and review before download. Code imports selected App package components through compiler-checked source review, insertion and Undo, staging the draft for explicit Save. Selected component import/export preserves library metadata in source and reviews retained types, labels, descriptions and defaults in Code. Code also shares independent stateful ELEMENTs as .gridcomponent source packages, with reviewed imports and per-instance state/action recompilation. Code import can create a complete bound View instance with compiler-checked parameters, separate native rules, source review and one staged Undo transaction. App conversion uses one distinct page-name plan for declarations and navigation, with reserved names, case/slash route matching, explicit duplicate-route gaps and home-first source order. Code shows original/generated page identities, routes, positions and native source links; changed identities and order remain in the comparison. Repeated App and saved View instances keep mounted control labels, descriptions, action help, tab panels and page headings distinct. Keyed row movement and value updates retain those relationships while Code keeps shared compiler identities. Source component export bundles local element helpers transitively as private nested declarations, including custom PRESENT controls. Code and App Builder review native helper names and complete source before saving. Nested precedence, embedded payloads and receiving-model helper identities are retained, while per-instance local state and actions compile normally. Local named actions now travel with source components, including transitive calls and callbacks passed through elements. Code/App reviews list actions separately; native capture checks and exact action-call recognition retain formula and model boundaries. App-to-Code library conversion assigns distinct declaration names for display names, View keywords, standard controls and receiving-model/case conflicts. Component mapping reviews original names and IDs, generated names, unsupported templates and native source links. Source-owned library metadata survives; future exports use current Code names. Selected component instances link to their compiler-owned shared declaration; imported definitions identify the owning library and open the caller USE statement or dependency tools. Custom PRESENT controls retain private and transitive ownership, and stale analysis disables links. New View creation retains Whole model and the new inspector, using one rich-Code insertion and Undo step while preserving earlier editor history. Source autosync stays paused until explicit Save; stale or refused editor changes do not stage a draft. Reviewed App conversions use the same single rich-Code Undo transaction, with a cancellable handoff while the editor loads. Source, App, model, partition and dependency changes retire the insertion; refusals never retry automatically. Whole model and its new inspector stay together until explicit Save. Page names now have a checked Properties refactor: Whole model access, local/cross-View navigation and CHECK updates, preserved titles and URLs, compiler rejection of ambiguous or changed navigation, and one rich-editor Undo transaction. Repeated buttons and named native events preserve sibling ELSE refusal handlers; Code updates/removes those blocks with their owning event and keeps implicit body content separate. Code CHECK controls now run one check or retry failures, publish progress after private-copy cleanup, and cancel without accepting late results. Unrelated results survive a subset retry; source and environment changes retire them. Cancellation retains admission identity for cleanup, and failing-step links stay inside the owning CHECK. Recursive imported data contracts retain nested Code/compiler types. Native View errors retain author locations. Source components carry closed local/imported Grid function dependencies, and App migration retains node/library/workbench identity and saved View placements with nested Form navigation protection.

Run a guided agent debate in Desktop — 0.66.8

Author a sequential team conversation, bind its models, start it from the Processes panel and inspect attributed replies and the chair’s typed conclusion.

Combine installed API reads with agents — 0.66.8

Read a service from a process, share its checked response with an agent, and inspect the combined result through Desktop.

Review collections with sequential agent processes — 0.66.8

Use EACH for ordered per-item reviews or WITH for a running summary, with continuing agent history and inspectable results.

Coordinate isolated reports before an editorial decision — 0.66.8

Use INDEPENDENTLY EACH with fresh child processes, then pass ordered reports to an editor through Desktop process controls.

Follow process conversations while they run — 0.66.8

Read each finished reply in Processes while later turns are still running. Browse earlier turns or follow the latest, and retain accepted replies after cancellation.

Choose a procedure during a workflow — 0.66.8

Bind a Boolean choice between known procedures, then run only the selected child through Desktop Processes.

Revise a draft with a human editor — 0.66.8

Accept, revise or decline an agent draft through Desktop Processes; set time and model-call limits at Start and inspect actual usage.

Scientific method disclosure and useful solver errors — 0.66.5

Portable molecular records identify their proxy status; nonlinear solver errors retain explanations; strict dimension errors retain source locations; guarded chemistry examples declare input assumptions.

Explicit PCA methods and dependable biology authoring — 0.66.5

Select centered PCA explicitly, preserve existing uncentered scores, recover collection checkpoint residency when saving, and learn motif functions from meaningful examples.

Engineering units and trustworthy calculation feedback — 0.66.5

Use petroleum units, inspect chart sources, and understand root-solver failures and nonconvergence.

Recalculable spreadsheet handoff and documented PDE controls — 0.66.5

Preserve supported named calculation dependencies in Excel, choose a static values export, and use the documented PDE options record.

Petroleum starters and simpler chart authoring — 0.66.5

Open guarded engineering starters, expose calculations as outputs, and plot named numeric vectors with visible bindings.

Named molecular property workflow — 0.66.5

Choose a named molecular property method, inspect saved results with units and provenance, retain exact external decimal values during digest verification, and report batch progress in completed molecules.

Guarded laboratory inputs and readable biological data — 0.66.5

Review matrix axes and labels before import, preserve missing laboratory measurements, and inspect peptides, ORFs, alignments, and observation totals with clear placement status.

Complete biology research starters and clearer failures — 0.66.5

Start a guarded qPCR study, fit enzyme kinetics with residuals, or inspect sequences and ORFs; recover from numerical and sequence errors and use names that preserve cell identity.

Variant safeguards and scientific archive restoration — 0.66.5

Distinguish passed and unfiltered variants, reject invalid allele references, and restore content-addressed scientific analysis Frames with their integrity checks intact.

Named expression comparisons and readable scientific results — 0.66.5

Choose Welch t or the legacy normal reference, retain content-bound analysis assumptions, and inspect paged DE, read-quality and embedding results.

Reviewed matrix imports and portable research starters — 0.66.5

Paste and review scientific data, use versioned matrix and embedding operations that older runtimes refuse, and explore discoverable expression, matrix and variant starters.

Inspect nonlinear fitting results — 0.66.5

Request named coefficients, residuals, the actual stopping reason and local rank diagnostics, with readable fitting reports and an adsorption example.

Request local parameter uncertainty — 0.66.5

Explicitly request approximate nonlinear-fit standard errors, covariance and individual confidence intervals, with declared observation-noise assumptions and unavailable-result explanations.

Fit observations with unequal precision — 0.66.5

Supply relative weights or known observation errors, inspect raw and weighted residuals separately, and explicitly select the matching local parameter intervals.

Understand nested-array transposes — 0.66.5

Source-local matrix advice explains nested-array transposes, preserves unknown input shapes, and remains visible in cell checks after Unicode source text.

Read ODE methods, work and terminal states — 0.66.5

An explicit ODE_REPORT record format presents the actual solver method, local controls, numerical work and terminal state in the result inspector, with a stiff-kinetics tolerance comparison.

Understand, compare and reproduce operations research decisions — 0.66.5

Expose truthful nonlinear completion and labeled LP/MIP/flow reports, enforce explicit optimization inputs, prototype named formulation authoring, compare immutable scenarios, and export checked teaching studies.

Aerospace starters and explicit physical-scale checks — 0.66.5

Review unit-scale conflicts, understand root failures, and expose named results in aerospace models.

Fit within explicit parameter limits — 0.66.5

Declare lower and upper parameter limits or fixed values, inspect active boundaries and constrained stationarity, and compare assumptions in an adsorption example.

Checked finance models and explicit numerical methods — 0.66.5

Reject incomplete portfolio inputs, bootstrap regular coupon curves with repricing reports, handle option-price limits, and provide checked finance starters with scenario review and method disclosure.

Inspect calendar-safe economics and explicit regression inference — 0.66.5

Work with calendar-aligned economic series, inspect missing and incomplete periods, and export clearly labeled regression comparisons. Reviewed input editing, safer Save and Undo, and recovery-aware results preserve accepted work and prevent delayed replies from replacing newer models or edits.

Inspect seeded resampling uncertainty — 0.66.5

Refit simulated normal observations with declared weights and bounds, inspect every failure, and compare marginal percentile intervals with explicit noise assumptions.

Explain derivative methods and finish scalar searches honestly — 0.66.5

Inspect the actual derivative method and fallback, receive explicit scalar search exhaustion errors, and explore three applied mathematics workflows with editable assumptions.

Check physics results and recover from numerical failures — 0.66.5

Explore nine physics starters with bounded assumptions, unsmoothed plots and independent checks; preserve plots of named arrays, read compact reports, distinguish source warnings from errors, and recover from explained ODE failures.

Reuse admitted model properties and refresh named input warnings — 0.66.5

Repeated result reads reuse immutable workflow and coercion properties. Input edits refresh coercion warnings for named-cell models, including actor updates, and numeric corrections clear obsolete warnings.

Refresh named cells without repeatedly scanning large arrays — 0.66.5

Named-cell refreshes share source-reference analysis within each update, reducing repeated work when input edits refresh models containing large inline datasets.

Keep delayed named results in their owning model — 0.66.5

Named-result refreshes, including I/O and reactive-surface bindings, reject replies from a superseded model, worksheet, partition, source, input revision or model opening before publishing them.

Avoid repeated full-sheet height calculation — 0.66.5

Uniform grids select a single height through the existing density and zoom rules. Custom-height and hidden-row layouts retain the existing callback.

Typed surface blocks and readable examples — 0.66.4

Surface configuration uses TOML, YAML, or JSON blocks; embedded source uses its language tag.

Shared documentation and release history — 0.66.4

Documentation sites and the in-app reference share release explanations and featured capability guides.

See the changelog for release history and clearly labeled upcoming changes.