@motionscript/plot 0.0.0-stage → 0.1.0-alpha.3

package/dist/graph2d/curve-error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Why an expression won't compile as `y = f(x)`, in the terms the tile shows.
+ *
+ * A one-line binding of the shared checker to this node's single free variable,
+ * and it is worth its own name for what it *rejects*: `x + y` is a perfectly
+ * good surface and a mistake on a curve, and the tile has to say so rather than
+ * silently plotting `x`. The 3D graph's `expressionError` is the same function
+ * bound the other way.
+ */
+/** `null` when `source` compiles as `y = f(x)`, else the reason it doesn't. */
+export declare function curveError(source: string): string | null;
+//# sourceMappingURL=curve-error.d.ts.map

package/dist/graph2d/curve-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve-error.d.ts","sourceRoot":"","sources":["../../src/graph2d/curve-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAExD"}

package/dist/graph2d/curve-error.js

@@ -0,0 +1,15 @@
+/**
+ * Why an expression won't compile as `y = f(x)`, in the terms the tile shows.
+ *
+ * A one-line binding of the shared checker to this node's single free variable,
+ * and it is worth its own name for what it *rejects*: `x + y` is a perfectly
+ * good surface and a mistake on a curve, and the tile has to say so rather than
+ * silently plotting `x`. The 3D graph's `expressionError` is the same function
+ * bound the other way.
+ */
+import { CURVE_VARIABLES, expressionError, } from "../kit/expression.js";
+/** `null` when `source` compiles as `y = f(x)`, else the reason it doesn't. */
+export function curveError(source) {
+    return expressionError(source, CURVE_VARIABLES);
+}
+//# sourceMappingURL=curve-error.js.map

package/dist/graph2d/curve-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve-error.js","sourceRoot":"","sources":["../../src/graph2d/curve-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,eAAe,EACf,eAAe,GAChB,MAAM,mBAAmB,CAAA;AAE1B,+EAA+E;AAC/E,MAAM,UAAU,UAAU,CAAC,MAAc;IACvC,OAAO,eAAe,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;AACjD,CAAC","sourcesContent":["/**\n * Why an expression won't compile as `y = f(x)`, in the terms the tile shows.\n *\n * A one-line binding of the shared checker to this node's single free variable,\n * and it is worth its own name for what it *rejects*: `x + y` is a perfectly\n * good surface and a mistake on a curve, and the tile has to say so rather than\n * silently plotting `x`. The 3D graph's `expressionError` is the same function\n * bound the other way.\n */\n\nimport {\n  CURVE_VARIABLES,\n  expressionError,\n} from \"../kit/expression\"\n\n/** `null` when `source` compiles as `y = f(x)`, else the reason it doesn't. */\nexport function curveError(source: string): string | null {\n  return expressionError(source, CURVE_VARIABLES)\n}\n"]}

package/dist/graph2d/curve.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Turning `y = f(x)` into polylines you can actually hand a rasterizer.
+ *
+ * This is the whole difficulty of a 2D grapher, and it is not the sampling loop
+ * anybody writes first. That loop — walk the pixel columns, evaluate, skip
+ * anything that isn't on screen — fails in four separate ways, and each failure
+ * looks like a *different* bug:
+ *
+ * 1. **Dropping off-view points instead of clipping segments.** If the last
+ *    point you keep is the last one that landed inside the box, the curve stops
+ *    in mid-air an arbitrary distance from the edge. `log(x)` appears to end
+ *    somewhere over the plot rather than plunging out of the bottom of it. The
+ *    fix is to build the segment anyway and clip *it* against the frame, so the
+ *    curve leaves through the edge exactly where it really crosses.
+ *
+ * 2. **Handing the path API astronomical coordinates.** `log(1e-300)` is about
+ *    -690, which at any sane zoom is millions of pixels below the box. Skia's
+ *    scan converter is fixed-point, so a coordinate past roughly ±32k overflows
+ *    and the contour is *silently dropped* — the curve doesn't render wrong, it
+ *    doesn't render at all. Clipping (1) already bounds what reaches the path
+ *    API to the frame plus a hair; {@link COORD_LIMIT} bounds the arithmetic on
+ *    the way there, so no infinity ever reaches the clipper to turn a `t` into a
+ *    `NaN`.
+ *
+ * 3. **Sampling uniformly in x.** Near an asymptote one pixel of x is thousands
+ *    of pixels of y, so a uniform grid gives a visible polygonal kink where the
+ *    curve turns; far from one, the same grid spends hundreds of samples on a
+ *    straight line. {@link sampleCurve} subdivides recursively instead — split
+ *    any segment that is not flat *in screen space*, stop at a quarter pixel —
+ *    so sample density follows curvature and comes out dense near `x = 0` for
+ *    `log` and sparse where it is nearly straight. The flatness test pairs a
+ *    distance check with an **angle** check, because the distance alone reads a
+ *    symmetric wiggle (whose midpoint sits exactly on the chord) as flat.
+ *
+ * 4. **Treating "undefined" and "very large" as the same thing.** `log(-1)` is
+ *    `NaN`: a genuine hole, and the path has to break. `log(1e-300)` is finite
+ *    and enormous: the curve is still there, still continuous, and has to keep
+ *    being drawn until it leaves the frame. Conflating the two is the other half
+ *    of the cut-off in (1). At a defined/undefined edge this bisects to find
+ *    where the domain actually ends, so `sqrt(x)` terminates at the origin
+ *    rather than at whichever sample happened to be last.
+ *
+ * Everything here is pure and works in node-local pixels, so it is testable with
+ * no renderer: the caller supplies the graph→pixel mapping and gets back runs of
+ * points ready to stroke.
+ */
+import type { Vector2 } from "@motionscript/sdk";
+/**
+ * The graph→pixel mapping, as four numbers rather than two closures: this is the
+ * hot path (a few thousand projections per curve per frame) and the closures
+ * would be called through a megamorphic call site.
+ *
+ * Pixels are the node's own local space — origin at the node's centre, y **up**,
+ * which is both the space `Graphics` draws in and, conveniently, the orientation
+ * a graph is thought about in.
+ */
+export interface PlaneMap {
+    /** Graph x at the node's horizontal centre. */
+    centerX: number;
+    /** Graph y at the node's vertical centre. */
+    centerY: number;
+    /** Pixels per graph unit along x. */
+    scaleX: number;
+    /** Pixels per graph unit along y. */
+    scaleY: number;
+}
+/** An axis-aligned rectangle in node-local pixels, y-up. */
+export interface PixelRect {
+    left: number;
+    right: number;
+    bottom: number;
+    top: number;
+}
+/** A `y = f(x)` curve, sampled by {@link sampleCurve}. */
+export type CurveFunction = (x: number) => number;
+/**
+ * A ceiling on curve evaluations, shared by every curve drawn in one frame.
+ *
+ * Shared rather than per curve because what a frame can afford is a property of
+ * the frame: one curve with a pole every three pixels must not be allowed to
+ * cost what six ordinary ones do, and six ordinary ones must not each be held to
+ * a sixth of the budget when five of them are straight lines. A cheap curve
+ * hands its slack to whatever comes after it.
+ */
+export interface SampleBudget {
+    /** Evaluations left for the curves still to be drawn. */
+    remaining: number;
+    /** How many curves are still to be drawn, this one included. */
+    pending: number;
+}
+/** A frame's budget, to be handed to each of `curves` {@link sampleCurve} calls. */
+export declare function sampleBudget(curves: number): SampleBudget;
+/**
+ * Samples `f` across the x range `clip` covers and returns the polylines to
+ * stroke: node-local pixel points, clipped to `clip`, split wherever the curve
+ * genuinely stops.
+ *
+ * `clip` should be the node's box grown by about a stroke width, so a curve
+ * running just outside the frame still paints the half of its stroke that falls
+ * inside it. Nothing outside that rectangle is returned, which is what keeps the
+ * rasterizer's fixed-point limit out of reach — see (2) in the module note.
+ */
+export declare function sampleCurve(f: CurveFunction, map: PlaneMap, clip: PixelRect, budget?: SampleBudget): Vector2[][];
+//# sourceMappingURL=curve.d.ts.map

package/dist/graph2d/curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve.d.ts","sourceRoot":"","sources":["../../src/graph2d/curve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAEhD;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ;IACvB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAA;IACf,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAA;IACf,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAA;IACd,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAA;CACf;AAED,4DAA4D;AAC5D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;CACZ;AAkHD,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;AAiEjD;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAA;IACjB,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAEzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,aAAa,EAChB,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,SAAS,EACf,MAAM,CAAC,EAAE,YAAY,GACpB,OAAO,EAAE,EAAE,CAwJb"}

package/dist/graph2d/curve.js

@@ -0,0 +1,531 @@
+/**
+ * Turning `y = f(x)` into polylines you can actually hand a rasterizer.
+ *
+ * This is the whole difficulty of a 2D grapher, and it is not the sampling loop
+ * anybody writes first. That loop — walk the pixel columns, evaluate, skip
+ * anything that isn't on screen — fails in four separate ways, and each failure
+ * looks like a *different* bug:
+ *
+ * 1. **Dropping off-view points instead of clipping segments.** If the last
+ *    point you keep is the last one that landed inside the box, the curve stops
+ *    in mid-air an arbitrary distance from the edge. `log(x)` appears to end
+ *    somewhere over the plot rather than plunging out of the bottom of it. The
+ *    fix is to build the segment anyway and clip *it* against the frame, so the
+ *    curve leaves through the edge exactly where it really crosses.
+ *
+ * 2. **Handing the path API astronomical coordinates.** `log(1e-300)` is about
+ *    -690, which at any sane zoom is millions of pixels below the box. Skia's
+ *    scan converter is fixed-point, so a coordinate past roughly ±32k overflows
+ *    and the contour is *silently dropped* — the curve doesn't render wrong, it
+ *    doesn't render at all. Clipping (1) already bounds what reaches the path
+ *    API to the frame plus a hair; {@link COORD_LIMIT} bounds the arithmetic on
+ *    the way there, so no infinity ever reaches the clipper to turn a `t` into a
+ *    `NaN`.
+ *
+ * 3. **Sampling uniformly in x.** Near an asymptote one pixel of x is thousands
+ *    of pixels of y, so a uniform grid gives a visible polygonal kink where the
+ *    curve turns; far from one, the same grid spends hundreds of samples on a
+ *    straight line. {@link sampleCurve} subdivides recursively instead — split
+ *    any segment that is not flat *in screen space*, stop at a quarter pixel —
+ *    so sample density follows curvature and comes out dense near `x = 0` for
+ *    `log` and sparse where it is nearly straight. The flatness test pairs a
+ *    distance check with an **angle** check, because the distance alone reads a
+ *    symmetric wiggle (whose midpoint sits exactly on the chord) as flat.
+ *
+ * 4. **Treating "undefined" and "very large" as the same thing.** `log(-1)` is
+ *    `NaN`: a genuine hole, and the path has to break. `log(1e-300)` is finite
+ *    and enormous: the curve is still there, still continuous, and has to keep
+ *    being drawn until it leaves the frame. Conflating the two is the other half
+ *    of the cut-off in (1). At a defined/undefined edge this bisects to find
+ *    where the domain actually ends, so `sqrt(x)` terminates at the origin
+ *    rather than at whichever sample happened to be last.
+ *
+ * Everything here is pure and works in node-local pixels, so it is testable with
+ * no renderer: the caller supplies the graph→pixel mapping and gets back runs of
+ * points ready to stroke.
+ */
+/**
+ * Hard bound on a projected coordinate, in node pixels.
+ *
+ * Not a rendering decision — clipping is what decides what the rasterizer sees.
+ * This exists so the *arithmetic* between projection and clipping stays finite:
+ * `1/x` at 1e-320 projects to something that overflows to `Infinity`, and an
+ * `Infinity` in the clipper's `q / p` produces a `NaN` `t` that quietly discards
+ * the segment — which would put the cut-off of (1) back in through a side door.
+ *
+ * Large enough that no clamped point is ever inside a plausible frame (so the
+ * clamp can't bend a visible part of the curve), small enough to stay far below
+ * the fixed-point limit even after a parent scales the node up.
+ */
+const COORD_LIMIT = 16_000;
+/** How far a sample may sit from the chord before the segment is split, in px. */
+const TOLERANCE_PX = 0.25;
+/**
+ * How narrow a segment may get before the subdivision stops, in pixels of x.
+ *
+ * A **pixel** size rather than a recursion depth, and that is the single change
+ * that bounds this module's cost. Leaves tile the frame, so however violent the
+ * function is the whole tree costs at most `2 · width / MIN_SEGMENT_PX`
+ * evaluations — about seven and a half thousand on a 1920-px node, against the
+ * million a depth of ten over five hundred seeds allowed. Half a pixel because
+ * that is where one more halving cannot move a stroked line by as much as its
+ * own antialiasing.
+ */
+const MIN_SEGMENT_PX = 0.5;
+/**
+ * How far the two halves of a segment may disagree in direction before it is
+ * split, in radians (~2.9°).
+ *
+ * The reason the distance test alone is not enough: a symmetric wiggle puts its
+ * midpoint *exactly* on the chord, so the perpendicular distance is zero and a
+ * distance-only test declares a visible kink flat. Two tests, and a segment has
+ * to pass both.
+ */
+const ANGLE_TOLERANCE = 0.05;
+/**
+ * Backstop on the recursion depth.
+ *
+ * {@link MIN_SEGMENT_PX} stops the subdivision first at every box size
+ * {@link seedCount} can produce — the deepest is about six levels on an 8000-px
+ * node — so this only ever fires if a seed interval somehow came out enormous.
+ * It is here so the recursion cannot run away on a stack rather than because any
+ * curve needs it.
+ */
+const MAX_DEPTH = 12;
+/**
+ * Evaluations one curve may spend in one frame.
+ *
+ * The refinement alone cannot reach this — see {@link MIN_SEGMENT_PX} — so what
+ * this really bounds is the boundary bisection, which is logarithmic per domain
+ * edge but unbounded in the *number* of edges: `sqrt(sin(1000x))` has hundreds.
+ * At roughly a tenth of a microsecond for a compiled expression tree this is
+ * about four milliseconds, which is as much of a 60 fps frame as one curve may
+ * have to itself.
+ */
+const MAX_EVALUATIONS = 40_000;
+/**
+ * Evaluations every curve is guaranteed, however many of them there are: the
+ * seed pass with room for two levels of refinement over all of it.
+ *
+ * A graph carrying twenty curves draws all twenty coarsely rather than the first
+ * three well and the rest not at all.
+ */
+const MIN_EVALUATIONS = 2_048;
+/**
+ * Evaluations all the curves on one node share in a frame.
+ *
+ * Three at their individual ceiling, or the verification harness's six at twenty
+ * thousand each — about twelve milliseconds in the worst case, which is the
+ * point past which degrading the curves beats dropping the frame.
+ */
+const FRAME_EVALUATIONS = 120_000;
+/**
+ * How many times a defined/undefined edge is bisected before the curve is cut.
+ *
+ * Generous because the interesting case is not `sqrt(x)`, where the value at the
+ * boundary is finite and a handful of steps land on it. It is `log(x)`, whose
+ * boundary value is unbounded: each halving buys a constant amount of extra
+ * descent, so terminating early leaves the curve stopping *inside* the frame,
+ * which is the exact artefact this module exists to prevent. The loop exits as
+ * soon as the defined side has left the frame, so the full count is only ever
+ * paid on a boundary that stays on screen.
+ */
+const BOUNDARY_STEPS = 60;
+/** Roughly how far apart the initial uniform samples are laid, in pixels. */
+const SEED_SPACING_PX = 8;
+const MIN_SEEDS = 64;
+const MAX_SEEDS = 512;
+/**
+ * Ceiling on the points one curve may emit.
+ *
+ * Adaptive subdivision is self-limiting on anything anybody plots deliberately;
+ * it is not self-limiting on `sin(10000x)`, where every segment genuinely is
+ * curved at every scale and the recursion expands to its full width. This is the
+ * backstop, and going over it degrades the curve to the resolution already
+ * reached rather than dropping it.
+ */
+const MAX_POINTS = 24_000;
+function blankSample() {
+    return { t: 0, x: 0, y: 0, px: 0, py: 0, ok: false };
+}
+/**
+ * Reused {@link Sample} storage.
+ *
+ * Every evaluation used to be a fresh object. Six curves at sixty frames a
+ * second is millions of short-lived allocations a second, which is a collector
+ * running *through* the animation rather than between takes. The recursion is a
+ * depth-first walk over one seed interval and nothing outlives that interval, so
+ * the arena hands out slots and the seed loop resets the mark — which makes
+ * every allocation after the first frame a field write on an object whose hidden
+ * class never changes.
+ *
+ * Module scope, and therefore not re-entrant. Nothing re-enters: one
+ * {@link sampleCurve} runs to completion before the next begins, and an arena
+ * per call would allocate the thing it exists to avoid.
+ */
+const arena = [];
+let arenaMark = 0;
+function takeSample() {
+    const slot = arena[arenaMark];
+    if (slot !== undefined) {
+        arenaMark++;
+        return slot;
+    }
+    const fresh = blankSample();
+    arena.push(fresh);
+    arenaMark++;
+    return fresh;
+}
+/** A frame's budget, to be handed to each of `curves` {@link sampleCurve} calls. */
+export function sampleBudget(curves) {
+    return { remaining: FRAME_EVALUATIONS, pending: Math.max(1, curves) };
+}
+/**
+ * Samples `f` across the x range `clip` covers and returns the polylines to
+ * stroke: node-local pixel points, clipped to `clip`, split wherever the curve
+ * genuinely stops.
+ *
+ * `clip` should be the node's box grown by about a stroke width, so a curve
+ * running just outside the frame still paints the half of its stroke that falls
+ * inside it. Nothing outside that rectangle is returned, which is what keeps the
+ * rasterizer's fixed-point limit out of reach — see (2) in the module note.
+ */
+export function sampleCurve(f, map, clip, budget) {
+    const pen = new CurvePen(clip);
+    // Sample across the *clip*, not the box: the extra sliver either side is what
+    // lets a curve enter the frame already at full stroke width instead of
+    // starting with a cap flush against the edge.
+    //
+    // In offsets from the centre rather than in x — see {@link Sample.t}.
+    const tLo = clip.left / map.scaleX;
+    const tHi = clip.right / map.scaleX;
+    if (!(tHi > tLo) || !(map.scaleX > 0) || !(map.scaleY > 0))
+        return [];
+    const seeds = seedCount(clip.right - clip.left);
+    const step = (tHi - tLo) / seeds;
+    // This curve's slice of the frame's evaluations. Bounded above so one curve
+    // can't eat the frame, and below so a graph full of them still draws every one.
+    const share = budget
+        ? Math.min(MAX_EVALUATIONS, Math.max(MIN_EVALUATIONS, Math.floor(budget.remaining / Math.max(1, budget.pending))))
+        : MAX_EVALUATIONS;
+    let spent = 0;
+    const write = (slot, t) => {
+        const x = map.centerX + t;
+        const y = f(x);
+        spent++;
+        const ok = Number.isFinite(y);
+        slot.t = t;
+        slot.x = x;
+        slot.y = y;
+        slot.px = clampCoord(t * map.scaleX);
+        // A non-finite y has no position; 0 is a placeholder the `ok` flag keeps
+        // anyone from reading.
+        slot.py = ok ? clampCoord((y - map.centerY) * map.scaleY) : 0;
+        slot.ok = ok;
+        return slot;
+    };
+    const at = (t) => write(takeSample(), t);
+    /**
+     * The last defined sample on the way from `from` towards `to`, where exactly
+     * one of the two is defined.
+     *
+     * Three exits. Off the frame, because past the edge the only thing further
+     * halvings buy is a longer segment that is going to be clipped to the same
+     * place anyway — this is the one `log` leaves by, and the reason
+     * {@link BOUNDARY_STEPS} is generous. *Converged*, because a boundary whose
+     * value is finite stops moving after a handful of steps and `sqrt` was paying
+     * for all sixty of them. And float resolution, which nothing reaches.
+     */
+    const edgeOf = (from, to) => {
+        let inside = from;
+        let outsideT = to.t;
+        for (let i = 0; i < BOUNDARY_STEPS; i++) {
+            if (spent >= share)
+                break;
+            if (offFrame(inside, clip))
+                break;
+            const midT = (inside.t + outsideT) / 2;
+            if (midT === inside.t || midT === outsideT)
+                break; // float resolution
+            const mid = at(midT);
+            if (!mid.ok) {
+                outsideT = midT;
+                continue;
+            }
+            const settled = Math.abs(mid.px - inside.px) < TOLERANCE_PX &&
+                Math.abs(mid.py - inside.py) < TOLERANCE_PX;
+            inside = mid;
+            if (settled)
+                break;
+        }
+        return inside;
+    };
+    const emit = (a, m, b, floored) => {
+        if (a.ok && b.ok) {
+            if (floored && diverges(a, m, b, clip)) {
+                pen.break();
+                return;
+            }
+            pen.draw(a, b);
+            return;
+        }
+        if (a.ok) {
+            const edge = edgeOf(a, b);
+            if (edge.t !== a.t)
+                pen.draw(a, edge);
+            pen.break();
+            return;
+        }
+        if (b.ok) {
+            pen.break();
+            const edge = edgeOf(b, a);
+            if (edge.t !== b.t)
+                pen.draw(edge, b);
+            else
+                pen.start(b);
+            return;
+        }
+        pen.break();
+    };
+    const refine = (a, b, depth) => {
+        // Out of budget, or out of room in the path: draw the chord. Deliberately
+        // *not* routed through the pole test — with no midpoint there is nothing to
+        // judge by, and a vertical line through an asymptote is an ugly frame where
+        // a missing branch is a wrong one.
+        if (spent >= share || pen.points >= MAX_POINTS) {
+            emit(a, null, b, false);
+            return;
+        }
+        const m = at((a.t + b.t) / 2);
+        const floored = depth >= MAX_DEPTH || b.px - a.px <= MIN_SEGMENT_PX;
+        if (floored || flat(a, m, b)) {
+            // "Gave up" rather than "settled" is what identifies a pole, which is why
+            // the midpoint travels with the verdict — see {@link diverges}.
+            emit(a, m, b, floored);
+            return;
+        }
+        refine(a, m, depth + 1);
+        refine(m, b, depth + 1);
+    };
+    // The seed endpoints come from their own pair rather than from the arena:
+    // `previous` has to survive the reset that recycles the interval it was the
+    // right-hand end of.
+    const ends = [blankSample(), blankSample()];
+    let previous = write(ends[0], tLo);
+    for (let i = 1; i <= seeds; i++) {
+        // Recomputed from the ends rather than accumulated, so rounding can't drift
+        // the grid off the right-hand edge over five hundred additions.
+        const next = write(ends[i & 1], i === seeds ? tHi : tLo + i * step);
+        arenaMark = 0;
+        refine(previous, next, 0);
+        previous = next;
+    }
+    arenaMark = 0;
+    if (budget) {
+        budget.remaining = Math.max(0, budget.remaining - spent);
+        budget.pending = Math.max(0, budget.pending - 1);
+    }
+    return pen.finish();
+}
+/** How many uniform samples to lay down before refining anything. */
+function seedCount(widthPx) {
+    const wanted = Math.round(widthPx / SEED_SPACING_PX);
+    return Math.min(MAX_SEEDS, Math.max(MIN_SEEDS, wanted));
+}
+/**
+ * Whether the arc `a → m → b` is straight enough, in **screen** space, to draw
+ * as one segment.
+ *
+ * Screen space and not graph space, because what "straight enough" has to mean
+ * is "the eye can't tell" — a tolerance in graph units would subdivide a flat
+ * line to death when zoomed out and give up mid-curve when zoomed in.
+ */
+function flat(a, m, b) {
+    // A domain edge somewhere inside: always split, so the bisection that finds it
+    // runs on as short an interval as possible.
+    if (a.ok !== m.ok || m.ok !== b.ok)
+        return false;
+    // Nothing defined anywhere across it — there is no curve here to be wrong
+    // about, so stop.
+    if (!a.ok)
+        return true;
+    const dx = b.px - a.px;
+    const dy = b.py - a.py;
+    const length = Math.hypot(dx, dy) || 1;
+    const distance = Math.abs((m.px - a.px) * dy - (m.py - a.py) * dx) / length;
+    if (distance > TOLERANCE_PX)
+        return false;
+    // The second half of the test — see {@link ANGLE_TOLERANCE}.
+    const first = Math.atan2(m.py - a.py, m.px - a.px);
+    const second = Math.atan2(b.py - m.py, b.px - m.px);
+    let turn = Math.abs(first - second);
+    if (turn > Math.PI)
+        turn = 2 * Math.PI - turn;
+    return turn < ANGLE_TOLERANCE;
+}
+/**
+ * Whether a segment the sampler had to give up on is an **asymptote** — the one
+ * case where drawing nothing beats drawing the chord.
+ *
+ * Two conditions, and the second is the one this module was missing. The ends
+ * must have run off *opposite* edges, which is what a vertical line through the
+ * frame looks like. And the curve must actually turn back inside the segment: a
+ * midpoint outside the range its own ends span is a pole (`tan` climbs to +∞ on
+ * one side of π/2 and arrives from -∞ on the other, so the midpoint is always
+ * outside), while a midpoint *between* them is an ordinary steep climb.
+ *
+ * Leaving the second test out is what cut `log(x)` off in mid-air. Once the y
+ * axis is stretched, `log` crosses the whole visible band inside a single leaf;
+ * the ends of that leaf are both off the frame, so its neighbours clip away to
+ * nothing, and treating the leaf itself as a pole deletes not a gap but the
+ * entire crossing — the exact artefact this module exists to prevent, arriving
+ * through the door meant to keep it out. `exp`, `x^20` and `1/x` all reach it.
+ *
+ * A `null` midpoint means the sampler ran out of budget and has nothing to judge
+ * by. Draw it: only a curve that has already spent forty thousand evaluations
+ * can get here, and a spurious vertical line is the lesser wrong.
+ */
+function diverges(a, m, b, clip) {
+    if (!straddles(a, b, clip))
+        return false;
+    if (m === null)
+        return false;
+    if (!m.ok)
+        return true;
+    return m.y < Math.min(a.y, b.y) || m.y > Math.max(a.y, b.y);
+}
+/** Whether the two ends have run off *opposite* edges of the frame. */
+function straddles(a, b, clip) {
+    return ((a.py > clip.top && b.py < clip.bottom) ||
+        (a.py < clip.bottom && b.py > clip.top));
+}
+/** Whether a sample has left the frame entirely. */
+function offFrame(sample, clip) {
+    return sample.py > clip.top || sample.py < clip.bottom;
+}
+function clampCoord(value) {
+    if (value > COORD_LIMIT)
+        return COORD_LIMIT;
+    if (value < -COORD_LIMIT)
+        return -COORD_LIMIT;
+    // `NaN` cannot reach here (the caller checks `ok` first), but a `-0` would
+    // print oddly in a test snapshot and costs nothing to normalise.
+    return value === 0 ? 0 : value;
+}
+/**
+ * Accumulates clipped polylines, one segment at a time.
+ *
+ * Incremental rather than "collect every point, then clip the polyline" because
+ * a curve is built by a recursion that already knows where its breaks are, and
+ * because the intermediate list is the thing that would carry the astronomical
+ * coordinates this module exists to keep out of the renderer.
+ */
+class CurvePen {
+    clip;
+    runs = [];
+    open = [];
+    /** The clipped end of the last drawn segment, for joining the next one to. */
+    cursor = null;
+    /** Points emitted so far, against {@link MAX_POINTS}. */
+    points = 0;
+    constructor(clip) {
+        this.clip = clip;
+    }
+    /** Draws `a → b`, clipped; continues the open run when it joins on. */
+    draw(a, b) {
+        const segment = clipSegment(a.px, a.py, b.px, b.py, this.clip);
+        if (!segment) {
+            // Wholly outside the frame: whatever run was open ended at the edge.
+            this.break();
+            return;
+        }
+        const [start, end] = segment;
+        if (this.cursor && samePoint(this.cursor, start)) {
+            this.push(end);
+        }
+        else {
+            this.break();
+            this.push(start);
+            this.push(end);
+        }
+        this.cursor = end;
+    }
+    /** Begins a run at `b` without drawing anything into it yet. */
+    start(b) {
+        this.break();
+        if (inside(b.px, b.py, this.clip)) {
+            this.push({ x: b.px, y: b.py });
+            this.cursor = { x: b.px, y: b.py };
+        }
+    }
+    /** Ends the open run. A run of fewer than two points draws nothing. */
+    break() {
+        if (this.open.length >= 2)
+            this.runs.push(this.open);
+        this.open = [];
+        this.cursor = null;
+    }
+    finish() {
+        this.break();
+        return this.runs;
+    }
+    push(point) {
+        this.open.push(point);
+        this.points++;
+    }
+}
+/** Points within a tenth of a pixel are the same point, for run-joining. */
+function samePoint(a, b) {
+    return Math.abs(a.x - b.x) < 0.1 && Math.abs(a.y - b.y) < 0.1;
+}
+function inside(x, y, clip) {
+    return x >= clip.left && x <= clip.right && y >= clip.bottom && y <= clip.top;
+}
+/**
+ * Liang–Barsky clip of one segment against `clip`. Returns the surviving
+ * `[start, end]`, or `null` when the segment lies wholly outside.
+ *
+ * The piece of this module that turns "the curve stops in mid-air" into "the
+ * curve leaves through the edge": the off-frame endpoint is kept and the
+ * *segment* is cut, rather than the point being discarded and the segment never
+ * built.
+ */
+function clipSegment(ax, ay, bx, by, clip) {
+    const dx = bx - ax;
+    const dy = by - ay;
+    let t0 = 0;
+    let t1 = 1;
+    // Each edge as (p, q): the segment survives where p·t <= q.
+    const edges = [
+        [-dx, ax - clip.left],
+        [dx, clip.right - ax],
+        [-dy, ay - clip.bottom],
+        [dy, clip.top - ay],
+    ];
+    for (const [p, q] of edges) {
+        if (p === 0) {
+            // Parallel to this edge: outside it means the whole segment is out.
+            if (q < 0)
+                return null;
+            continue;
+        }
+        const r = q / p;
+        if (p < 0) {
+            if (r > t1)
+                return null;
+            if (r > t0)
+                t0 = r;
+        }
+        else {
+            if (r < t0)
+                return null;
+            if (r < t1)
+                t1 = r;
+        }
+    }
+    return [
+        { x: ax + t0 * dx, y: ay + t0 * dy },
+        { x: ax + t1 * dx, y: ay + t1 * dy },
+    ];
+}
+//# sourceMappingURL=curve.js.map