Features

The helper wraps browser clipboard text reads/writes and consistent JSON serialization/parsing. It does not invent an application data format, retain clipboard history, or silently fall back when browser permission is unavailable.

The helper maps application values into explicit color arrays without owning palette selection, dataset meaning, or rendering. Numeric scales interpolate or quantize; categories use declared order or deterministic hashing. Diverging scales can define an explicit achromatic midpoint plus one shared center-influence ramp for tone and opacity. Legend metadata comes from the same scale used by the renderer.

Point positions and values are generated once with deterministic-random.js; the selected scale changes only their color encoding. Diverging mode keeps an explicit achromatic center RGB and uses one symmetric sigmoid-like Ramp tightness profile for both tone and opacity: higher tightness confines Center-tone influence to a narrower region around zero, while lower Center opacity applies a transparency mask with that same shape. At 0% Center opacity, premultiplied interpolation prevents the center RGB from tinting nearby visible values. The legend uses the same color/opacity mapping as the points and exposes transparency over a checkerboard substrate. The specimen consumes the active rendered perceptual palette, including color-vision assistance, without making the scale helper theme-aware.

Editing mode is page-local, but overrides live in one application-wide browser store. Edit this paragraph, move to Styles or the app page, edit another eligible block, then use the filled Save as icon in the status bar: one JSON file carries every local edit across pages with its exact source file/anchor, role, authored original, replacement content, and originating app version.

Markdown-backed info dialogs register their source file as the stable block identity, so editing the same information popup from any page updates the same site-wide override. Nothing in this workflow writes back to the web server.

The binding layer removes repetitive native-control plumbing without owning persistence or application state. Change a control to update the state object; use Programmatic update to change the state first and synchronize all controls back from it.

The framework binding owns event wiring, native value parsing/writing, output synchronization, radio-group synchronization, and teardown. The application still decides where state lives, whether it persists, and what rerenders after a change.

Actions can report a compact semantic result without inventing a new status treatment. The controller owns the live-region presentation and optional auto-clear timer; the application still owns the action and its durable state.

The framework owns file validation, text reading, and browser download plumbing. This specimen uses CSV as a lightweight parser example, previews bounded rows through the shared scientific-table contract, and keeps the complete parsed dataset available for export.

Choose a CSV file or load the embedded example.

The helper stores cloned snapshots while the application keeps ownership of live state, rendering, and persistence. Drag the slider: all intermediate input events are grouped into one undo step. A new edit after Undo clears the redo branch.

History is intentionally outside persistence and snapshots. Applications choose which state is worth recording, when a transaction begins/ends, and whether a restored snapshot should itself become a history step.

The shared model standardizes only the recurring display-state shell. Layer meaning, render order, geometry, style vocabulary, persistence, and snapshot-domain ownership remain application decisions.

This state is snapshot-eligible only when the application classifies it as reproducibility-relevant. For one app it may belong to Application; for another, a document-specific layer configuration may belong to Content.

Pages that declare the markdown runtime can mix ordinary HTML with <md-block> regions. Markdown headings are assigned stable anchors and participate in the existing page TOC after rendering.

<md-block>
        ## Section

        A paragraph with **bold**, *italic*, `code`, and [a link](../methods/).

        ### Subsection

        - one
        - two
        </md-block>

Use ## for top-level Markdown sections on ordinary pages, ### for TOC subitems, and #### for third-level TOC items. The framework-owned page title remains the document H1.

The site generator resolves inherited page metadata, crawler policy, social metadata, sitemap eligibility, and generic structured data once. This report surfaces missing or duplicate core fields and contradictory discovery state without copying the full metadata catalogue into the eager application runtime.

Common scientific presentation modes share missing-value, infinity, sign, and locale-safe handling.

A page declares only the optional runtime environments it needs. The central registry owns their resources; page-local controller scripts remain under wrapper.scripts. Runtime environments are not inherited through the hierarchy and are loaded only on requesting pages.

"runtime": {
          "// environments": "\"a\" or [\"a\", \"b\", ...]. Use [] for none.",
          "environments": ["mathjax"]
        }

The Mathematics specimen requests mathjax and demonstrates both browser-native MathML and MathJax TeX. External runtime failure never prevents the normal application shell from starting.

A shared controller anchors compact non-modal UI to either a DOM trigger or an application-supplied virtual screen-space rectangle, flips and clamps it inside the viewport, and closes on outside click or Escape. This specimen uses a DOM trigger, so it also maintains aria-expanded and restores trigger focus; Selection and inspection demonstrates virtual-anchor use.

Preset libraries are intentionally separate from snapshots. The application chooses the captured payload, factory presets remain immutable, user presets are save/replace/delete entries, and import/export travels through a smaller named preset envelope rather than the snapshot transport.

{}

No preset selected.

The same seed and algorithm identifier reproduce the same pseudo-random sequence. Applications can store the seed and algorithm with snapshots, fingerprints, or scientific provenance instead of serializing every randomized result.

Repeated resize, control, layer, pan, zoom, and style changes can request work freely while the scheduler collapses them into one render callback per animation frame. Reasons and dirty keys are preserved as hints; the application still decides what state changed and what must actually be redrawn.

The shared model tracks transient hover, ordered selected IDs, and one primary selection while the application retains object identity, hit testing, rendering, inspection content, persistence, and snapshot semantics. Ordinary activation replaces the selection; Shift/Command/Control activation demonstrates additive toggle behavior.

Virtual anchors let renderer-owned marks open the same viewport-aware popover without requiring the rendered point itself to provide DOM geometry. This SVG specimen deliberately derives a screen-space rectangle from application point data; Canvas, WebGL, charts, and sky maps can supply the same contract.

One snapshot envelope can carry several independently versioned state domains. Capture the current interface, the Controls specimen state, and an example content fingerprint; change any of them, then restore only the domains you select.

No snapshot captured yet.

Snapshots are not presets. Snapshots are portable reproducible state envelopes and may include interface, application, and content together. Presets are now a separate named-library workflow that can reuse the same domain capture/validation adapters while choosing its own subset and lifecycle.

Native table markup stays the baseline. Numeric columns are right-aligned with tabular figures, headers stay visible while scrolling, missing observations sort last, and selected rows retain a clear theme-aware state.

Table values inherit the global display precision; Signal uses a local 3-decimal column override.

The controller gives each run a request id, requests cancellation of the previous run through AbortSignal, and still suppresses an older result if that task ignores abort. Applications own the actual network/computation task, retry policy, result meaning, presentation, persistence, and whether a completed result changes application state.

Abort is cooperative optimization, not correctness. The request-id/latest check is the correctness boundary: an obsolete task may finish, reject, or ignore its signal, but it cannot become the current committed result.

The shared controller owns input mechanics and lifecycle only. It reports screen-space pan deltas and focal-point zoom factors; the application decides whether those gestures move Cartesian coordinates, a camera, a celestial projection center, or another domain-specific view.

The host owns responsive geometry and standard loading, empty, and error presentation while the application keeps complete control of the renderer. Export helpers prepare standalone SVG or raster PNG output at an explicit scale/density without taking ownership of the scene or the browser download action.