@changfenhuang/dsh-genui 0.9.1

package/src/client/panel.tsx

@@ -0,0 +1,185 @@
+/**
+ * Session GenUI panel: the dock surface that renders the latest `render_ui`
+ * spec IN PLACE. The toolview publishes every new result into the panel
+ * store; this component subscribes and re-renders the same block, so a
+ * refresh (model calls render_ui again) updates the panel instead of the
+ * message flow accumulating new UI per round.
+ *
+ * Mounted through the 'conversation.input.dock' list slot (TodoDock posture)
+ * — a session-scoped, always-present seat above the composer — so the panel
+ * coexists with the message flow on one screen. Absent spec = no panel.
+ *
+ * The dock is COLLAPSIBLE (TodoDock pattern), defaulting to a one-line
+ * header: a tall always-open panel pins above the composer and crushes the
+ * message flow's visible area, making history feel unreachable. Collapsed,
+ * it takes a single row; expanded, the body caps its height and scrolls
+ * internally, so the conversation stays scrollable either way.
+ *
+ * The expanded body is vertically RESIZABLE: a drag strip between the header
+ * and the body adjusts the body height (clamped to sane bounds); the custom
+ * height survives expand/collapse cycles for the session's life.
+ *
+ * Actions ride the same GenuiActionContext contract as inline fences: the
+ * sendGenuiAction injection (built from the scoped conversation service in
+ * apply) queues a [genui-action] user message back to the model.
+ */
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from 'react'
+import type {} from '@deepseek-ai/dsh-client-runtime/client'
+import { GenuiActionContext, type GenuiActionHandler } from './action-context.ts'
+import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
+import { GenuiBlock } from './GenuiBlock.tsx'
+import { ErrorBoundary } from './ErrorBoundary.tsx'
+import { panelStateKey } from './interaction-store.ts'
+import { clearSessionPanel, getPanelExpandToken, getPanelSpec, setLocalPanel, subscribePanel, subscribePanelExpand } from './panel-store.ts'
+import css from './GenuiBlock.module.css'
+
+/** Resize bounds for the panel body, in px. */
+const PANEL_HEIGHT_MIN = 120
+const PANEL_HEIGHT_MAX = 600
+
+/** Injection face built per session in apply (scoped conversation send). */
+export interface GenuiPanelInjected {
+  sessionId: string
+  sendGenuiAction: GenuiActionHandler
+}
+
+export type GenuiPanelProps = PropsRuntime<'conversation.input.dock'> & GenuiPanelInjected
+
+/**
+ * Panel dock entry. Renders nothing until the session's toolview published a
+ * spec; afterwards the SAME block re-renders on every publish. Collapsed by
+ * default so the dock never steals the message flow's scroll room; the
+ * header always shows the current panel title.
+ */
+export function GenuiPanel({ sessionId, sendGenuiAction }: GenuiPanelProps) {
+  const spec = useSyncExternalStore(subscribePanel, () => getPanelSpec(sessionId))
+  const expandToken = useSyncExternalStore(subscribePanelExpand, () => getPanelExpandToken(sessionId))
+  const [collapsed, setCollapsed] = useState(true)
+  // Custom body height from the resize drag; null = the CSS default (360px).
+  const [bodyHeight, setBodyHeight] = useState<number | null>(null)
+  const [resizing, setResizing] = useState(false)
+  const dragStart = useRef<{ y: number; height: number } | null>(null)
+  const bodyRef = useRef<HTMLDivElement | null>(null)
+
+  // Explicit expand requests (the /panel command) open the dock even when the
+  // user collapsed it manually: the monotone token guarantees a fresh request
+  // is never mistaken for the previous one.
+  useEffect(() => {
+    if (expandToken > 0) setCollapsed(false)
+  }, [expandToken])
+
+  // Session teardown: the dock is session-scoped, so unmount means the host
+  // pruned or destroyed the session's scope. Release the session's panel
+  // state (snapshot, ops, overflow diagnostics, expand token) — without this
+  // the module-level store grows one entry per session for the app's whole
+  // lifetime. A reopen lazily rebuilds from history replays, which is the
+  // host's own lifecycle contract.
+  useEffect(() => {
+    return () => {
+      clearSessionPanel(sessionId)
+    }
+  }, [sessionId])
+
+  // Cleanup safety net: if the component unmounts mid-drag (spec cleared),
+  // the window listeners must not outlive it.
+  useEffect(() => {
+    if (!resizing) return
+    return () => {
+      dragStart.current = null
+    }
+  }, [resizing])
+
+  /** Start a vertical resize drag on the panel's top edge. Dragging UP grows
+   * the panel (the edge moves toward the message flow); dragging down shrinks
+   * it. Pointer capture binds move/up/cancel to the HANDLE, so dragging past
+   * the element edge keeps tracking and nothing global is registered — no
+   * window listeners, nothing to leak on unmount. */
+  const startResize = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    e.preventDefault()
+    const handle = e.currentTarget
+    // Track from the current committed height (state mirrors the drag, the
+    // CSS default otherwise) — no DOM measurement needed.
+    const startHeight = bodyHeight ?? 360
+    dragStart.current = { y: e.clientY, height: startHeight }
+    setResizing(true)
+    try {
+      handle.setPointerCapture(e.pointerId)
+    } catch {
+      // jsdom / capture unsupported: listeners below still track the drag.
+    }
+    const onMove = (ev: PointerEvent): void => {
+      const start = dragStart.current
+      if (start === null) return
+      // Upward drag (clientY decreasing) grows the body height.
+      const next = Math.min(PANEL_HEIGHT_MAX, Math.max(PANEL_HEIGHT_MIN, start.height + (start.y - ev.clientY)))
+      setBodyHeight(next)
+    }
+    const onUp = (): void => {
+      dragStart.current = null
+      setResizing(false)
+      handle.removeEventListener('pointermove', onMove)
+      handle.removeEventListener('pointerup', onUp)
+      handle.removeEventListener('pointercancel', onUp)
+    }
+    handle.addEventListener('pointermove', onMove)
+    handle.addEventListener('pointerup', onUp)
+    handle.addEventListener('pointercancel', onUp)
+  }, [bodyHeight])
+
+  if (spec === null || spec.items.length === 0) return null
+  return (
+    <div className={css.panel} data-genui-panel>
+      {/* Resize grip on the panel's TOP EDGE (above the header): the drag
+          target the user described — the outermost top border, not a strip
+          under the title. */}
+      {!collapsed && (
+        <div
+          role="separator"
+          aria-orientation="horizontal"
+          aria-label="调整面板高度"
+          className={`${css.panelResizeHandle}${resizing ? ` ${css.panelResizeHandleActive}` : ''}`}
+          onPointerDown={startResize}
+        />
+      )}
+      <div className={css.panelHeader}>
+        <button
+          type="button"
+          className={css.panelToggle}
+          aria-expanded={!collapsed}
+          onClick={() => setCollapsed(c => !c)}
+        >
+          <span className={css.panelBadge}>面板</span>
+          <span className={css.panelTitle}>{spec.title ?? 'GenUI 面板'}</span>
+          <span className={css.panelChevron} aria-hidden>{collapsed ? '▸' : '▾'}</span>
+        </button>
+        {/* In-place dismiss (issue #23): the same local override `/panel
+            clear` applies — persists to localStorage, notifies subscribers,
+            unmounts the dock without any navigation or reload. */}
+        <button
+          type="button"
+          className={css.panelClose}
+          aria-label="关闭面板"
+          title="关闭面板"
+          onClick={() => setLocalPanel(sessionId, null)}
+        >
+          <span aria-hidden>✕</span>
+        </button>
+      </div>
+      {!collapsed && (
+        <div
+          ref={bodyRef}
+          className={css.panelBody}
+          data-genui-panel-body
+          style={bodyHeight === null ? undefined : { height: bodyHeight }}
+        >
+          <GenuiActionContext.Provider value={sendGenuiAction}>
+            <ErrorBoundary label="面板">
+              {/* content-fingerprinted: same panel spec re-published restores its state */}
+              <GenuiBlock spec={spec} stateKey={panelStateKey(sessionId, JSON.stringify(spec))} />
+            </ErrorBoundary>
+          </GenuiActionContext.Provider>
+        </div>
+      )}
+    </div>
+  )
+}

package/src/client/parse-partial.ts

@@ -0,0 +1,162 @@
+/**
+ * Partial GenUI spec parsing: extract the components that are already
+ * complete from a still-growing ```dsh-ui fence body, so the UI can render
+ * top-down as the model writes — each finished component appears the moment
+ * its JSON object closes, instead of the whole block waiting for the fence.
+ *
+ * Strategy (tolerant, white-list-agnostic, BOUNDED):
+ * 1. Full parse first (the common settled case) — at most one.
+ * 2. ONE left-to-right scan collects the repair candidates: every position
+ *    where the prefix is bracket-balanced (trailing comma / fence tail) and
+ *    every `}` object close within the depth budget (an unfinished trailing
+ *    element, closed by appending the remaining brackets). The ring buffer
+ *    keeps only the longest-direction candidates (≤ MAX_PARTIAL_REPAIR_ATTEMPTS),
+ *    so the work is O(n) with a hard parse-attempt cap — a pathological
+ *    input can never re-scan prefixes or burn seconds in JSON.parse.
+ * 3. Candidates are tried longest first; the first that parses as a GenUI
+ *    spec wins. Nothing parses → null (streaming partial, wait for more).
+ *
+ * The result is only ever a PREFIX of the intended spec, so it is always
+ * safe to render: components already present are complete and valid.
+ *
+ * `ponytail:` the 32-candidate / 33-parse budget is the protection ceiling
+ * for depth 8 / 200 nodes; only real streaming samples proving a recovery
+ * shortfall justify switching to a tokenizing parser.
+ */
+import { GENUI_LIMITS } from './guard.ts'
+import { isGenuiSpec, type GenuiSpec } from './spec.ts'
+import { wrapSingleComponentRoot } from './spec.ts'
+
+/** Default repair-candidate budget (adjustable; see the design doc). */
+export const MAX_PARTIAL_REPAIR_ATTEMPTS = 32
+
+let repairAttemptsLimit = MAX_PARTIAL_REPAIR_ATTEMPTS
+
+/** Override the repair-candidate budget (tests / tuning). */
+export function setMaxPartialRepairAttempts(n: number): void {
+  repairAttemptsLimit = n
+}
+
+/** One repair candidate: a balanced prefix of the body ending at `end`,
+ *  plus the closing brackets to append (empty when already balanced). */
+export interface PartialCandidate {
+  end: number
+  closingSuffix: string
+}
+
+/** Single left-to-right pass over the raw body. Tracks the bracket stack
+ *  (skipping strings/escapes correctly) and records:
+ *  - every position where the prefix is fully balanced (trailing comma or
+ *    fence tail) — candidate with an empty closing suffix;
+ *  - every `}` object close whose remaining depth fits the spec budget —
+ *    candidate with the remaining brackets closed (an unfinished trailing
+ *    element).
+ *  Candidates are ring-buffered to the attempts budget (the LAST pushes are
+ *  the longest), then returned longest-first, deduplicated by end. The scan
+ *  stops at the first unbalanced close — earlier balanced prefixes remain
+ *  valid candidates.
+ *
+ * Exposed for tests (the `scannedChars` diagnostic); not exported from the
+ * package entry. The parser calls this exactly once per parse.
+ */
+export function collectPartialCandidates(raw: string): { candidates: PartialCandidate[]; scannedChars: number } {
+  const stack: string[] = []
+  const candidates: PartialCandidate[] = []
+  const push = (c: PartialCandidate): void => {
+    if (candidates.length >= repairAttemptsLimit) candidates.shift()
+    candidates.push(c)
+  }
+  let inString = false
+  let escaped = false
+  let scanned = 0
+  for (; scanned < raw.length; scanned++) {
+    const ch = raw[scanned]!
+    if (inString) {
+      if (escaped) escaped = false
+      else if (ch === '\\') escaped = true
+      else if (ch === '"') inString = false
+      continue
+    }
+    if (ch === '"') {
+      inString = true
+      continue
+    }
+    if (ch === '{' || ch === '[') {
+      stack.push(ch)
+      continue
+    }
+    if (ch === '}' || ch === ']') {
+      const open = stack.pop()
+      const expects = ch === '}' ? '{' : '['
+      if (open !== expects) {
+        // Unbalanced (mismatched or stray close): the tail is unusable, but
+        // balanced prefixes recorded earlier stay valid. Stop scanning.
+        break
+      }
+      if (ch === '}' && stack.length <= GENUI_LIMITS.maxDepth) {
+        // A finished object element: closing the remaining brackets yields
+        // the longest legal prefix (an unfinished trailing element drops).
+        push({ end: scanned + 1, closingSuffix: closeSuffix(stack) })
+      }
+      if (stack.length === 0) {
+        // Whole prefix balanced: a complete-JSON candidate (trailing comma /
+        // fence tail cases).
+        push({ end: scanned + 1, closingSuffix: '' })
+      }
+      continue
+    }
+  }
+  candidates.sort((a, b) => b.end - a.end)
+  const deduped: PartialCandidate[] = []
+  for (const c of candidates) {
+    if (deduped.length === 0 || deduped[deduped.length - 1]!.end !== c.end) deduped.push(c)
+  }
+  return { candidates: deduped.slice(0, repairAttemptsLimit), scannedChars: scanned }
+}
+
+/** Closing brackets for the remaining open stack (top first). */
+function closeSuffix(stack: string[]): string {
+  let suffix = ''
+  for (let i = stack.length - 1; i >= 0; i--) suffix += stack[i] === '{' ? '}' : ']'
+  return suffix
+}
+
+/** Try to parse a candidate as a GenuiSpec. */
+function trySpec(candidate: string): GenuiSpec | null {
+  try {
+    const value: unknown = JSON.parse(candidate)
+    if (isGenuiSpec(value)) return value
+    // Single-component roots are part of the documented fence vocabulary
+    // (e.g. a bare {"type":"callout",…} body) — wrap into a col so the
+    // items-gated pipeline renders them (panel/append hoisted).
+    return wrapSingleComponentRoot(value)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Parse a possibly incomplete genui spec body.
+ * @param raw - the fence body as accumulated so far.
+ * @returns a spec containing only finished components, or null when nothing
+ *   usable has been written yet.
+ */
+export function parsePartialGenuiSpec(raw: string): GenuiSpec | null {
+  const text = raw.trim()
+  if (text === '') return null
+
+  // 1. Full parse (settled / already-complete body).
+  const full = trySpec(text)
+  if (full !== null) return full
+
+  // 2. Bounded repair: ONE forward scan, at most `repairAttemptsLimit`
+  //    candidates, longest first — never a re-scan per `}`.
+  const { candidates } = collectPartialCandidates(text)
+  for (const candidate of candidates) {
+    const spec = trySpec(text.slice(0, candidate.end) + candidate.closingSuffix)
+    if (spec !== null) return spec
+  }
+
+  // 3. Not even one complete element yet (e.g. `{"items":[{"type":"tex`).
+  return null
+}

package/src/client/safe-math.ts

@@ -0,0 +1,270 @@
+/**
+ * SafeMath: a restricted math expression evaluator for GenUI plot specs.
+ *
+ * The model supplies an expression string like "sin(x) * 2 + 1". It is parsed
+ * and evaluated here WITHOUT eval / new Function: a hand-written recursive
+ * descent parser over a white-listed function/constant vocabulary. Unknown
+ * identifiers, object property access, and call syntax other than the
+ * white-listed functions are parse errors, so an adversarial expression
+ * cannot reach globals, prototypes, or side effects.
+ *
+ * Supported grammar:
+ *   expr    := term (('+' | '-') term)*
+ *   term    := unary (('*' | '/' | '%') unary)*
+ *   unary   := ('-' | '+') unary | power
+ *   power   := atom ('^' atom)?
+ *   atom    := number | variable | constant | func '(' expr ')' | '(' expr ')'
+ *   variable: 'x' (and any single-letter variable present in vars)
+ *   constant: 'pi' | 'e' | 'tau'
+ *   func    : sin cos tan asin acos atan sqrt cbrt exp log ln abs floor ceil round min max pow
+ */
+
+export interface SafeMathOptions {
+  /** Variable values; only names present here may be referenced as variables. */
+  vars?: Record<string, number>
+}
+
+const CONSTANTS: Record<string, number> = {
+  pi: Math.PI,
+  e: Math.E,
+  tau: Math.PI * 2,
+}
+
+const FUNCTIONS: Record<string, (...args: number[]) => number> = {
+  sin: Math.sin, cos: Math.cos, tan: Math.tan,
+  asin: Math.asin, acos: Math.acos, atan: Math.atan,
+  sqrt: Math.sqrt, cbrt: Math.cbrt,
+  exp: Math.exp, log: Math.log10, ln: Math.log,
+  abs: Math.abs, floor: Math.floor, ceil: Math.ceil, round: Math.round,
+  min: Math.min, max: Math.max,
+  pow: (a, b) => Math.pow(a, b),
+}
+
+class ParseError extends Error {
+  constructor(message: string, readonly pos: number) {
+    super(`SafeMath parse error at ${pos}: ${message}`)
+  }
+}
+
+class SafeMathParser {
+  private i = 0
+  constructor(private readonly src: string, private readonly vars: Record<string, number>) {}
+
+  parse(): (x: number) => number {
+    const node = this.parseExpr()
+    this.skipWs()
+    if (this.i < this.src.length) throw new ParseError('unexpected trailing input', this.i)
+    return this.evalNode(node)
+  }
+
+  private evalNode(node: number | ((x: number) => number)): (x: number) => number {
+    if (typeof node === 'number') return () => node
+    return node
+  }
+
+  private parseExpr(): number | ((x: number) => number) {
+    let left = this.parseTerm()
+    for (;;) {
+      this.skipWs()
+      const c = this.peek()
+      if (c === '+' || c === '-') {
+        this.i++
+        const right = this.parseTerm()
+        const op = c
+        const prev = left
+        left = op === '+'
+          ? (x) => this.asNum(prev, x) + this.asNum(right, x)
+          : (x) => this.asNum(prev, x) - this.asNum(right, x)
+      } else return left
+    }
+  }
+
+  private parseTerm(): number | ((x: number) => number) {
+    let left = this.parseUnary()
+    for (;;) {
+      this.skipWs()
+      const c = this.peek()
+      if (c === '*' || c === '/' || c === '%') {
+        this.i++
+        const right = this.parseUnary()
+        const op = c
+        const prev = left
+        left = op === '*'
+          ? (x) => this.asNum(prev, x) * this.asNum(right, x)
+          : op === '/'
+            ? (x) => this.asNum(prev, x) / this.asNum(right, x)
+            : (x) => this.asNum(prev, x) % this.asNum(right, x)
+      } else return left
+    }
+  }
+
+  private parseUnary(): number | ((x: number) => number) {
+    this.skipWs()
+    const c = this.char()
+    if (c === '-' || c === '+') {
+      this.i++
+      const operand = this.parseUnary()
+      return c === '-' ? (x) => -this.asNum(operand, x) : (x) => this.asNum(operand, x)
+    }
+    return this.parsePower()
+  }
+
+  private parsePower(): number | ((x: number) => number) {
+    const base = this.parseAtom()
+    this.skipWs()
+    if (this.peek() === '^') {
+      this.i++
+      const exp = this.parsePower()
+      const prev = base
+      return (x) => Math.pow(this.asNum(prev, x), this.asNum(exp, x))
+    }
+    return base
+  }
+
+  private parseAtom(): number | ((x: number) => number) {
+    this.skipWs()
+    const c = this.char()
+    if (c === '(') {
+      this.i++
+      const inner = this.parseExpr()
+      this.skipWs()
+      if (this.peek() !== ')') throw new ParseError('expected )', this.i)
+      this.i++
+      return inner
+    }
+    if (c >= '0' && c <= '9' || c === '.') return this.parseNumber()
+    if (this.isIdentStart(c)) return this.parseIdent()
+    throw new ParseError(`unexpected character '${c}'`, this.i)
+  }
+
+  private parseNumber(): number {
+    const start = this.i
+    while (this.i < this.src.length && /[0-9.eE+\-]/.test(this.src[this.i]!)) this.i++
+    const text = this.src.slice(start, this.i)
+    const value = Number(text)
+    if (Number.isNaN(value)) throw new ParseError(`invalid number '${text}'`, start)
+    return value
+  }
+
+  private parseIdent(): number | ((x: number) => number) {
+    const start = this.i
+    while (this.i < this.src.length && this.isIdentChar(this.src[this.i]!)) this.i++
+    const name = this.src.slice(start, this.i)
+    this.skipWs()
+    if (this.peek() === '(') {
+      // Function call.
+      const fn = FUNCTIONS[name]
+      if (fn === undefined) throw new ParseError(`unknown function '${name}'`, start)
+      this.i++
+      const args: Array<number | ((x: number) => number)> = []
+      this.skipWs()
+      if (this.peek() === ')') {
+        this.i++
+      } else {
+        for (;;) {
+          args.push(this.parseExpr())
+          this.skipWs()
+          const sep = this.peek()
+          if (sep === ',') { this.i++; continue }
+          if (sep === ')') { this.i++; break }
+          throw new ParseError('expected , or ) in call', this.i)
+        }
+      }
+      return (x) => fn(...args.map(a => this.asNum(a, x)))
+    }
+    // Own-property checks only: `in` would match inherited members like
+    // `constructor`/`toString` on the vars object.
+    if (Object.hasOwn(CONSTANTS, name)) return CONSTANTS[name]!
+    if (name === 'x') {
+      // The sampling variable resolves against the evaluation argument.
+      return (value: number) => value
+    }
+    if (Object.hasOwn(this.vars, name)) {
+      // A declared parameter (a/b/c…) resolves against its captured value,
+      // which the caller changes by recompiling with new vars.
+      const captured = this.vars[name]!
+      return () => captured
+    }
+    // Implicit parameters: an undeclared single-lowercase-letter identifier
+    // (a/b/k/m/n…) is a parameter that defaults to 1, so a model expression
+    // like "a*sin(b*x)" without a params declaration still renders instead
+    // of failing as "unknown identifier". This is safe: only [a-z] matches,
+    // so injection names (constructor, window, process…) still parse-error.
+    if (/^[a-z]$/.test(name)) return () => 1
+    throw new ParseError(`unknown identifier '${name}'`, start)
+  }
+
+  private asNum(node: number | ((x: number) => number), x: number): number {
+    return typeof node === 'number' ? node : node(x)
+  }
+
+  private skipWs(): void {
+    while (this.i < this.src.length && /\s/.test(this.src[this.i]!)) this.i++
+  }
+
+  private peek(): string | undefined {
+    return this.src[this.i]
+  }
+
+  private char(): string {
+    const c = this.peek()
+    if (c === undefined) throw new ParseError('unexpected end of input', this.i)
+    return c
+  }
+
+  private isIdentStart(c: string | undefined): boolean {
+    return c !== undefined && /[a-zA-Z_]/.test(c)
+  }
+
+  private isIdentChar(c: string): boolean {
+    return /[a-zA-Z0-9_]/.test(c)
+  }
+}
+
+/**
+ * Compile an expression into an evaluable function.
+ * @param expr - the math expression. `x` is the sampling variable; any other
+ *   name in `vars` is a parameter whose captured value the evaluator returns
+ *   (recompile with new vars to change a parameter — expressions are short).
+ * @param options - parameter values; `x` is reserved and ignored here.
+ * @returns evaluator, or null when the expression is invalid.
+ */
+export function compileMathExpr(expr: string, options: SafeMathOptions = {}): ((x: number) => number) | null {
+  try {
+    // `x` is the sampling variable and must never be shadowed by a param.
+    const vars: Record<string, number> = { ...options.vars }
+    delete vars.x
+    return new SafeMathParser(expr, vars).parse()
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Sample an expression over a range.
+ * @param expr - math expression in x, with optional parameters.
+ * @param xMin - inclusive start.
+ * @param xMax - inclusive end.
+ * @param samples - number of samples (>= 2).
+ * @param params - parameter values (e.g. { a: 2, b: 3 }); recompile per change.
+ * @returns [x, y] pairs; non-finite samples are dropped.
+ */
+export function sampleExpr(
+  expr: string,
+  xMin: number,
+  xMax: number,
+  samples = 200,
+  params: Record<string, number> = {},
+): Array<[number, number]> {
+  const fn = compileMathExpr(expr, { vars: params })
+  if (fn === null) return []
+  if (!Number.isFinite(xMin) || !Number.isFinite(xMax) || xMax <= xMin || samples < 2) return []
+  const points: Array<[number, number]> = []
+  const step = (xMax - xMin) / (samples - 1)
+  for (let i = 0; i < samples; i++) {
+    const x = xMin + step * i
+    const y = fn(x)
+    if (Number.isFinite(y)) points.push([x, y])
+  }
+  return points
+}