@weasel-js/core 1.4.4 → 1.5.0

package/dist/builtins-BXFBXegF.d.ts

@@ -1,840 +0,0 @@
-import { GradStop, Stroke } from '@weasel-js/paint';
-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';
-
-/**
- * Minimal compile/link/lookup wrapper for a GL program. Throws
- * `ShaderCompileError` on compile or link failure with the GL info log
- * embedded in the error message — never returns a half-initialized program.
- *
- * Designed so test code can stub `getShaderParameter` / `getProgramParameter`
- * via the recorder Proxy without further special-casing.
- */
-type Stage = 'vertex' | 'fragment' | 'link';
-/** Thrown when a shader fails to compile or link, carrying which stage failed
- *  and the driver's log. */
-declare class ShaderCompileError extends Error {
-    readonly stage: Stage;
-    readonly log: string;
-    constructor(stage: Stage, log: string);
-}
-declare class ShaderProgram {
-    private readonly gl;
-    readonly handle: WebGLProgram;
-    private readonly uniforms;
-    private readonly attributes;
-    constructor(gl: WebGL2RenderingContext, vertSrc: string, fragSrc: string);
-    private compile;
-    lookupUniforms(names: readonly string[]): void;
-    lookupAttributes(names: readonly string[]): void;
-    uniform(name: string): WebGLUniformLocation | undefined;
-    attribute(name: string): number | undefined;
-}
-
-/**
- * A tessellated representation of a Path, ready to upload to GL.
- *
- * - `vertices` is interleaved x,y in path-local coordinates (`Float32Array`
- *   of length `2 * vertexCount`).
- * - `indices` are triangle indices into `vertices` (`Uint32Array`, length
- *   `3 * triangleCount`).
- * - `requiresStencil` is set for paths whose fillRule is `'evenodd'` and
- *   whose triangulation is a *naive* per-contour fan rather than a clean
- *   inside/outside triangulation. The renderer must use a stencil
- *   two-pass when this flag is true. Single-contour paths and `'nonzero'`
- *   multi-contour paths leave it false.
- * - `anchorA` / `anchorB` / `anchorT` parameterize each mesh vertex by
- *   the two consecutive path anchors it lies between and the arc-length
- *   fraction along that segment (0 = at A, 1 = at B). Vertices that fall
- *   exactly on an anchor set A === B and t = 0. Used at draw time when
- *   the DrawCommand supplies per-anchor colors so the renderer can lerp
- *   per mesh vertex. Optional — emitted by the path tessellators; absent
- *   on meshes built by other paths (e.g. text glyphs).
- */
-interface Mesh {
-    readonly vertices: Float32Array;
-    readonly indices: Uint32Array;
-    readonly requiresStencil?: boolean;
-    readonly anchorA?: Uint32Array;
-    readonly anchorB?: Uint32Array;
-    readonly anchorT?: Float32Array;
-}
-
-interface GLMeshHandle {
-    readonly vao: WebGLVertexArrayObject;
-    readonly indexCount: number;
-    readonly requiresStencil: boolean;
-    readonly anchorA?: Uint32Array;
-    readonly anchorB?: Uint32Array;
-    readonly anchorT?: Float32Array;
-}
-/** Resources to release when a Mesh is reclaimed by GC. */
-interface MeshResources {
-    vao: WebGLVertexArrayObject;
-    vbo: WebGLBuffer;
-    ibo: WebGLBuffer;
-}
-/**
- * Caches GL-side buffers + VAO per `Mesh` identity. Upload happens lazily
- * on first `handleFor(mesh)` call.
- *
- * **GC-aware cleanup (deferred-delete queue):** when a Mesh becomes
- * unreachable, the WeakMap entry is dropped automatically — but the
- * underlying GL resources (VAO, VBO, IBO) would leak forever without an
- * explicit `gl.delete*` call. We register each Mesh with a
- * `FinalizationRegistry`; when the Mesh is reclaimed, the finalizer pushes
- * the resources onto an internal queue. The renderer drains this queue at
- * the start of each `render()` call (via `drainPendingDeletes()`), when GL
- * is in a known state — no VAO bound, no draw mid-flight. Deleting from the
- * finalizer directly was racy (it could fire between two `gl.bindVertexArray`
- * calls inside `dispatch()`, sometimes corrupting the next draw); deferring
- * the actual delete to a known-safe point keeps the use-after-free risk to
- * zero.
- *
- * Caveats:
- *   - Finalizer timing is non-deterministic; resources may live for a frame
- *     or two beyond their Mesh, but they will be reclaimed.
- *   - If the GL context is lost between finalizer and drain, the drain
- *     no-ops safely (`gl.isContextLost()` makes deletes no-ops, and
- *     `gl.deleteBuffer(null)` is allowed).
- *
- * The cache is GL-context-bound; if the context is lost and re-created, the
- * renderer should construct a new GLMeshCache. (Context loss handling lives
- * in `WeaselRenderer`.)
- */
-declare class GLMeshCache {
-    private readonly gl;
-    private readonly aPositionLoc;
-    private readonly map;
-    /** Meshes this context has drawn at least once; see `uploadRecurring`. */
-    private readonly seen;
-    private readonly finalizer;
-    private readonly pendingDeletes;
-    /** Transient resources allocated this frame; freed at end of render(). */
-    private readonly transientThisFrame;
-    constructor(gl: WebGL2RenderingContext, aPositionLoc: number);
-    handleFor(mesh: Mesh): GLMeshHandle;
-    /**
-     * Upload a Mesh that the caller knows is single-use (e.g. the per-frame
-     * stroke ribbon from `tessellateStroke`). Returns a handle backed by fresh
-     * GL resources that the renderer will free deterministically at the end
-     * of the current frame via `freeTransient()`. Bypasses the WeakMap cache
-     * and the FinalizationRegistry, so transient meshes never wait on GC.
-     */
-    uploadTransient(mesh: Mesh): GLMeshHandle;
-    /**
-     * Upload a Mesh that may or may not recur across frames. Its first sight in
-     * *this* context takes `uploadTransient`; every later one takes the
-     * persistent handle. One transient upload to find out is cheaper than
-     * stranding a persistent VAO on a mesh that never returns, whose release
-     * would wait on GC. The transient upload does not populate the persistent
-     * map, so steady-state reuse begins on the third frame.
-     */
-    uploadRecurring(mesh: Mesh): GLMeshHandle;
-    /**
-     * Free all transient resources allocated since the last call. Called by
-     * the renderer at the end of each `render()`. Safe under context loss.
-     */
-    freeTransient(): void;
-    /** @internal — for tests asserting the transient-list size. */
-    _transientCount(): number;
-    /**
-     * Free GL resources whose Mesh has been GC'd since the last drain.
-     * Called by the renderer at the top of each `render()`, before any draws.
-     */
-    drainPendingDeletes(): void;
-    /** @internal — for tests asserting the queue size. */
-    _pendingDeleteCount(): number;
-    /** @internal — for tests that need to simulate the finalizer firing. */
-    _enqueueDeleteForTest(resources: MeshResources): void;
-    private upload;
-}
-
-/**
- * GL texture upload + cache for MSDF font atlases (and future images).
- *
- * Textures are keyed by a string id (the font family name or image id).
- * Pixels are uploaded once per id; a later upload of the same id reuses the
- * texture and only re-applies its wrap mode when that changed.
- * The cache is GL-context-bound; discard and create a new one on context loss.
- *
- * Atlas format: RGBA UNSIGNED_BYTE, linear filtering, no mipmaps.
- * Mipmap generation is deliberately skipped — MSDF works correctly with
- * linear filtering, and mipmap resampling corrupts the multi-channel SDF signal.
- */
-type TexSource$1 = HTMLImageElement | ImageBitmap | ImageData | HTMLCanvasElement;
-/** How a texture samples outside `0..1`. Pattern tiles need `'repeat'`;
- *  everything else clamps. WebGL2 allows `REPEAT` on NPOT textures, so a
- *  tile of any size tiles correctly. */
-type TextureWrap = 'clamp' | 'repeat';
-declare class GLTextureCache {
-    private readonly gl;
-    private readonly map;
-    private readonly wraps;
-    constructor(gl: WebGL2RenderingContext);
-    has(id: string): boolean;
-    /** Uploads the pixels once per id. `wrap` is re-applied whenever it differs
-     *  from what the id was last uploaded under: the same registered image can
-     *  be a clamped shader texture in one draw and a repeating pattern tile in
-     *  the next, and first-upload-wins gave the second one the first one's mode. */
-    upload(id: string, source: TexSource$1, wrap?: TextureWrap): string;
-    private applyWrap;
-    /** Create a single-channel R8 texture from raw bytes (full upload).
-     *  No-op if `id` already exists. Same LINEAR/CLAMP params as `upload`;
-     *  UNPACK_ALIGNMENT dropped to 1 for non-4-aligned row widths. */
-    uploadR8(id: string, width: number, height: number, data: Uint8Array): void;
-    /** Patch a rect of an existing R8 texture with tightly-packed w×h bytes. */
-    subImageR8(id: string, x: number, y: number, w: number, h: number, data: Uint8Array): void;
-    bind(id: string, unit: number): void;
-    /**
-     * Delete every uploaded GL texture and clear the map. Called by
-     * `WeaselRenderer.dispose()`. The cache is unusable but refillable
-     * afterward — a subsequent `upload()` for a previously-seen id re-creates
-     * the texture rather than restoring the deleted one.
-     */
-    free(): void;
-}
-
-/**
- * GL texture upload cache for ImageBitmap objects.
- *
- * Key: ImageBitmap (or pattern source object) identity (WeakMap) — lets GC
- * reclaim unreferenced bitmaps. The GL textures are NOT freed when the source
- * is gc'd; deferred to v2.
- *
- * Wrapping is set once at upload time per the `repetition` parameter:
- *   - undefined / 'no-repeat' → CLAMP_TO_EDGE
- *   - 'repeat'   → REPEAT (both axes)
- *   - 'repeat-x' → REPEAT on S, CLAMP on T
- *   - 'repeat-y' → CLAMP on S, REPEAT on T
- *
- * Convention §2: texels stored straight; shader premultiplies.
- */
-type PatternRepetition = 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
-/** MIN_FILTER strategy for uploaded textures. */
-type ImageMinification = 'linear' | 'mipmap';
-type TexSource = ImageBitmap | ImageData | HTMLCanvasElement | HTMLImageElement;
-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
-     *  quality minification when a large source bitmap is drawn small (the
-     *  headless print/export path); bilinear-only minification undersamples
-     *  and produces moiré. */
-    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 + the GL texture every baked ramp lives in.
- *
- * 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.
- */
-
-/** 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 GradientRampAtlas {
-    private readonly gl;
-    /** 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);
-    /** 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 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. */
-declare const IDENTITY_COLOR_MATRIX: Float32Array<ArrayBuffer>;
-interface GroupFrame {
-    transform?: Mat3;
-    alpha?: number;
-    /** Row-major 4×5 color matrix (20 floats). Absent leaves the stack unchanged. */
-    colorMatrix?: Float32Array | number[];
-}
-declare class GroupState {
-    private transformStack;
-    private alphaStack;
-    private colorMatrixStack;
-    get transform(): Mat3;
-    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;
-    pop(): void;
-}
-
-/**
- * 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.
- *
- * **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.
- */
-
-/**
- * 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;
-    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 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;
-    /** Whether staging `vertices` more would put the run past the per-flush cap. */
-    wouldOverflow(vertices: number): boolean;
-    /**
-     * Append one rect's four corners through `m`, all carrying `rgba` (straight
-     * alpha). An affine maps a rect to a parallelogram, so two triangles still
-     * 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
-     * index buffer is uploaded per flush rather than written once.
-     */
-    pushMesh(mesh: Mesh, m: Mat3, r: number, g: number, b: number, a: 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;
-    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;
-    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. */
-interface WeaselRendererOptions {
-    gl?: WebGL2RenderingContext;
-    canvas?: HTMLCanvasElement;
-    width: number;
-    height: number;
-    dpr: number;
-    /** MIN_FILTER strategy for image/pattern textures (`GLImageCache`).
-     *  Default `'linear'` — the existing screen behavior. The headless
-     *  `renderSceneToPixels` path passes `'mipmap'` for print-quality
-     *  minification. Explicitly passing `'linear'` is always valid. */
-    imageMinification?: ImageMinification;
-    /** Flatness tolerance for curve tessellation, in WORLD units (see
-     *  `TessellateOptions.flattenTolerance`). When set, path fills are
-     *  tessellated fresh at this tolerance per frame (transient pool) instead
-     *  of served from the Path-identity mesh cache — the cache key does not
-     *  include tolerance. Default: unset — the existing cached behavior at
-     *  `DEFAULT_FLATTEN_TOLERANCE`. The headless path derives this from the
-     *  requested output scale; screen callers normally leave it unset. */
-    flattenTolerance?: number;
-    /** Per-render synchronous bake budget for dynamic canvas-SDF glyphs.
-     *  Default DEFAULT_BAKE_BUDGET (16). The headless renderSceneToPixels
-     *  path passes Infinity so print never defers a glyph. */
-    bakeBudget?: number;
-    /** On-screen glyph size, in CSS pixels, at or above which text renders from
-     *  tessellated font outlines instead of a distance field — see
-     *  `OUTLINE_MIN_SCREEN_PX`. Only faces registered with
-     *  `registerFontOutlines` are affected; everything else keeps its SDF tier
-     *  whatever this says. Pass `Infinity` to disable the tier outright, or 0
-     *  to use outlines wherever they exist (what the headless path does, since
-     *  print has no reason to sample a field it could evaluate exactly). */
-    textOutlineMinScreenSize?: number;
-}
-/** Where a renderer draws inside a buffer it does not own.
- *
- *  The rect's SIZE is the renderer's own `width`/`height` — `resize()` owns
- *  that, and a second copy here could disagree with the one `DrawContext`
- *  reports to screen-space layers. */
-interface RenderTarget {
-    /** Top-left of this renderer's output within the drawing buffer, in CSS
-     *  pixels, with the origin at the buffer's top-left. GL's bottom-left origin
-     *  is handled internally. */
-    origin: {
-        x: number;
-        y: number;
-    };
-    /** Clear colour and stencil within the rect before drawing. Default true.
-     *  Pass false only when the caller clears the whole buffer itself on behalf
-     *  of every co-tenant — a frame that clears neither inherits its neighbour's
-     *  stencil bits, and even-odd fills then fill their holes. */
-    clear?: boolean;
-}
-/**
- * The WebGL2 renderer: takes a list of draw commands and paints them.
- *
- * It knows nothing about the scene — commands are the whole interface, which
- * is what lets layers, HUD widgets and overlays all draw through the same
- * pipeline. GPU resources (meshes, textures, gradient ramps) are cached across
- * frames and keyed by identity, so re-issuing the same command is cheap.
- */
-declare class WeaselRenderer {
-    private readonly gl;
-    private pathFill;
-    private pathFillVColor;
-    private imageFill;
-    private batchFill;
-    private gradFill;
-    private patternFill;
-    private meshCache;
-    private textureCache;
-    private imageCache;
-    private gradRamps;
-    private programRegistry;
-    private quadVbo;
-    private quadIbo;
-    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;
-    private readonly textOutlineMinScreenSize;
-    private contextLost;
-    private boundOnLost;
-    private boundOnRestored;
-    /** True after `dispose()`. A disposed renderer ignores further `render()`
-     *  calls and `registerProgram()` calls. */
-    private disposed;
-    constructor(opts: WeaselRendererOptions);
-    private uploadQuadGeometry;
-    /**
-     * Compile a consumer-registered shader program against this renderer's GL context.
-     *
-     * Call once per renderer after the module-level `registerProgram()`.
-     * Throws `ShaderCompileError` if compilation fails.
-     *
-     * In dev mode, calling again with the same handle replaces the compiled program.
-     *
-     * @experimental
-     */
-    registerProgram(handle: ShaderProgramHandle): void;
-    /**
-     * The compiled program for `id`, compiling it against this context on first
-     * use. Unlike {@link registerProgram} this neither throws on a missing
-     * source nor on a compile failure: a paint kind asking for a program it
-     * never registered must decline the paint, not take down the frame.
-     */
-    private ensureProgram;
-    /** The GL state every frame assumes. Applied per `render()` rather than once
-     *  at construction because a co-tenant sharing this context moves all of it
-     *  between our frames. */
-    private applyGlState;
-    /** Viewport and scissor for this frame. Re-applied inside `render()` because
-     *  a co-tenant on the same context moves both between our frames. */
-    private applyTarget;
-    /** Confine this renderer to a rect of its drawing buffer, or pass null to
-     *  give it the whole buffer back. Takes effect from the next `render()`. */
-    setTarget(target: RenderTarget | null): void;
-    getTarget(): RenderTarget | null;
-    isContextLost(): boolean;
-    private onContextLost;
-    private onContextRestored;
-    /** Free the GL resources this renderer itself owns and detach context-loss
-     *  listeners when a canvas was supplied. Idempotent.
-     *
-     *  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,
-     *  `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,
-     *  and are only reclaimed when the GL context itself goes away (cf.
-     *  `GLImageCache`'s own "deferred to v2" note). On a caller-owned
-     *  long-lived context — the headless render-to-pixels path hands the same
-     *  `gl` to many short-lived renderers — the image/pattern textures and
-     *  persistent Path meshes each renderer uploads DO accumulate across
-     *  renderer instances until the caller recycles the context.
-     *
-     *  Also: a Mesh that gets GC'd after `dispose()` still lands in
-     *  `GLMeshCache`'s `pendingDeletes` queue via its `FinalizationRegistry`,
-     *  but nothing drains that queue post-dispose (only `render()` does) —
-     *  those GL resources leak until the context goes away too.
-     *
-     *  A disposed renderer ignores further `render()` and `registerProgram()`
-     *  calls. */
-    dispose(): void;
-    /**
-     * Draw one frame.
-     *
-     * `viewMatrix` is the frame's world→screen transform. It is only consulted
-     * by `units: 'world'` gradients, which fall back to screen space without
-     * it — every other command carries its own transform in the stream, so
-     * callers with no view concept can keep calling `render(commands)`.
-     */
-    render(commands: DrawCommand[], viewMatrix?: Mat3): void;
-    resize(dims: {
-        width: number;
-        height: number;
-        dpr: number;
-    }): void;
-    /** @internal */ _gl(): WebGL2RenderingContext;
-    /** @internal */ _pathFill(): ShaderProgram;
-    /** @internal */ _pathFillVColor(): ShaderProgram;
-    /** @internal */ _drawBatch(): DrawBatch;
-    /** @internal */ _imageFill(): ShaderProgram;
-    /** @internal */ _batchFill(): ShaderProgram;
-    /** @internal */ _gradFill(): ShaderProgram;
-    /** @internal */ _patternFill(): ShaderProgram;
-    /** @internal */ _meshCache(): GLMeshCache;
-    /** @internal */ _textureCache(): GLTextureCache;
-    /** @internal */ _imageCache(): GLImageCache;
-    /** @internal */ _gradRamps(): GradientRampAtlas;
-    /** @internal */ _groupState(): GroupState;
-    /** @internal */ _widthCss(): number;
-    /** @internal */ _heightCss(): number;
-    /** @internal */ _dpr(): number;
-}
-
-/**
- * Uniform-grid sprite sheet layout — frame index to the source rect an
- * `ImageDrawCommand` samples. Pure arithmetic over the grid description; it
- * never touches the bitmap.
- */
-/** A sprite sheet's grid. `margin` and `spacing` follow the Tiled / Aseprite
- *  tileset convention, so a sheet exported from either describes itself here. */
-interface SpriteSheet {
-    frameWidth: number;
-    frameHeight: number;
-    columns: number;
-    /** Empty pixels around the whole grid. Default 0. */
-    margin?: number;
-    /** Empty pixels between adjacent cells — the gutter that keeps linear
-     *  sampling off the neighboring frame. Default 0. */
-    spacing?: number;
-}
-/**
- * Row-major source rect for frame `index`, counting from 0 at the top-left.
- *
- * `index` is not range-checked and does not wrap: past the last cell this
- * returns a rect below the sheet, which draws as an edge smear. Wrapping is
- * the animation's business (`frameRect(sheet, tick % count)`) — a sheet does
- * not know how many of its cells are filled.
- */
-declare function frameRect(sheet: SpriteSheet, index: number): {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-};
-
-/**
- * View → Mat3 helper for layer `draw` implementations on world-space layers.
- *
- * The kit's main package ships a `View` type at
- * `src/core/viewport/view.ts`; we re-declare a structurally compatible
- * shape here to avoid a runtime cross-package import. Exported as
- * `ViewLike` from the package barrel.
- */
-
-/** A weasel View — `{x, y, scale: {x, y}}`. Local type to avoid a cross-package import. */
-interface View {
-    x: number;
-    y: number;
-    scale: {
-        x: number;
-        y: number;
-    };
-}
-/**
- * Build the world→screen transform matrix for a `View`.
- * Use as the `transform` field of a `kind: 'group'` DrawCommand to wrap
- * world-space content emitted from a layer `draw` implementation.
- *
- * Mapping: `screen = (world − {view.x, view.y}) × {view.scale.x, view.scale.y}`.
- *
- * Column-major layout (matches `mat3.identity()`):
- * `[scale.x, 0, 0,  0, scale.y, 0,  -view.x*scale.x, -view.y*scale.y, 1]`.
- */
-declare function viewToMat3(view: View): Mat3;
-
-/** Options for stroke tessellation. */
-interface StrokeOptions {
-    flattenTolerance?: number;
-    /**
-     * Shorten each open subpath by this much at its start / end, in the same
-     * world units as the path. Stroke markers use this so a filled head is not
-     * speared by its own line; the caller resolves the distance, because this
-     * layer knows nothing about the marker registry.
-     */
-    startInset?: number;
-    endInset?: number;
-}
-/** Resolve a stroke width to world units. A number is already world units;
- *  `{ px }` is screen pixels divided by the accumulated scale, so it holds its
- *  on-screen thickness as the view zooms. */
-declare function resolveStrokeWidth(width: number | {
-    px: number;
-}, scale: number): number;
-/**
- * Build a triangle-mesh ribbon from a stroked Path.
- *
- * Supports:
- *   - cap: 'butt' | 'round' | 'square'
- *   - join: 'miter' | 'round' | 'bevel'
- *   - center alignment directly; RectPath inner/outer alignment via a
- *     pre-shifted rect; PolygonPath inner/outer alignment via stencil at the
- *     renderer level
- *   - dash splitting
- */
-declare function tessellateStroke(path: Path, stroke: Stroke, opts?: StrokeOptions): Mesh;
-
-/**
- * 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 };