Refine functions on zoom

[bewuwy]

Currently, functions are rendered once, for one resolution. It would be nice to re-render them when the user zooms in. Lines should be thinner then.

Generally, a "math zoom" would be better than a "physical zoom".

Maybe could be done using scaleX/scaleY ?. However, currently changing them does not change anything dynamically.

[bewuwy]

This was generated by AI during triage.

Agent Brief

Category: enhancement (render quality on zoom)
State: ready-for-agent
Label: none — 2D-layer primitive change, not an applet.

Summary: Function curves are sampled once at a fixed resolution and their strokes scale with zoom, so zooming in gives jagged curves and thick lines. Make the three function primitives re-sample and keep constant stroke width as the user zooms — without changing the zoom model (no "math zoom" rework; the maintainer explicitly ruled that out as too large).

Current behavior:
2D zoom is physical: the scene sits inside scale(cameraZoom) × d3 scale(k) groups, so everything — including stroke widths — scales with zoom, making lines thick when zoomed in. ExplicitFunction2D/ImplicitFunction2D/ParameterizedFunction2D sample their domain once over a fixed range (±GRID_SIZE_2D) at a fixed stepSize, so zooming in under-samples the visible slice → visibly jagged curves. CanvasD3 already tracks the zoom reactively (currentCameraTransform, a $state, updated on every zoom; and the debounced cameraState.camera2D), but these primitives don't consume it (the "changing scaleX/scaleY does nothing dynamically" the issue notes).

Desired behavior (scope: the three function primitives only — ExplicitFunction2D, ImplicitFunction2D, ParameterizedFunction2D):

Constant-on-screen stroke width:

• Stroke width becomes width = LINE_WIDTH / totalZoom, where totalZoom is the effective on-screen zoom (d3 k × cameraZoom), so lines keep a constant pixel thickness at every zoom instead of ballooning.
• Include a single tunable multiplier (to nudge lines thinner globally) and a minimum-width floor (so strokes never vanish at extreme zoom).
• Drive stroke width from the live zoom signal (currentCameraTransform, per-frame) so it tracks a zoom gesture without lag. (Fallback: if the live signal causes jitter/perf issues, drive it from the debounced settled zoom instead.)

Re-sample on zoom:

• Re-sample the curve from the debounced settled zoom (cameraState.camera2D) — re-running the adaptive sampling every frame during a continuous zoom would thrash the CPU; re-sample once when the zoom settles.
• Domain:
  • ExplicitFunction2D — re-sample over the currently-visible x-window (derived from the settled transform), expanded by a ×1.5 margin so small pans don't re-trigger and edges stay covered; clamp to the existing valid range.
  • ImplicitFunction2D — same idea over the visible 2D box (x and y windows + margin).
  • ParameterizedFunction2D — a parametric curve samples over t, which cannot be clipped to a visible x/y window; keep the full t-range but increase t-sampling density with zoom. No window clipping here.
• Resolution: scale sampling density with zoom to hold roughly constant screen-space density — effective stepSize (and minStep) = base / totalZoom (denser as you zoom in). Clamp with the existing perf guards (maxDepth/minStep/evaluation budget) so a deep zoom can't blow up the sample count.

Key interfaces:

• Expose the reactive zoom to these primitives: a live totalZoom (from currentCameraTransform), the settled zoom (from cameraState.camera2D), and enough of the transform to derive the visible domain — via context from CanvasD3 or the camera store. AxisLabels.ts already back-derives world coordinates from the same transform; reuse that approach for the visible-window computation.
• ExplicitFunction2D / ImplicitFunction2D / ParameterizedFunction2D — consume the settled zoom for re-sample domain/resolution and the live zoom for stroke width.
• The stroke-width computation (LINE_WIDTH / totalZoom × multiplier, floored) — a small shared helper is fine, but only these three primitives use it in this issue.

Acceptance criteria:

• On the three function primitives, stroke width stays visually constant (crisp, not thick) across the zoom range; a min floor keeps it visible at deep zoom; the multiplier tunes global thickness.
• Zooming into ExplicitFunction2D/ImplicitFunction2D re-samples over the visible window (+margin) so the curve is smooth at high zoom, not jagged.
• ParameterizedFunction2D increases t-density with zoom (full t-range retained) and its stroke thins per the same law.
• Re-sampling happens on settled zoom (not every frame); a continuous zoom gesture stays responsive.
• Deep zoom does not exceed the existing sampling/perf budget (clamps hold).
• No change to the zoom transform model; other primitives and applets are unaffected.

Out of scope:

• The "math zoom" architectural rework (explicitly declined).
• Any primitive other than the three named functions (other stroke primitives keep current behavior in this issue).
• Axis-label sizing under zoom (Axis labels are bad with zoom #478) and the Projection2D seam (Deepen the 2D scale transform into a Projection2D seam #491) — related but separate.

Decisions recorded (triage grilling): scope = the 3 function primitives; live stroke + debounced re-sample (fallback debounced-both); constant-on-screen stroke LINE_WIDTH/totalZoom + multiplier + floor; re-sample visible-window+×1.5-margin at zoom-scaled density with existing clamps; parametric samples t-density only (no window clip); no math-zoom rework.