@weasel-js/core 1.4.2 → 1.4.4

package/dist/{DrawCommand-Ch8W63oQ.d.ts → DrawCommand-CD-ug3d9.d.ts}

@@ -116,6 +116,35 @@ type ShaderUniform = number | [number, number] | [number, number, number] | [num
  */
 declare function registerProgram(id: string, vert: string, frag: string): ShaderProgramHandle;
 
+/**
+ * One full-screen pass over what a group has already drawn.
+ *
+ * The renderer runs a group's effects in order, each reading the previous
+ * one's output through `u_source` and writing a whole new buffer — so an
+ * effect is free to read neighbouring pixels, which is the entire point and
+ * the one thing `colorMatrix` can never do.
+ *
+ * `uniforms` are the effect's own; `u_source`, `u_resolution` and `u_texel`
+ * come from the renderer and must not be passed here.
+ */
+interface Effect {
+    program: ShaderProgramHandle;
+    uniforms?: Record<string, ShaderUniform>;
+}
+/**
+ * Register a fragment shader as an effect. Sugar over `registerProgram` with
+ * the effect vertex shader, and the reason a consumer never imports the
+ * prelude: an effect that registers with the *custom-shader* vertex shader
+ * compiles, runs, and samples its source upside down.
+ *
+ * The fragment shader reads `v_uv` and `u_source`, and may declare
+ * `u_resolution` / `u_texel`. See `effectPrelude.ts` for the full contract,
+ * including the premultiplied-alpha requirement.
+ *
+ * @experimental
+ */
+declare function registerEffect(id: string, frag: string): ShaderProgramHandle;
+
 /**
  * Solid-fill paint variant (subset of the full `FillStyle` union from
  * `@weasel-js/core`). Kept for back-compat with step-1/2 consumers and
@@ -172,6 +201,21 @@ interface GroupDrawCommand {
      *  cannot escape an ancestor's clip. Max 7 nesting levels; the renderer
      *  throws if exceeded. */
     clip?: Path;
+    /**
+     * Full-screen passes run over this group's own pixels, in order, before it
+     * is composited into its parent.
+     *
+     * Unlike every other field here, this does not accumulate down the group
+     * stack — it is a render-target boundary. The children draw into a buffer of
+     * their own, each effect reads the previous one's output, and the result is
+     * composited back under this group's `transform`, `alpha`, `colorMatrix` and
+     * whatever clip encloses it. So a blur here blurs this group and nothing
+     * around it, which is what a CSS `filter` on the canvas cannot do.
+     *
+     * An empty or absent list costs nothing: no buffer is allocated until a
+     * group asks for one.
+     */
+    effects?: readonly Effect[];
     children: DrawCommand[];
 }
 /**
@@ -285,4 +329,4 @@ interface ShaderDrawCommand {
     };
 }
 
-export { type DrawCommand as D, type GroupDrawCommand as G, type ImageDrawCommand as I, type Mat3 as M, type PathDrawCommand as P, SPRITE_STRIDE as S, type TextDrawCommand as T, type ShaderDrawCommand as a, type ShaderProgramHandle as b, type ShaderUniform as c, type SolidPaint as d, type SpritesDrawCommand as e, mat3 as m, registerProgram as r };
+export { type DrawCommand as D, type Effect as E, type GroupDrawCommand as G, type ImageDrawCommand as I, type Mat3 as M, type PathDrawCommand as P, SPRITE_STRIDE as S, type TextDrawCommand as T, type ShaderDrawCommand as a, type ShaderProgramHandle as b, type ShaderUniform as c, type SolidPaint as d, type SpritesDrawCommand as e, registerProgram as f, mat3 as m, registerEffect as r };

package/dist/{pointSnapToGrid-Dmthv94u.d.ts → autoPoseDescriptor-DF1SnnSx.d.ts}

@@ -1,6 +1,7 @@
-import { c as ResizeAnchor, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior, d as PointSnapFrame, M as ModifierState } from './types-miXHGrZM.js';
-import { B as Bounds, P as PoseProjection } from './geometry-Dtt_k6Dq.js';
+import { c as ResizeAnchor, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior, d as PointSnapFrame, M as ModifierState } from './types-ei3UMl9R.js';
+import { B as Bounds, P as PoseProjection } from './geometry-6fCNhAux.js';
 import { D as DebugSink } from './types-BHK2dkMu.js';
+import { P as Path } from './path-JEV2c5If.js';
 
 /** Corner resize-handle: world-space center plus the anchor that pins the opposite corner during resize. */
 interface CornerHandle {
@@ -137,4 +138,18 @@ declare function pointSnapToGrid<TPose extends ResizePose>(args: {
     bypassKey?: keyof ModifierState;
 }): PointSnapBehavior<TPose>;
 
-export { CORNER_ANCHORS as C, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, cornerPoint as c, cornerResizeHandles as d, type CornerEdge as e, fixedCornerOf as f, hitCornerHandle as h, pointSnapToGrid as p };
+/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for
+ *  callers that need to fork between `pathPoseDescriptor` and
+ *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire `geometry`
+ *  explicitly. */
+declare function isPathLike(p: unknown): p is Path;
+/** Per-call dispatch: if the pose looks like a Path, route to
+ *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing
+ *  demos with Path TPose to wire `geometry={pathPoseDescriptor}` explicitly.
+ *  `getRotation` surfaces a `pose.rotation` field on non-Path poses so demos
+ *  using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to wire
+ *  `geometry={ROTATED_POSE_DESCRIPTOR}` just to get rotated selection chrome
+ *  and rotation-aware corner hit-tests. */
+declare const AUTO_POSE_DESCRIPTOR: PoseProjection<unknown>;
+
+export { AUTO_POSE_DESCRIPTOR as A, CORNER_ANCHORS as C, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, cornerPoint as c, cornerResizeHandles as d, type CornerEdge as e, fixedCornerOf as f, hitCornerHandle as h, isPathLike as i, pointSnapToGrid as p };

package/dist/{stroke-Dq8nL4A2.d.ts → builtins-BXFBXegF.d.ts}

@@ -1,5 +1,5 @@
 import { GradStop, Stroke } from '@weasel-js/paint';
-import { M as Mat3, b as ShaderProgramHandle, D as DrawCommand } from './DrawCommand-Ch8W63oQ.js';
+import { M as Mat3, b as ShaderProgramHandle, D as DrawCommand, E as Effect } from './DrawCommand-CD-ug3d9.js';
 import { P as Path } from './path-JEV2c5If.js';
 
 /**
@@ -218,6 +218,23 @@ declare class GLImageCache {
     private readonly gl;
     private readonly minification;
     private readonly map;
+    /**
+     * MAG_FILTER each texture currently carries, so a redundant write can be
+     * skipped.
+     *
+     * The batch sets this per flush — the same bitmap can be drawn at both
+     * filters in one frame, and the value has to be right at the draw rather than
+     * at upload. Filtering is state on the *texture object*, though, not on the
+     * unit, so re-asserting a value it already has is a write to a live texture
+     * for no reason. On a large sheet that is not free: a consumer's wall samples
+     * a 5652px-square atlas, 122MB resident, and measured `sampling: 'nearest'`
+     * costing up to 8x `'linear'` there — where the linear pass re-asserts the
+     * upload default and the nearest pass changes state on every draw.
+     *
+     * Whether that is the cause is unproven (see `docs/TODO.md`), but the write
+     * was redundant either way.
+     */
+    private readonly magFilters;
     /** `minification` selects the MIN_FILTER strategy for uploaded textures.
      *  `'linear'` (default) is the screen path's existing behavior. `'mipmap'`
      *  generates mipmaps and filters LINEAR_MIPMAP_LINEAR — required for
@@ -227,13 +244,21 @@ declare class GLImageCache {
     constructor(gl: WebGL2RenderingContext, minification?: ImageMinification);
     upload(key: object, source: TexSource, repetition?: PatternRepetition): WebGLTexture;
     bind(key: object, unit: number): void;
+    /** Set `key`'s MAG_FILTER, skipping the call when it already holds that
+     *  value. Its texture must be bound to the active unit — callers pair this
+     *  with `bind`. */
+    setMagFilter(key: object, filter: number): void;
 }
 
 /**
- * CPU gradient-ramp builder + GL 1×256 RGBA texture cache.
+ * CPU gradient-ramp builder + the GL texture every baked ramp lives in.
  *
- * Each unique stop list is uploaded once. Key = JSON.stringify(stops).
- * The cache is GL-context-bound; discard and recreate on context loss.
+ * Each unique stop list is baked once into a 256-texel strip and written to its
+ * own **row** of one RGBA texture, keyed by `JSON.stringify(stops)`. One
+ * texture rather than one per ramp is what lets a gradient take a batch texture
+ * slot the way a bitmap or a font atlas does: every gradient in a frame samples
+ * the same unit, so a run does not break per gradient. The atlas is
+ * GL-context-bound; discard and recreate on context loss.
  *
  * Output convention §2: texels are stored as straight RGBA. The fragment
  * shader applies premultiplication before writing outColor.
@@ -242,25 +267,66 @@ declare class GLImageCache {
 /** Bake gradient stops into a 256-entry RGBA lookup strip, which the shader
  *  samples instead of evaluating stops per fragment. */
 declare function buildGradientRamp(stops: GradStop[]): Uint8ClampedArray;
-declare class GradientRampCache {
+declare class GradientRampAtlas {
     private readonly gl;
-    private readonly map;
+    /** Row per stop list, in least-recently-used order: a hit re-inserts, so the
+     *  first entry is the row a full atlas recycles. */
+    private readonly rowByKey;
+    private texture;
+    private rows;
+    /** Mirror of the texture, so growth can respecify it without re-baking every
+     *  ramp it already holds. */
+    private pixels;
     private totalQueries;
     private cacheHits;
     constructor(gl: WebGL2RenderingContext);
-    upload(stops: GradStop[]): string;
-    bind(key: string, unit: number): void;
+    /** Rows the atlas currently holds — its texture height. */
+    get height(): number;
+    /**
+     * Bake `stops` into a row and return it, reusing the row an identical stop
+     * list already holds.
+     *
+     * **A returned row outlives the frame only while the atlas has room.** Past
+     * `RAMP_ATLAS_MAX_ROWS` an upload recycles the least recently used row, which
+     * rewrites texels a row handed out earlier still names. Nothing that defers
+     * its draw past this call may hold a row across another `upload` without
+     * arranging to be flushed first.
+     */
+    upload(stops: GradStop[]): number;
+    /**
+     * Whether uploading `stops` would move where existing rows sit — by growing
+     * the atlas, which changes every row's `v`, or by recycling one, which
+     * rewrites its texels.
+     *
+     * Anything holding a row past this call asks first and gets itself out of
+     * the way, because neither can be undone once it has happened.
+     */
+    wouldReshape(stops: GradStop[]): boolean;
+    /**
+     * The `v` a row is sampled at — its center.
+     *
+     * The center is load-bearing: the atlas filters LINEAR, so a `v` anywhere
+     * else blends the ramp beside it into this one. At the center the neighbor's
+     * weight is exactly zero.
+     */
+    rowV(row: number): number;
+    bind(unit: number): void;
     hitRate(): number;
     resetStats(): void;
     /**
-     * Delete every uploaded GL ramp texture and clear the map. Called by
-     * `WeaselRenderer.dispose()`. Only the GL textures are owned resources —
-     * `buildGradientRamp`'s CPU-side `Uint8ClampedArray` is transient per
-     * `upload()` call and already gone by the time a ramp is cached. The
-     * cache is unusable but refillable afterward (stats are left as-is; call
+     * Delete the atlas texture and forget every row in it. Called by
+     * `WeaselRenderer.dispose()`. The CPU mirror goes with it, so the atlas is
+     * unusable but refillable afterward (stats are left as-is; call
      * `resetStats()` separately if desired).
      */
     free(): void;
+    /** The row the next ramp is written to: a free one, a taller atlas, or the
+     *  least recently used row of a full one. */
+    private claimRow;
+    /** Grow to `rows`, keeping every row at the index it already had — a row
+     *  index is a stable name, and callers hold them. */
+    private resize;
+    private writeRow;
 }
 
 /** Row-major 4×5 color matrix identity. */
@@ -279,6 +345,22 @@ declare class GroupState {
     get alpha(): number;
     get colorMatrix(): Float32Array;
     push(frame: GroupFrame): void;
+    /**
+     * Push a frame whose children paint into a surface of their own.
+     *
+     * The transform still accumulates — the children draw where they would have
+     * drawn. Alpha and colour do not: they describe how the finished surface
+     * joins the frame, and applying them on the way in as well would fade the
+     * pixels an effect is about to read, then fade them again on the way out.
+     *
+     * Returns the pair the caller must apply at composite time — what `push`
+     * would have left on the stack — so the composition rules live here and not
+     * in the dispatcher.
+     */
+    pushIsolated(frame: GroupFrame): {
+        alpha: number;
+        colorMatrix: Float32Array;
+    };
     /** Drop every pushed frame, leaving the root. A frame that throws part-way
      *  down the tree never pops, and the next frame would draw under leftovers. */
     reset(): void;
@@ -286,33 +368,72 @@ declare class GroupState {
 }
 
 /**
- * Growable vertex staging for consecutive solid-fill geometry.
+ * Growable vertex staging for a run of solid-fill geometry, image quads and
+ * glyphs.
  *
  * Geometry only: `draw.ts` owns when a run starts, what breaks it, and the
- * uniforms the flush draws under. Colors ride the vertices (the batch program
- * is `pathFillVColor` with `u_color` left at white) because shapes in a run
- * differ in color and a merged draw has one set of uniforms — and so does the
- * model transform, applied here rather than uploaded, so that shapes under
- * different transforms still share a draw.
+ * uniforms the flush draws under.
+ *
+ * **One batch for all three, because a page interleaves them.** A grid of
+ * thumbnails is a ground rect under an atlas quad under a caption, per cell,
+ * and while each kind staged separately every one had to drain the others
+ * before it could stage — so a shape that batches perfectly in any one half
+ * alone paid a flush per command. Everything a vertex needs to say which it is
+ * fits in the same vertex: solids carry the UV of a 1x1 white texel and are
+ * their own color, quads carry their atlas UV and a white color, glyphs carry
+ * a font atlas UV, their text color, and a paint mode saying the texel is a
+ * distance field rather than a color. Gradients join as a fourth off the ramp
+ * atlas — a linear one without a mode of its own, since (ramp position, row) is
+ * what the plain mode already samples, and a radial or conic one with a mode
+ * that says its UV is a gradient-space coordinate to take a `length` or an
+ * `atan` of. See `shaders/batchFill.ts`.
+ *
+ * Colors ride the vertices because shapes in a run differ in color and a merged
+ * draw has one set of uniforms — and so does the model transform, applied here
+ * rather than uploaded, so shapes under different transforms still share a
+ * draw. The texture rides them too, as a slot index into the units the flush
+ * binds: slot 0 is the white texel every solid samples, and `draw.ts` hands out
+ * the rest per bitmap. A run holds as many bitmaps as there are slots, so an
+ * atlas is what makes a wall of one sheet coalesce and a handful of loose
+ * bitmaps no longer breaks a run per command.
  */
 
-declare class SolidBatch {
+/**
+ * A gradient vertex's `a_uv`, each channel affine in the coordinates the
+ * geometry arrives in: `u = ux*x + uy*y + u0`, and the same for `v`.
+ *
+ * One shape for all three gradients. A linear one's `v` row is the constant
+ * atlas row and its `u` row is the ramp position; a radial or conic one's two
+ * rows are the gradient-space coordinate, and the row rides `a_post` instead.
+ */
+interface GradientUV {
+    ux: number;
+    uy: number;
+    u0: number;
+    vx: number;
+    vy: number;
+    v0: number;
+}
+declare class DrawBatch {
     private readonly gl;
     private readonly aPos;
     private readonly aColor;
-    /** Cycled per flush, and created on first use so a renderer that flushes
-     *  rarely allocates as few slots as it flushes. */
-    private readonly ring;
-    private next;
-    /** The same, for flushes past a slot's capacity; these sets grow to fit. */
+    private readonly aUv;
+    private readonly aPost;
+    private readonly aSlot;
+    /** One ring per tier, cycled per flush. Slots are created on first use, so a
+     *  renderer that flushes rarely allocates as few as it flushes. */
+    private readonly rings;
+    private readonly nextInRing;
+    /** The same, for flushes past the largest tier; these sets grow to fit. */
     private readonly largeRing;
     private nextLarge;
     private verts;
     private idx;
     private nVerts;
     private nIdx;
-    /** Whether the staged run is rects alone, so its indices are the canonical
-     *  quad pattern and a slot already holding that pattern needs no upload. */
+    /** Whether the staged run is quads alone, so its indices are the canonical
+     *  pattern and a slot already holding that pattern needs no upload. */
     private pureRects;
     constructor(gl: WebGL2RenderingContext, prog: ShaderProgram);
     get length(): number;
@@ -324,6 +445,62 @@ declare class SolidBatch {
      * cover it and the batch draws at `u_model` identity.
      */
     pushRect(x: number, y: number, w: number, h: number, m: Mat3, r: number, g: number, b: number, a: number): void;
+    /**
+     * Append one image quad: the destination rect `(x, y, w, h)` mapped through
+     * `m`, sampling `(u0, v0)`-`(u1, v1)`, every corner carrying `post` as the
+     * after-the-color-matrix alpha factor.
+     *
+     * Corners wind top-left, top-right, bottom-right, bottom-left with UVs
+     * following — the same winding `pushRect` uses, which is what lets a run of
+     * mixed rects and quads keep the canonical index pattern. The flips a command
+     * asks for are already in the `u` / `v` the caller passes.
+     *
+     * `slot` is the texture unit the corners sample, which `draw.ts` assigns per
+     * bitmap within the run.
+     */
+    pushQuad(x: number, y: number, w: number, h: number, m: Mat3, u0: number, v0: number, u1: number, v1: number, post: number, slot: number): void;
+    /**
+     * Append one glyph quad: the box `(x0, y0)`-`(x1, y1)` mapped through `m`,
+     * sampling `(u0, v0)`-`(u1, v1)` of the font atlas at `slot`, painted in
+     * `rgba`.
+     *
+     * `mode` says which channels of that atlas carry the distance field, and
+     * rides the vertices packed into the slot — so a run off a baked MSDF atlas
+     * and one off the runtime canvas bake still share a draw. The synthetic-bold
+     * threshold does not: it is `u_synthBold`, and `draw.ts` breaks the run when
+     * it changes.
+     *
+     * **A synthetic oblique is sheared here rather than in the shader.** The old
+     * text program carried the baseline per vertex and skewed against
+     * `u_synthItalic`; the batch places its own corners, so the shear is one
+     * multiply while they are being placed, and `tanItalic` is 0 for an upright
+     * face. It has to happen before `m`, which is where the shader had it too.
+     *
+     * Corners wind top-left, top-right, bottom-right, bottom-left — `pushQuad`'s
+     * winding, which is what lets a run of mixed rects, image quads and glyphs
+     * keep the canonical index pattern.
+     */
+    pushGlyph(x0: number, y0: number, x1: number, y1: number, baselineY: number, tanItalic: number, m: Mat3, u0: number, v0: number, u1: number, v1: number, r: number, g: number, b: number, a: number, slot: number, mode: number): void;
+    /**
+     * Append one rect filled by a gradient: the corners of `(x, y, w, h)` mapped
+     * through `m`, sampling the ramp atlas at `slot`.
+     *
+     * `uv` gives each channel of `a_uv` as an affine function of the coordinates
+     * the corners arrive in, which is what lets a gradient ride the vertices at
+     * all: a linear one's ramp position is affine in position outright, and a
+     * radial or conic one's gradient-space *coordinate* is, even though the ramp
+     * position it yields is not. Either way the rasterizer's interpolation across
+     * a triangle is exact. `mode` says which of the two the fragment shader is
+     * looking at, and `post` carries the atlas row for the modes that read it —
+     * see `shaders/batchFill.ts`.
+     *
+     * Values outside 0..1 are the sampler's business; the atlas clamps to the
+     * edge texel, which is what the gradient shader's own `clamp` did.
+     */
+    pushGradientRect(x: number, y: number, w: number, h: number, m: Mat3, uv: GradientUV, post: number, slot: number, mode: number, r: number, g: number, b: number, a: number): void;
+    /** `pushMesh` for a mesh filled by a gradient — see `pushGradientRect` for
+     *  what `uv`, `post` and `mode` carry. */
+    pushGradientMesh(mesh: Mesh, m: Mat3, uv: GradientUV, post: number, slot: number, mode: number, r: number, g: number, b: number, a: number): void;
     /**
      * Append a tessellated mesh through `m`, all vertices carrying `rgba`. The
      * mesh's own indices are rebased onto the staged vertices, which is why the
@@ -335,6 +512,9 @@ declare class SolidBatch {
     uploadAndBind(): number;
     reset(): void;
     dispose(): void;
+    private writeVertex;
+    /** Two triangles over the four corners just written. */
+    private pushQuadIndices;
     /** Grow the CPU arrays so `vertices` / `indices` more fit. */
     private reserve;
     private nextRingSlot;
@@ -343,67 +523,6 @@ declare class SolidBatch {
     private deleteSet;
 }
 
-/**
- * Growable vertex staging for consecutive image quads.
- *
- * Geometry only: `draw.ts` owns when a run starts, what breaks it, and the
- * uniforms the flush draws under. The counterpart to `SolidBatch`, and the same
- * two tricks — the model transform is applied here rather than uploaded, so
- * quads under different group transforms still share a draw, and opacity rides
- * the vertices, so quads under different opacities do too. What it cannot
- * absorb is the texture: a batch samples one, which is why an atlas is what
- * makes a large run coalesce at all.
- *
- * Every run is quads, so a slot's index buffer is written once at creation and
- * never again: the pattern for N quads is a prefix of the pattern for any
- * larger N, so the pattern for a slot's capacity serves every flush it takes.
- * `SolidBatch` carries meshes, whose indices are rebased per flush, and has to
- * re-upload; this does not.
- */
-
-declare class ImageBatch {
-    private readonly gl;
-    private readonly aPos;
-    private readonly aUv;
-    private readonly aOpacity;
-    /** One ring per tier, cycled per flush. Slots are created on first use, so a
-     *  renderer that flushes rarely allocates as few as it flushes. */
-    private readonly rings;
-    private readonly nextInRing;
-    /** For flushes past the largest tier; these sets grow to fit. */
-    private readonly largeRing;
-    private nextLarge;
-    private verts;
-    private nQuads;
-    constructor(gl: WebGL2RenderingContext, prog: ShaderProgram);
-    /** Indices staged — what a caller passes to `drawElements`. */
-    get length(): number;
-    get quads(): number;
-    /** Whether staging one more quad would put the run past the per-flush cap. */
-    wouldOverflow(): boolean;
-    /**
-     * Append one image quad: the destination rect `(x, y, w, h)` mapped through
-     * `m`, sampling `(u0, v0)`-`(u1, v1)`, every corner carrying `opacity`.
-     *
-     * An affine maps a rect to a parallelogram, so two triangles still cover it
-     * and the batch draws at `u_model` identity. Corners wind top-left,
-     * top-right, bottom-right, bottom-left, with UVs following — the flips a
-     * command asks for are already in the `u`/`v` the caller passes.
-     */
-    pushQuad(x: number, y: number, w: number, h: number, m: Mat3, u0: number, v0: number, u1: number, v1: number, opacity: number): void;
-    /** Upload the staged geometry into the next set of buffers and bind its VAO.
-     *  Returns the index count for the caller's `drawElements`. */
-    uploadAndBind(): number;
-    reset(): void;
-    dispose(): void;
-    /** Grow the CPU arrays so one more quad fits. */
-    private reserve;
-    private nextRingSlot;
-    private nextLargeSlot;
-    private createSet;
-    private deleteSet;
-}
-
 /** How to construct a `WeaselRenderer`: the GL context or canvas to draw
  *  into, the output size, and the quality knobs that separate screen
  *  rendering from print. */
@@ -470,27 +589,30 @@ declare class WeaselRenderer {
     private readonly gl;
     private pathFill;
     private pathFillVColor;
-    private textSdf;
-    private textSdfR8;
     private imageFill;
-    private imageFillVOpacity;
+    private batchFill;
     private gradFill;
     private patternFill;
     private meshCache;
     private textureCache;
     private imageCache;
-    private gradRampCache;
+    private gradRamps;
     private programRegistry;
     private quadVbo;
     private quadIbo;
-    private solidBatch;
-    private imageBatch;
+    private drawBatch;
+    /** 1x1 white, so a batch flush sampling no image still samples something —
+     *  see `shaders/batchFill.ts`. */
+    private whiteTexture;
     private readonly groupState;
     private widthCss;
     private heightCss;
     private dpr;
     private canvas;
     private target;
+    /** Offscreen buffers for group effects. Allocates nothing until a group
+     *  with effects asks, so a canvas without them pays no memory. */
+    private readonly effectTargets;
     private readonly imageMinification;
     private readonly flattenTolerance?;
     private readonly bakeBudget;
@@ -541,7 +663,7 @@ declare class WeaselRenderer {
      *  Scope: built-in shader programs, any consumer-registered programs, the
      *  shared quad/rect geometry, any in-flight transient meshes, and the
      *  enumerable Map-keyed caches (`GLTextureCache` atlas/image textures,
-     *  `GradientRampCache` ramp textures) ARE freed.
+     *  `GradientRampAtlas`'s ramp texture) ARE freed.
      *
      *  NOT freed: `GLImageCache` (bitmap/pattern textures) and `GLMeshCache`'s
      *  persistent per-Path mesh cache are keyed by `WeakMap`, not enumerable,
@@ -577,18 +699,15 @@ declare class WeaselRenderer {
     /** @internal */ _gl(): WebGL2RenderingContext;
     /** @internal */ _pathFill(): ShaderProgram;
     /** @internal */ _pathFillVColor(): ShaderProgram;
-    /** @internal */ _solidBatch(): SolidBatch;
-    /** @internal */ _imageBatch(): ImageBatch;
-    /** @internal */ _textSdf(): ShaderProgram;
-    /** @internal */ _textSdfR8(): ShaderProgram;
+    /** @internal */ _drawBatch(): DrawBatch;
     /** @internal */ _imageFill(): ShaderProgram;
-    /** @internal */ _imageFillVOpacity(): ShaderProgram;
+    /** @internal */ _batchFill(): ShaderProgram;
     /** @internal */ _gradFill(): ShaderProgram;
     /** @internal */ _patternFill(): ShaderProgram;
     /** @internal */ _meshCache(): GLMeshCache;
     /** @internal */ _textureCache(): GLTextureCache;
     /** @internal */ _imageCache(): GLImageCache;
-    /** @internal */ _gradRampCache(): GradientRampCache;
+    /** @internal */ _gradRamps(): GradientRampAtlas;
     /** @internal */ _groupState(): GroupState;
     /** @internal */ _widthCss(): number;
     /** @internal */ _heightCss(): number;
@@ -688,4 +807,34 @@ declare function resolveStrokeWidth(width: number | {
  */
 declare function tessellateStroke(path: Path, stroke: Stroke, opts?: StrokeOptions): Mesh;
 
-export { IDENTITY_COLOR_MATRIX as I, type Mesh as M, type RenderTarget as R, ShaderCompileError as S, type View as V, WeaselRenderer as W, type ImageMinification as a, type SpriteSheet as b, type StrokeOptions as c, type WeaselRendererOptions as d, buildGradientRamp as e, frameRect as f, ShaderProgram as g, resolveStrokeWidth as r, tessellateStroke as t, viewToMat3 as v };
+/**
+ * Effects that ship with the kit.
+ *
+ * Each is a function returning `Effect[]`, not a single `Effect`, because a
+ * separable kernel is genuinely two passes and hiding that behind one entry
+ * would make the cost invisible at the callsite:
+ *
+ *   effects={[...blur({ radius: 4 }), ...vignette({ amount: 0.6 })]}
+ */
+
+/**
+ * Gaussian blur, as a horizontal pass followed by a vertical one.
+ *
+ * `radius` is in device pixels and is the distance of the outermost tap, not a
+ * standard deviation — 0 is a copy, and the falloff is the same nine-tap
+ * kernel at every radius, so a large one is a wide blur rather than a better
+ * one. Two passes at O(9) beat one at O(81) and look the same.
+ */
+declare function blur({ radius }: {
+    radius: number;
+}): Effect[];
+/**
+ * Darken toward the corners. `amount` is how dark the corner gets (0..1) and
+ * `feather` how much of the radius the falloff occupies.
+ */
+declare function vignette({ amount, feather }: {
+    amount: number;
+    feather?: number;
+}): Effect[];
+
+export { IDENTITY_COLOR_MATRIX as I, type Mesh as M, type RenderTarget as R, ShaderCompileError as S, type View as V, WeaselRenderer as W, type ImageMinification as a, type SpriteSheet as b, type StrokeOptions as c, type WeaselRendererOptions as d, blur as e, buildGradientRamp as f, frameRect as g, vignette as h, ShaderProgram as i, resolveStrokeWidth as r, tessellateStroke as t, viewToMat3 as v };

package/dist/{chunk-Y5KS66G7.js → chunk-2VXGHUVL.js}

@@ -1,5 +1,5 @@
-import { RECT_ORIGIN_PROJECTION } from './chunk-SBFC6J3C.js';
-import { registerOpFactory, captureSlot, slotFromIndex, resolveSlot } from './chunk-2KKYDDDD.js';
+import { RECT_ORIGIN_PROJECTION } from './chunk-WPM42WJP.js';
+import { registerOpFactory, captureSlot, slotFromIndex, resolveSlot } from './chunk-4RJP2N2L.js';
 
 // src/core/ops/transform.ts
 function createTransformOp(args) {
@@ -142,5 +142,5 @@ function snap(strategy, opts = {}) {
 }
 
 export { createReparentOp, createTransformOp, deleteScratch, getScratch, scratchKey, setScratch, snap };
-//# sourceMappingURL=chunk-Y5KS66G7.js.map
-//# sourceMappingURL=chunk-Y5KS66G7.js.map
+//# sourceMappingURL=chunk-2VXGHUVL.js.map
+//# sourceMappingURL=chunk-2VXGHUVL.js.map