@weasel-js/core 1.9.3 → 1.10.0

package/dist/renderer/WeaselRenderer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WeaselRenderer.js","names":["customUniformNames","CUSTOM_KIT_UNIFORMS","extractUniformNames","vertSrc","fragSrc","compileCustomProgram","src","CUSTOM_VERT_SRC","program","ShaderProgram","gl","extractUniformArrays","CUSTOM_ATTRIBUTES","now","GLYPH_PAINT_SOURCES","GLYPH_PATTERN_FRAG_SRC","GLYPH_PATTERN_UNIFORMS","GLYPH_GRAD_FRAG_SRC","GLYPH_GRAD_UNIFORMS","GLYPH_TEXTURE_FRAG_SRC","GLYPH_TEXTURE_UNIFORMS","WeaselRenderer","GroupState","createPaintResources","opts","EffectTargets","PaintScratch","attrs","DEFAULT_BAKE_BUDGET","OUTLINE_MIN_SCREEN_PX","VERT_SRC","FRAG_SRC","PATH_FILL_UNIFORMS","PATH_FILL_ATTRIBUTES","VCOLOR_VERT_SRC","VCOLOR_FRAG_SRC","PATH_FILL_VCOLOR_ATTRIBUTES","IMAGE_VERT_SRC","IMAGE_FRAG_SRC","IMAGE_FILL_UNIFORMS","IMAGE_FILL_ATTRIBUTES","BATCH_VERT_SRC","BATCH_FRAG_SRC","BATCH_FILL_UNIFORMS","BATCH_FILL_ATTRIBUTES","GRAD_VERT_SRC","GRAD_FRAG_SRC","GRAD_FILL_UNIFORMS","GRAD_FILL_ATTRIBUTES","PATTERN_VERT_SRC","PATTERN_FRAG_SRC","PATTERN_FILL_UNIFORMS","PATTERN_FILL_ATTRIBUTES","aPos","GLMeshCache","GLTextureCache","GLImageCache","GradientRampAtlas","DrawBatch","createWhiteTexture","QUAD_VERTICES","QUAD_INDICES","getProgramSource","handle","previous","id","compiled","e","existing","kind","frag","uniforms","GLYPH_PAINT_VERT_SRC","GLYPH_PAINT_ATTRIBUTES","w","h","x","y","target","markAllFontsNotUploaded","prog","t0","counters","spanStats","resetBakeBudget","ctx","spans","next","si","span","commands","drawsBefore","spanT0","flushBatch","tolerance","dims","tex"],"sources":["../../src/renderer/WeaselRenderer.ts"],"sourcesContent":["import { createPaintResources, type OwnedPaintResources } from './paintResources';\nimport { ShaderProgram } from './shaders/ShaderProgram';\nimport {\n  VERT_SRC,\n  FRAG_SRC,\n  VCOLOR_VERT_SRC,\n  VCOLOR_FRAG_SRC,\n  PATH_FILL_UNIFORMS,\n  PATH_FILL_ATTRIBUTES,\n  PATH_FILL_VCOLOR_ATTRIBUTES,\n} from './shaders/pathFill';\nimport {\n  markAllFontsNotUploaded,\n  resetBakeBudget,\n  DEFAULT_BAKE_BUDGET,\n} from '@weasel-js/font';\nimport {\n  IMAGE_VERT_SRC,\n  IMAGE_FRAG_SRC,\n  IMAGE_FILL_UNIFORMS,\n  IMAGE_FILL_ATTRIBUTES,\n} from './shaders/imageFill';\nimport {\n  BATCH_VERT_SRC,\n  BATCH_FRAG_SRC,\n  BATCH_FILL_UNIFORMS,\n  BATCH_FILL_ATTRIBUTES,\n} from './shaders/batchFill';\nimport {\n  GRAD_VERT_SRC,\n  GRAD_FRAG_SRC,\n  GRAD_FILL_UNIFORMS,\n  GRAD_FILL_ATTRIBUTES,\n} from './shaders/gradFill';\nimport {\n  PATTERN_VERT_SRC,\n  PATTERN_FRAG_SRC,\n  PATTERN_FILL_UNIFORMS,\n  PATTERN_FILL_ATTRIBUTES,\n} from './shaders/patternFill';\nimport {\n  GLYPH_PAINT_VERT_SRC,\n  GLYPH_PATTERN_FRAG_SRC,\n  GLYPH_GRAD_FRAG_SRC,\n  GLYPH_TEXTURE_FRAG_SRC,\n  GLYPH_PATTERN_UNIFORMS,\n  GLYPH_GRAD_UNIFORMS,\n  GLYPH_TEXTURE_UNIFORMS,\n  GLYPH_PAINT_ATTRIBUTES,\n} from './shaders/glyphPaint';\nimport { PaintScratch } from './paintScratch';\nimport { GLMeshCache } from './cache/GLMeshCache';\nimport { GLTextureCache } from './cache/GLTextureCache';\nimport { GLImageCache, type ImageMinification } from './cache/GLImageCache';\nimport { GradientRampAtlas } from './cache/GradientRampAtlas';\nimport { GroupState } from './state/GroupState';\nimport type { DrawCommand } from './DrawCommand';\nimport type { GlMat3 } from './math/mat3';\nimport {\n  dispatch, flushBatch, OUTLINE_MIN_SCREEN_PX, type DrawContext, type GlyphPaintKind,\n} from './draw';\nimport { DrawBatch } from './drawBatch';\nimport {\n  CUSTOM_VERT_SRC, CUSTOM_ATTRIBUTES, CUSTOM_KIT_UNIFORMS,\n  QUAD_VERTICES, QUAD_INDICES,\n} from './shaders/customPrelude';\nimport { getProgramSource, type ProgramSource, type ShaderProgramHandle } from './shaders/registerProgram';\nimport { EffectTargets } from './effects/EffectTargets';\nimport { extractUniformArrays, extractUniformNames } from './shaders/extractUniformNames';\n\n/** Every uniform a custom program may be written through. Both stages, not\n *  just the fragment one: a name never looked up is written through `null`,\n *  which GL accepts silently, so the uniform keeps its zero default. */\nfunction customUniformNames(vertSrc: string, fragSrc: string): string[] {\n  return [...CUSTOM_KIT_UNIFORMS, ...extractUniformNames(vertSrc), ...extractUniformNames(fragSrc)];\n}\n\n/** Compile a registered program's source against `gl`, with every uniform\n *  location and array base it may be written through. */\nfunction compileCustomProgram(gl: WebGL2RenderingContext, src: ProgramSource): ShaderProgram {\n  const vertSrc = src.vert === '' ? CUSTOM_VERT_SRC : src.vert;\n  const program = new ShaderProgram(gl, vertSrc, src.frag);\n  program.lookupUniforms(customUniformNames(vertSrc, src.frag));\n  program.lookupUniformArrays(new Map([...extractUniformArrays(vertSrc), ...extractUniformArrays(src.frag)]));\n  program.lookupAttributes(CUSTOM_ATTRIBUTES);\n  return program;\n}\n\n/** How to construct a `WeaselRenderer`: the GL context or canvas to draw\n *  into, the output size, and the quality knobs that separate screen\n *  rendering from print. */\n/** A run of top-level commands, `[start, end)` by index, that\n *  {@link WeaselRenderer.lastFrameStats} accounts for separately — one render\n *  layer's commands, say. Spans are in order and do not overlap. */\nexport interface RenderSpan {\n  id: string;\n  start: number;\n  end: number;\n}\n\n/** Per-frame options for {@link WeaselRenderer.render}. */\nexport interface RenderOptions {\n  spans?: readonly RenderSpan[];\n}\n\n/** What one span cost. A batched run is drawn when something closes it, so\n *  its draw call counts toward the span that closed it. */\nexport interface RenderSpanStats {\n  id: string;\n  drawCalls: number;\n  ms: number;\n}\n\n/** What one `render()` cost. See {@link WeaselRenderer.lastFrameStats}. */\nexport interface RenderStats {\n  drawCalls: number;\n  ms: number;\n  spans: RenderSpanStats[];\n}\n\nfunction now(): number {\n  return typeof performance !== 'undefined' ? performance.now() : Date.now();\n}\n\n/** Construction options for {@link WeaselRenderer}. Pass `gl` or `canvas`;\n *  a context passed in must have a stencil buffer. */\nexport interface WeaselRendererOptions {\n  /** A WebGL2 context to draw with. Wins over `canvas`. */\n  gl?: WebGL2RenderingContext;\n  /** A canvas to open a stencil-backed WebGL2 context on, when `gl` is absent. */\n  canvas?: HTMLCanvasElement;\n  /** Drawing size in CSS pixels. */\n  width: number;\n  /** Drawing size in CSS pixels. */\n  height: number;\n  /** Device pixels per CSS pixel. */\n  dpr: number;\n  /** MIN_FILTER strategy for image/pattern textures (`GLImageCache`).\n   *  Default `'linear'` — the existing screen behavior. The headless\n   *  `renderSceneToPixels` path passes `'mipmap'` for print-quality\n   *  minification. Explicitly passing `'linear'` is always valid. */\n  imageMinification?: ImageMinification;\n  /** Flatness tolerance for curve tessellation, in WORLD units (see\n   *  `TessellateOptions.flattenTolerance`). When set, path fills are\n   *  tessellated fresh at this tolerance per frame (transient pool) instead\n   *  of served from the Path-identity mesh cache — the cache key does not\n   *  include tolerance. Default: unset — the existing cached behavior at\n   *  `DEFAULT_FLATTEN_TOLERANCE`. The headless path derives this from the\n   *  requested output scale; screen callers normally leave it unset. */\n  flattenTolerance?: number;\n  /** Per-render synchronous bake budget for dynamic canvas-SDF glyphs.\n   *  Default DEFAULT_BAKE_BUDGET (16). The headless renderSceneToPixels\n   *  path passes Infinity so print never defers a glyph. */\n  bakeBudget?: number;\n  /** On-screen glyph size, in CSS pixels, at or above which text renders from\n   *  tessellated font outlines instead of a distance field — see\n   *  `OUTLINE_MIN_SCREEN_PX`. Only faces registered with\n   *  `registerFontOutlines` are affected; everything else keeps its SDF tier\n   *  whatever this says. Pass `Infinity` to disable the tier outright, or 0\n   *  to use outlines wherever they exist (what the headless path does, since\n   *  print has no reason to sample a field it could evaluate exactly). */\n  textOutlineMinScreenSize?: number;\n}\n\n/** Where a renderer draws inside a buffer it does not own.\n *\n *  The rect's SIZE is the renderer's own `width`/`height` — `resize()` owns\n *  that, and a second copy here could disagree with the one `DrawContext`\n *  reports to screen-space layers. */\nexport interface RenderTarget {\n  /** Top-left of this renderer's output within the drawing buffer, in CSS\n   *  pixels, with the origin at the buffer's top-left. GL's bottom-left origin\n   *  is handled internally. */\n  origin: { x: number; y: number };\n  /** Clear colour and stencil within the rect before drawing. Default true.\n   *  Pass false only when the caller clears the whole buffer itself on behalf\n   *  of every co-tenant — a frame that clears neither inherits its neighbour's\n   *  stencil bits, and even-odd fills then fill their holes. */\n  clear?: boolean;\n}\n\n/** Each glyph-paint program's fragment stage and the uniforms it looks up. */\nconst GLYPH_PAINT_SOURCES: Record<GlyphPaintKind, readonly [string, readonly string[]]> = {\n  pattern: [GLYPH_PATTERN_FRAG_SRC, GLYPH_PATTERN_UNIFORMS],\n  gradient: [GLYPH_GRAD_FRAG_SRC, GLYPH_GRAD_UNIFORMS],\n  texture: [GLYPH_TEXTURE_FRAG_SRC, GLYPH_TEXTURE_UNIFORMS],\n};\n\n/**\n * The WebGL2 renderer: takes a list of draw commands and paints them.\n *\n * It knows nothing about the scene — commands are the whole interface, which\n * is what lets layers, HUD widgets and overlays all draw through the same\n * pipeline. GPU resources (meshes, textures, gradient ramps) are cached across\n * frames and keyed by identity, so re-issuing the same command is cheap.\n */\nexport class WeaselRenderer {\n  private readonly gl: WebGL2RenderingContext;\n  private stats: RenderStats = { drawCalls: 0, ms: 0, spans: [] };\n  private pathFill: ShaderProgram;\n  private pathFillVColor: ShaderProgram;\n  private imageFill: ShaderProgram;\n  private batchFill: ShaderProgram;\n  private gradFill: ShaderProgram;\n  private patternFill: ShaderProgram;\n  /** Compiled on first use: only atlas text under a texture paint needs one. */\n  private glyphPaintPrograms = new Map<GlyphPaintKind, ShaderProgram>();\n  private meshCache: GLMeshCache;\n  private textureCache: GLTextureCache;\n  private imageCache: GLImageCache;\n  private gradRamps: GradientRampAtlas;\n  private programRegistry = new Map<string, ShaderProgram>();\n  /** The source each compiled custom program was built from — or, after a\n   *  failed recompile, the source that failed, so it is not retried every frame. */\n  private programSources = new Map<string, ProgramSource>();\n  private quadVbo: WebGLBuffer | null = null;\n  private quadIbo: WebGLBuffer | null = null;\n  private drawBatch: DrawBatch;\n  /** 1x1 white, so a batch flush sampling no image still samples something —\n   *  see `shaders/batchFill.ts`. */\n  private whiteTexture: WebGLTexture | null = null;\n  private readonly groupState = new GroupState();\n  private widthCss: number;\n  private heightCss: number;\n  private dpr: number;\n  private canvas: HTMLCanvasElement | null = null;\n  private target: RenderTarget | null = null;\n  /** Offscreen buffers for group effects. Allocates nothing until a group\n   *  with effects asks, so a canvas without them pays no memory. */\n  private readonly effectTargets: EffectTargets;\n  private readonly paintScratch: PaintScratch;\n  private readonly imageMinification: ImageMinification;\n  private flattenTolerance?: number;\n  private readonly bakeBudget: number;\n  private readonly textOutlineMinScreenSize: number;\n  private contextLost = false;\n  private boundOnLost = (e: Event) => this.onContextLost(e);\n  private boundOnRestored = () => this.onContextRestored();\n  /** True after `dispose()`. A disposed renderer ignores further `render()`\n   *  calls and `registerProgram()` calls. */\n  private disposed = false;\n  /** What registered paint kinds hang their GPU state on. One per context\n   *  generation: a restore releases it and opens the next. */\n  private paintResources: OwnedPaintResources = createPaintResources();\n\n  constructor(opts: WeaselRendererOptions) {\n    if (!opts.gl && !opts.canvas) {\n      throw new Error('WeaselRenderer requires either gl or canvas');\n    }\n    const gl = opts.gl ?? opts.canvas!.getContext('webgl2', { stencil: true });\n    if (!gl) throw new Error('WeaselRenderer: WebGL2 not available');\n    this.gl = gl as WebGL2RenderingContext;\n    this.effectTargets = new EffectTargets(this.gl);\n    this.paintScratch = new PaintScratch(this.gl);\n\n    // Bits 0-7 are load-bearing: bit 0 for even-odd fills and stenciled\n    // strokes, bits 1-7 for clip depth (`renderer/draw.ts`). Without a stencil\n    // buffer both render wrong rather than not at all, so refuse the context\n    // instead of painting a plausible lie. A stub that cannot answer is not a\n    // stencil-less context — only an explicit `false` is.\n    const attrs = typeof this.gl.getContextAttributes === 'function'\n      ? this.gl.getContextAttributes()\n      : null;\n    if (attrs && attrs.stencil === false) {\n      throw new Error(\n        'WeaselRenderer: the supplied WebGL2 context has no stencil buffer. '\n        + 'Create it with { stencil: true } — clips and even-odd fills need one.',\n      );\n    }\n\n    this.widthCss = opts.width;\n    this.heightCss = opts.height;\n    this.dpr = opts.dpr;\n    this.imageMinification = opts.imageMinification ?? 'linear';\n    this.flattenTolerance = opts.flattenTolerance;\n    this.bakeBudget = opts.bakeBudget ?? DEFAULT_BAKE_BUDGET;\n    this.textOutlineMinScreenSize = opts.textOutlineMinScreenSize ?? OUTLINE_MIN_SCREEN_PX;\n\n    this.canvas = opts.canvas ?? null;\n    if (this.canvas) {\n      this.canvas.width = Math.round(opts.width * opts.dpr);\n      this.canvas.height = Math.round(opts.height * opts.dpr);\n      if (this.canvas.style) {\n        this.canvas.style.width = `${opts.width}px`;\n        this.canvas.style.height = `${opts.height}px`;\n      }\n      this.canvas.addEventListener('webglcontextlost', this.boundOnLost);\n      this.canvas.addEventListener('webglcontextrestored', this.boundOnRestored);\n    }\n\n    this.applyGlState();\n    this.applyTarget();\n\n    this.pathFill = new ShaderProgram(this.gl, VERT_SRC, FRAG_SRC);\n    this.pathFill.lookupUniforms(PATH_FILL_UNIFORMS);\n    this.pathFill.lookupAttributes(PATH_FILL_ATTRIBUTES);\n\n    this.pathFillVColor = new ShaderProgram(this.gl, VCOLOR_VERT_SRC, VCOLOR_FRAG_SRC);\n    this.pathFillVColor.lookupUniforms(PATH_FILL_UNIFORMS);\n    this.pathFillVColor.lookupAttributes(PATH_FILL_VCOLOR_ATTRIBUTES);\n\n    this.imageFill = new ShaderProgram(this.gl, IMAGE_VERT_SRC, IMAGE_FRAG_SRC);\n    this.imageFill.lookupUniforms(IMAGE_FILL_UNIFORMS);\n    this.imageFill.lookupAttributes(IMAGE_FILL_ATTRIBUTES);\n\n    this.batchFill = new ShaderProgram(this.gl, BATCH_VERT_SRC, BATCH_FRAG_SRC);\n    this.batchFill.lookupUniforms(BATCH_FILL_UNIFORMS);\n    this.batchFill.lookupAttributes(BATCH_FILL_ATTRIBUTES);\n\n    this.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);\n    this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);\n    this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);\n\n    this.patternFill = new ShaderProgram(this.gl, PATTERN_VERT_SRC, PATTERN_FRAG_SRC);\n    this.patternFill.lookupUniforms(PATTERN_FILL_UNIFORMS);\n    this.patternFill.lookupAttributes(PATTERN_FILL_ATTRIBUTES);\n\n    const aPos = this.pathFill.attribute('a_position');\n    if (aPos === undefined) throw new Error('WeaselRenderer: a_position not found in path-fill shader');\n    this.meshCache = new GLMeshCache(this.gl, aPos);\n    this.textureCache = new GLTextureCache(this.gl);\n    this.imageCache = new GLImageCache(this.gl, this.imageMinification);\n    this.gradRamps = new GradientRampAtlas(this.gl);\n    this.uploadQuadGeometry();\n    this.drawBatch = new DrawBatch(this.gl, this.batchFill);\n    this.whiteTexture = createWhiteTexture(this.gl);\n  }\n\n  private uploadQuadGeometry(): void {\n    const gl = this.gl;\n    this.quadVbo = gl.createBuffer();\n    this.quadIbo = gl.createBuffer();\n    if (!this.quadVbo || !this.quadIbo) {\n      throw new Error('WeaselRenderer: failed to create quad geometry buffers');\n    }\n    gl.bindBuffer(gl.ARRAY_BUFFER, this.quadVbo);\n    gl.bufferData(gl.ARRAY_BUFFER, QUAD_VERTICES, gl.STATIC_DRAW);\n    gl.bindBuffer(gl.ARRAY_BUFFER, null);\n\n    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.quadIbo);\n    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, QUAD_INDICES, gl.STATIC_DRAW);\n    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);\n  }\n\n  /**\n   * Compile a consumer-registered shader program against this renderer's GL context.\n   *\n   * Call once per renderer after the module-level `registerProgram()`.\n   * Throws `ShaderCompileError` if compilation fails.\n   *\n   * In dev mode, calling again with the same handle replaces the compiled program.\n   *\n   * @experimental\n   */\n  registerProgram(handle: ShaderProgramHandle): void {\n    // A disposed renderer must not compile programs into the cleared registry.\n    if (this.disposed) return;\n    const src = getProgramSource(handle.id);\n    if (!src) {\n      throw new Error(\n        `WeaselRenderer.registerProgram: program \"${handle.id}\" not found in source registry. ` +\n        `Call the module-level registerProgram() first.`,\n      );\n    }\n    this.installProgram(handle.id, src, compileCustomProgram(this.gl, src));\n  }\n\n  private installProgram(id: string, src: ProgramSource, program: ShaderProgram): void {\n    const previous = this.programRegistry.get(id);\n    if (previous) this.gl.deleteProgram(previous.handle);\n    this.programRegistry.set(id, program);\n    this.programSources.set(id, src);\n  }\n\n  /** Recompile every program whose module-level source was re-registered\n   *  since it was compiled. A source that fails keeps the old program drawing. */\n  private refreshPrograms(): void {\n    for (const [id, compiled] of this.programSources) {\n      const src = getProgramSource(id);\n      if (!src || src === compiled) continue;\n      if (src.vert === compiled.vert && src.frag === compiled.frag) {\n        this.programSources.set(id, src);\n        continue;\n      }\n      try {\n        this.installProgram(id, src, compileCustomProgram(this.gl, src));\n      } catch (e) {\n        this.programSources.set(id, src);\n        console.error(`weasel: failed to recompile re-registered program \"${id}\"; still drawing the previous one:`, e);\n      }\n    }\n  }\n\n  /**\n   * The compiled program for `id`, compiling it against this context on first\n   * use. Unlike {@link registerProgram} this neither throws on a missing\n   * source nor on a compile failure: a paint kind asking for a program it\n   * never registered must decline the paint, not take down the frame.\n   */\n  private ensureProgram(id: string): ShaderProgram | null {\n    const existing = this.programRegistry.get(id);\n    if (existing) return existing;\n    if (this.disposed || !getProgramSource(id)) return null;\n    try {\n      this.registerProgram({ id });\n    } catch (e) {\n      console.error(`weasel: failed to compile paint program \"${id}\":`, e);\n      return null;\n    }\n    return this.programRegistry.get(id) ?? null;\n  }\n\n  private glyphPaintProgram(kind: GlyphPaintKind): ShaderProgram {\n    const existing = this.glyphPaintPrograms.get(kind);\n    if (existing) return existing;\n    const [frag, uniforms] = GLYPH_PAINT_SOURCES[kind];\n    const program = new ShaderProgram(this.gl, GLYPH_PAINT_VERT_SRC, frag);\n    program.lookupUniforms(uniforms);\n    program.lookupAttributes(GLYPH_PAINT_ATTRIBUTES);\n    this.glyphPaintPrograms.set(kind, program);\n    return program;\n  }\n\n  /** The GL state every frame assumes. Applied per `render()` rather than once\n   *  at construction because a co-tenant sharing this context moves all of it\n   *  between our frames. */\n  private applyGlState(): void {\n    const gl = this.gl;\n    gl.enable(gl.BLEND);\n    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n    gl.disable(gl.DEPTH_TEST);\n    gl.disable(gl.CULL_FACE);\n    gl.clearColor(0, 0, 0, 0);\n  }\n\n  /** Viewport and scissor for this frame. Re-applied inside `render()` because\n   *  a co-tenant on the same context moves both between our frames. */\n  private applyTarget(): void {\n    const gl = this.gl;\n    const w = Math.round(this.widthCss * this.dpr);\n    const h = Math.round(this.heightCss * this.dpr);\n    if (!this.target) {\n      gl.disable(gl.SCISSOR_TEST);\n      gl.viewport(0, 0, w, h);\n      return;\n    }\n    const x = Math.round(this.target.origin.x * this.dpr);\n    const y = gl.drawingBufferHeight - Math.round(this.target.origin.y * this.dpr) - h;\n    gl.viewport(x, y, w, h);\n    gl.scissor(x, y, w, h);\n    gl.enable(gl.SCISSOR_TEST);\n  }\n\n  /** Confine this renderer to a rect of its drawing buffer, or pass null to\n   *  give it the whole buffer back. Takes effect from the next `render()`. */\n  setTarget(target: RenderTarget | null): void {\n    this.target = target;\n    this.applyTarget();\n  }\n\n  getTarget(): RenderTarget | null {\n    return this.target;\n  }\n\n  isContextLost(): boolean {\n    return this.contextLost;\n  }\n\n  private onContextLost(e: Event): void {\n    e.preventDefault();\n    this.contextLost = true;\n  }\n\n  private onContextRestored(): void {\n    this.contextLost = false;\n    this.applyGlState();\n    this.applyTarget();\n    // Every framebuffer, texture and renderbuffer the pool held died with the\n    // context. `releaseAll` deletes handles that are already gone, which is a\n    // no-op, and drops the bookkeeping that would otherwise hand a dead FBO to\n    // the next group with effects.\n    this.effectTargets.releaseAll();\n    this.paintScratch.release();\n    this.paintResources.release();\n    this.paintResources = createPaintResources();\n    this.pathFill = new ShaderProgram(this.gl, VERT_SRC, FRAG_SRC);\n    this.pathFill.lookupUniforms(PATH_FILL_UNIFORMS);\n    this.pathFill.lookupAttributes(PATH_FILL_ATTRIBUTES);\n    this.pathFillVColor = new ShaderProgram(this.gl, VCOLOR_VERT_SRC, VCOLOR_FRAG_SRC);\n    this.pathFillVColor.lookupUniforms(PATH_FILL_UNIFORMS);\n    this.pathFillVColor.lookupAttributes(PATH_FILL_VCOLOR_ATTRIBUTES);    this.imageFill = new ShaderProgram(this.gl, IMAGE_VERT_SRC, IMAGE_FRAG_SRC);\n    this.imageFill.lookupUniforms(IMAGE_FILL_UNIFORMS);\n    this.imageFill.lookupAttributes(IMAGE_FILL_ATTRIBUTES);\n\n    this.batchFill = new ShaderProgram(this.gl, BATCH_VERT_SRC, BATCH_FRAG_SRC);\n    this.batchFill.lookupUniforms(BATCH_FILL_UNIFORMS);\n    this.batchFill.lookupAttributes(BATCH_FILL_ATTRIBUTES);\n    this.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);\n    this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);\n    this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);\n\n    this.patternFill = new ShaderProgram(this.gl, PATTERN_VERT_SRC, PATTERN_FRAG_SRC);\n    this.patternFill.lookupUniforms(PATTERN_FILL_UNIFORMS);\n    this.patternFill.lookupAttributes(PATTERN_FILL_ATTRIBUTES);\n    this.glyphPaintPrograms.clear();\n    const aPos = this.pathFill.attribute('a_position');\n    if (aPos === undefined) throw new Error('a_position missing after restore');\n    this.meshCache = new GLMeshCache(this.gl, aPos);\n    this.textureCache = new GLTextureCache(this.gl);\n    this.imageCache.abandon();\n    this.imageCache = new GLImageCache(this.gl, this.imageMinification);\n    this.gradRamps = new GradientRampAtlas(this.gl);\n    markAllFontsNotUploaded();\n\n    this.uploadQuadGeometry();\n    this.drawBatch = new DrawBatch(this.gl, this.batchFill);\n    this.whiteTexture = createWhiteTexture(this.gl);\n    for (const id of this.programRegistry.keys()) {\n      const src = getProgramSource(id);\n      if (!src) continue;\n      try {\n        this.programRegistry.set(id, compileCustomProgram(this.gl, src));\n        this.programSources.set(id, src);\n      } catch (e) {\n        console.error(`weasel: failed to recompile program \"${id}\" after context restore:`, e);\n      }\n    }\n  }\n\n  /** Free every GL resource this renderer created and detach context-loss\n   *  listeners when a canvas was supplied. Idempotent.\n   *\n   *  That covers the built-in and consumer-registered programs (their shaders\n   *  go with them), the shared quad geometry, the batch, the effect targets,\n   *  and every cache: atlas and gradient-ramp textures, bitmap and pattern\n   *  textures, and meshes — transient, persistent, and those whose Path was\n   *  already collected. The context itself is left alone, so a caller-owned\n   *  context can host renderer after renderer without accumulating anything.\n   *\n   *  A disposed renderer ignores further `render()` and `registerProgram()`\n   *  calls. */\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    const gl = this.gl;\n    if (this.canvas) {\n      this.canvas.removeEventListener('webglcontextlost', this.boundOnLost);\n      this.canvas.removeEventListener('webglcontextrestored', this.boundOnRestored);\n    }\n    this.meshCache.dispose();\n    this.paintResources.release();\n    for (const prog of [\n      this.pathFill, this.pathFillVColor, this.imageFill, this.batchFill, this.gradFill, this.patternFill,\n      ...this.glyphPaintPrograms.values(),\n    ]) {\n      gl.deleteProgram(prog.handle);\n    }\n    this.glyphPaintPrograms.clear();\n    for (const prog of this.programRegistry.values()) {\n      gl.deleteProgram(prog.handle);\n    }\n    this.programRegistry.clear();\n    this.programSources.clear();\n    this.textureCache.free();\n    this.imageCache.dispose();\n    this.gradRamps.free();\n    if (this.quadVbo) gl.deleteBuffer(this.quadVbo);\n    if (this.quadIbo) gl.deleteBuffer(this.quadIbo);\n    this.drawBatch.dispose();\n    if (this.whiteTexture) gl.deleteTexture(this.whiteTexture);\n    this.whiteTexture = null;\n    this.effectTargets.releaseAll();\n    this.paintScratch.release();\n  }\n\n  /**\n   * Draw one frame.\n   *\n   * `viewMatrix` is the frame's world→screen transform. It is only consulted\n   * by `units: 'world'` gradients, which fall back to screen space without\n   * it — every other command carries its own transform in the stream, so\n   * callers with no view concept can keep calling `render(commands)`.\n   */\n  render(commands: DrawCommand[], viewMatrix?: GlMat3, opts?: RenderOptions): void {\n    if (this.contextLost || this.disposed) return;\n    const t0 = now();\n    const counters = { drawCalls: 0 };\n    const spanStats: RenderSpanStats[] = [];\n    this.stats = { drawCalls: 0, ms: 0, spans: spanStats };\n    const gl = this.gl;\n    // Free GL resources whose Mesh was GC'd since the last frame. Done here\n    // (top of render, before any draws) because GL state is known clean —\n    // no VAO bound, no draw in flight. Deleting from the FinalizationRegistry\n    // callback directly was racy and caused mid-draw crashes.\n    this.meshCache.drainPendingDeletes();\n    this.refreshPrograms();\n    // New frame: refill the dynamic-glyph synchronous bake budget.\n    resetBakeBudget(this.bakeBudget);\n    this.groupState.reset();\n    this.applyGlState();\n    this.applyTarget();\n    // Ensure all stencil bits are cleared regardless of any mask left over\n    // from the previous frame's clip ops.\n    if (this.target?.clear !== false) {\n      gl.stencilMask(0xFF);\n      gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);\n    }\n    const ctx: DrawContext = {\n      gl,\n      pathFill: this.pathFill,\n      pathFillVColor: this.pathFillVColor,\n      imageFill: this.imageFill,\n      batchFill: this.batchFill,\n      gradFill: this.gradFill,\n      patternFill: this.patternFill,\n      meshCache: this.meshCache,\n      textureCache: this.textureCache,\n      imageCache: this.imageCache,\n      gradRamps: this.gradRamps,\n      programRegistry: this.programRegistry,\n      ensureProgram: (id) => this.ensureProgram(id),\n      glyphPaintProgram: (kind) => this.glyphPaintProgram(kind),\n      quadVbo: this.quadVbo,\n      quadIbo: this.quadIbo,\n      drawBatch: this.drawBatch,\n      whiteTexture: this.whiteTexture,\n      state: this.groupState,\n      widthCss: this.widthCss,\n      heightCss: this.heightCss,\n      clipDepth: 0,\n      clipStack: [],\n      flattenTolerance: this.flattenTolerance,\n      textOutlineMinScreenSize: this.textOutlineMinScreenSize,\n      viewMatrix,\n      effectTargets: this.effectTargets,\n      paintScratch: this.paintScratch,\n      renderTarget: null,\n      deviceWidth: Math.round(this.widthCss * this.dpr),\n      deviceHeight: Math.round(this.heightCss * this.dpr),\n      restoreTargetRect: () => this.applyTarget(),\n      paintResources: this.paintResources,\n      stats: counters,\n    };\n    // A frame that threw part-way left its clip here.\n    this.drawBatch.clip = null;\n    const spans = opts?.spans ?? [];\n    let next = 0;\n    for (let si = 0; si < spans.length; si++) {\n      const span = spans[si];\n      for (; next < span.start; next++) dispatch(ctx, commands[next]);\n      const drawsBefore = counters.drawCalls;\n      const spanT0 = now();\n      for (; next < span.end; next++) dispatch(ctx, commands[next]);\n      // The stream's closing flush belongs to whatever it closes.\n      if (si === spans.length - 1 && next >= commands.length) flushBatch(ctx);\n      spanStats.push({ id: span.id, drawCalls: counters.drawCalls - drawsBefore, ms: now() - spanT0 });\n    }\n    for (; next < commands.length; next++) dispatch(ctx, commands[next]);\n    // The stream ended, so whatever is still staged has nothing left that\n    // could merge with it.\n    flushBatch(ctx);\n    // Free transient resources allocated during this frame (e.g. per-frame\n    // stroke ribbons from tessellateStroke). Done after all draws complete\n    // so we never delete a buffer that's still bound to a pending draw.\n    this.meshCache.freeTransient();\n    this.stats.drawCalls = counters.drawCalls;\n    this.stats.ms = now() - t0;\n  }\n\n  /** What the last `render()` cost: GL draw calls issued and CPU milliseconds\n   *  spent issuing them, in total and per requested span. GPU time is not\n   *  measured; the GPU runs asynchronously. */\n  lastFrameStats(): RenderStats {\n    return this.stats;\n  }\n\n  /** Change the curve-flattening tolerance after construction. `undefined`\n   *  restores the cached `DEFAULT_FLATTEN_TOLERANCE` route. */\n  setFlattenTolerance(tolerance: number | undefined): void {\n    this.flattenTolerance = tolerance;\n  }\n\n  resize(dims: { width: number; height: number; dpr: number }): void {\n    this.widthCss = dims.width;\n    this.heightCss = dims.height;\n    this.dpr = dims.dpr;\n    if (this.canvas) {\n      this.canvas.width = Math.round(dims.width * dims.dpr);\n      this.canvas.height = Math.round(dims.height * dims.dpr);\n      if (this.canvas.style) {\n        this.canvas.style.width = `${dims.width}px`;\n        this.canvas.style.height = `${dims.height}px`;\n      }\n    }\n    this.applyTarget();\n  }\n\n  /** @internal */ _gl(): WebGL2RenderingContext { return this.gl; }\n  /** @internal */ _pathFill(): ShaderProgram { return this.pathFill; }\n  /** @internal */ _pathFillVColor(): ShaderProgram { return this.pathFillVColor; }\n  /** @internal */ _drawBatch(): DrawBatch { return this.drawBatch; }\n  /** @internal */ _imageFill(): ShaderProgram { return this.imageFill; }\n  /** @internal */ _batchFill(): ShaderProgram { return this.batchFill; }\n  /** @internal */ _gradFill(): ShaderProgram { return this.gradFill; }\n  /** @internal */ _patternFill(): ShaderProgram { return this.patternFill; }\n  /** @internal */ _meshCache(): GLMeshCache { return this.meshCache; }\n  /** @internal */ _textureCache(): GLTextureCache { return this.textureCache; }\n  /** @internal */ _imageCache(): GLImageCache { return this.imageCache; }\n  /** @internal */ _gradRamps(): GradientRampAtlas { return this.gradRamps; }\n  /** @internal */ _groupState(): GroupState { return this.groupState; }\n  /** @internal */ _widthCss(): number { return this.widthCss; }\n  /** @internal */ _heightCss(): number { return this.heightCss; }\n  /** @internal */ _dpr(): number { return this.dpr; }\n}\n\n/** The 1x1 opaque white texture a batch flush binds when its run samples no\n *  image. NEAREST both ways: one texel, so there is nothing to filter, and a\n *  mipmap filter on a texture with no mipmaps is incomplete. */\nfunction createWhiteTexture(gl: WebGL2RenderingContext): WebGLTexture | null {\n  const tex = gl.createTexture();\n  if (!tex) return null;\n  gl.bindTexture(gl.TEXTURE_2D, tex);\n  gl.texImage2D(\n    gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE,\n    new Uint8Array([255, 255, 255, 255]),\n  );\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n  gl.bindTexture(gl.TEXTURE_2D, null);\n  return tex;\n}\n"],"mappings":"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"}

package/dist/renderer/batchClip.js

@@ -1,46 +0,0 @@
-//#region src/renderer/batchClip.ts
-function e(e, t) {
-	if (e.kind !== "rect" || !(t[1] === 0 && t[3] === 0 || t[0] === 0 && t[4] === 0)) return null;
-	let n = t[0] * e.x + t[3] * e.y + t[6], r = t[1] * e.x + t[4] * e.y + t[7], i = e.x + e.width, a = e.y + e.height, o = t[0] * i + t[3] * a + t[6], s = t[1] * i + t[4] * a + t[7];
-	return {
-		x0: Math.min(n, o),
-		y0: Math.min(r, s),
-		x1: Math.max(n, o),
-		y1: Math.max(r, s)
-	};
-}
-function t(e, t) {
-	return {
-		x0: Math.max(e.x0, t.x0),
-		y0: Math.max(e.y0, t.y0),
-		x1: Math.min(e.x1, t.x1),
-		y1: Math.min(e.y1, t.y1)
-	};
-}
-function n(e, t, n, i, a, o) {
-	let s = r(e, t, n, 0, i.x0, 1, o);
-	return s = r(o, s, n, 0, i.x1, -1, a), s = r(a, s, n, 1, i.y0, 1, o), r(o, s, n, 1, i.y1, -1, a);
-}
-function r(e, t, n, r, i, a, o) {
-	if (t === 0) return 0;
-	let s = 0, c = t - 1, l = a * (e[c * n + r] - i) >= 0;
-	for (let u = 0; u < t; u++) {
-		let t = a * (e[u * n + r] - i) >= 0;
-		if (t !== l) {
-			let t = c * n, a = u * n, l = (i - e[t + r]) / (e[a + r] - e[t + r]), d = s * n;
-			for (let r = 0; r < n; r++) o[d + r] = e[t + r] + l * (e[a + r] - e[t + r]);
-			o[d + r] = i, s++;
-		}
-		if (t) {
-			let t = s * n, r = u * n;
-			for (let i = 0; i < n; i++) o[t + i] = e[r + i];
-			s++;
-		}
-		c = u, l = t;
-	}
-	return s;
-}
-//#endregion
-export { e as axisAlignedClipRect, n as clipConvexPolygon, t as intersectClipRects };
-
-//# sourceMappingURL=batchClip.js.map

package/dist/renderer/batchClip.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"batchClip.js","names":["axisAlignedClipRect","path","m","ax","ay","x1","y1","bx","by","intersectClipRects","a","b","clipConvexPolygon","count","clipEdge","src","n","stride","rect","tmp","dst","prev","prevIn","sign","axis","at","cur","curIn","t","o","k","c"],"sources":["../../src/renderer/batchClip.ts"],"sourcesContent":["/**\n * Clipping staged geometry to an axis-aligned rect on the CPU, so a rect clip\n * needs no stencil and does not break the run.\n *\n * A stencil clip is GL state, so content inside one cannot share a draw with\n * content outside it, and every clipped group paid a flush on the way in and\n * another on the way out. A rect under a transform that keeps it axis-aligned\n * is the common clip, and for that one the clip can ride the geometry instead:\n * cut each staged polygon to the rect before it joins the run.\n *\n * Exact, not approximate: every attribute a batch vertex carries is affine\n * across the polygon it belongs to, so interpolating along a cut edge gives\n * the value the rasterizer would have produced there, and the cut polygon\n * covers the same pixel centers the stencil would have passed.\n */\n\nimport type { Path } from '@weasel-js/geom';\nimport type { GlMat3 } from './math/mat3';\n\n/** In the space batch vertices are staged in: after the model transform,\n *  before the projection. */\nexport interface ClipRect {\n  x0: number;\n  y0: number;\n  x1: number;\n  y1: number;\n}\n\n/**\n * `path` under `m` as a `ClipRect`, or `null` when it is not one: not a rect\n * path, or a transform that rotates or skews it off the axes.\n */\nexport function axisAlignedClipRect(path: Path, m: GlMat3): ClipRect | null {\n  if (path.kind !== 'rect') return null;\n  const keepsAxes = (m[1] === 0 && m[3] === 0) || (m[0] === 0 && m[4] === 0);\n  if (!keepsAxes) return null;\n  const ax = m[0] * path.x + m[3] * path.y + m[6];\n  const ay = m[1] * path.x + m[4] * path.y + m[7];\n  const x1 = path.x + path.width;\n  const y1 = path.y + path.height;\n  const bx = m[0] * x1 + m[3] * y1 + m[6];\n  const by = m[1] * x1 + m[4] * y1 + m[7];\n  return {\n    x0: Math.min(ax, bx), y0: Math.min(ay, by),\n    x1: Math.max(ax, bx), y1: Math.max(ay, by),\n  };\n}\n\nexport function intersectClipRects(a: ClipRect, b: ClipRect): ClipRect {\n  return {\n    x0: Math.max(a.x0, b.x0), y0: Math.max(a.y0, b.y0),\n    x1: Math.min(a.x1, b.x1), y1: Math.min(a.y1, b.y1),\n  };\n}\n\n/**\n * Cut the convex polygon of `n` vertices in `src` (each `stride` floats, x and\n * y first) to `rect`, writing the result to `dst`. Returns the vertex count,\n * which is below 3 when nothing is left. `tmp` must hold as many floats as\n * `dst`; both need room for `n + 4` vertices.\n */\nexport function clipConvexPolygon(\n  src: Float32Array, n: number, stride: number, rect: ClipRect,\n  dst: Float32Array, tmp: Float32Array,\n): number {\n  // Four passes, ping-ponging so the last one lands in `dst`.\n  let count = clipEdge(src, n, stride, 0, rect.x0, 1, tmp);\n  count = clipEdge(tmp, count, stride, 0, rect.x1, -1, dst);\n  count = clipEdge(dst, count, stride, 1, rect.y0, 1, tmp);\n  return clipEdge(tmp, count, stride, 1, rect.y1, -1, dst);\n}\n\n/** One Sutherland–Hodgman pass: keep the side of `axis = at` where\n *  `sign * (v - at) >= 0`. */\nfunction clipEdge(\n  src: Float32Array, n: number, stride: number,\n  axis: 0 | 1, at: number, sign: 1 | -1, out: Float32Array,\n): number {\n  if (n === 0) return 0;\n  let m = 0;\n  let prev = n - 1;\n  let prevIn = sign * (src[prev * stride + axis] - at) >= 0;\n  for (let cur = 0; cur < n; cur++) {\n    const curIn = sign * (src[cur * stride + axis] - at) >= 0;\n    if (curIn !== prevIn) {\n      const a = prev * stride;\n      const b = cur * stride;\n      const t = (at - src[a + axis]) / (src[b + axis] - src[a + axis]);\n      const o = m * stride;\n      for (let k = 0; k < stride; k++) out[o + k] = src[a + k] + t * (src[b + k] - src[a + k]);\n      // On the line exactly, whatever the interpolation rounded to.\n      out[o + axis] = at;\n      m++;\n    }\n    if (curIn) {\n      const o = m * stride;\n      const c = cur * stride;\n      for (let k = 0; k < stride; k++) out[o + k] = src[c + k];\n      m++;\n    }\n    prev = cur;\n    prevIn = curIn;\n  }\n  return m;\n}\n"],"mappings":";AAgCA,SAAgBA,EAAoB,GAAY,GAA4B;CAG1E,IAFIC,EAAK,SAAS,UAEd,EADeC,EAAE,OAAO,KAAKA,EAAE,OAAO,KAAOA,EAAE,OAAO,KAAKA,EAAE,OAAO,IACxD,OAAO;CACvB,IAAMC,IAAKD,EAAE,KAAKD,EAAK,IAAIC,EAAE,KAAKD,EAAK,IAAIC,EAAE,IACvCE,IAAKF,EAAE,KAAKD,EAAK,IAAIC,EAAE,KAAKD,EAAK,IAAIC,EAAE,IACvCG,IAAKJ,EAAK,IAAIA,EAAK,OACnBK,IAAKL,EAAK,IAAIA,EAAK,QACnBM,IAAKL,EAAE,KAAKG,IAAKH,EAAE,KAAKI,IAAKJ,EAAE,IAC/BM,IAAKN,EAAE,KAAKG,IAAKH,EAAE,KAAKI,IAAKJ,EAAE;CACrC,OAAO;EACL,IAAI,KAAK,IAAIC,GAAII,CAAE;EAAG,IAAI,KAAK,IAAIH,GAAII,CAAE;EACzC,IAAI,KAAK,IAAIL,GAAII,CAAE;EAAG,IAAI,KAAK,IAAIH,GAAII,CAAE;CAC3C;AACF;AAEA,SAAgBC,EAAmB,GAAa,GAAuB;CACrE,OAAO;EACL,IAAI,KAAK,IAAIC,EAAE,IAAIC,EAAE,EAAE;EAAG,IAAI,KAAK,IAAID,EAAE,IAAIC,EAAE,EAAE;EACjD,IAAI,KAAK,IAAID,EAAE,IAAIC,EAAE,EAAE;EAAG,IAAI,KAAK,IAAID,EAAE,IAAIC,EAAE,EAAE;CACnD;AACF;AAQA,SAAgBC,EACd,GAAmB,GAAW,GAAgB,GAC9C,GAAmB,GACX;CAER,IAAIC,IAAQC,EAASC,GAAKC,GAAGC,GAAQ,GAAGC,EAAK,IAAI,GAAGC,CAAG;CAGvD,OAFA,IAAQL,EAASK,GAAKN,GAAOI,GAAQ,GAAGC,EAAK,IAAI,IAAIE,CAAG,GACxD,IAAQN,EAASM,GAAKP,GAAOI,GAAQ,GAAGC,EAAK,IAAI,GAAGC,CAAG,GAChDL,EAASK,GAAKN,GAAOI,GAAQ,GAAGC,EAAK,IAAI,IAAIE,CAAG;AACzD;AAIA,SAASN,EACP,GAAmB,GAAW,GAC9B,GAAa,GAAY,GAAc,GAC/B;CACR,IAAIE,MAAM,GAAG,OAAO;CACpB,IAAId,IAAI,GACJmB,IAAOL,IAAI,GACXM,IAASC,KAAQR,EAAIM,IAAOJ,IAASO,KAAQC,MAAO;CACxD,KAAK,IAAIC,IAAM,GAAGA,IAAMV,GAAG,KAAO;EAChC,IAAMW,IAAQJ,KAAQR,EAAIW,IAAMT,IAASO,KAAQC,MAAO;EACxD,IAAIE,MAAUL,GAAQ;GACpB,IAAMZ,IAAIW,IAAOJ,GACXN,IAAIe,IAAMT,GACVW,KAAKH,IAAKV,EAAIL,IAAIc,OAAUT,EAAIJ,IAAIa,KAAQT,EAAIL,IAAIc,KACpDK,IAAI3B,IAAIe;GACd,KAAK,IAAIa,IAAI,GAAGA,IAAIb,GAAQ,KAAK,EAAIY,IAAIC,KAAKf,EAAIL,IAAIoB,KAAKF,KAAKb,EAAIJ,IAAImB,KAAKf,EAAIL,IAAIoB;GAGrF,AADA,EAAID,IAAIL,KAAQC,GAChB;EACF;EACA,IAAIE,GAAO;GACT,IAAME,IAAI3B,IAAIe,GACRc,IAAIL,IAAMT;GAChB,KAAK,IAAIa,IAAI,GAAGA,IAAIb,GAAQ,KAAK,EAAIY,IAAIC,KAAKf,EAAIgB,IAAID;GACtD;EACF;EAEA,AADA,IAAOJ,GACP,IAASC;CACX;CACA,OAAOzB;AACT"}

package/dist/renderer/cache/GLImageCache.js

@@ -1,64 +0,0 @@
-//#region src/renderer/cache/GLImageCache.ts
-var e = 4096, t = /* @__PURE__ */ new Set();
-function n(e) {
-	for (let n of t) n.release(e);
-}
-function r() {
-	let n = Infinity;
-	for (let e of t) n = Math.min(n, e.maxTextureSide);
-	return Number.isFinite(n) ? n : e;
-}
-var i = class {
-	gl;
-	minification;
-	maxTextureSide;
-	map = /* @__PURE__ */ new WeakMap();
-	textures = /* @__PURE__ */ new Set();
-	magFilters = /* @__PURE__ */ new WeakMap();
-	constructor(n, r = "linear") {
-		this.gl = n, this.minification = r;
-		let i = n.getParameter(n.MAX_TEXTURE_SIZE);
-		this.maxTextureSide = typeof i == "number" && i > 0 ? i : e, t.add(this);
-	}
-	release(e) {
-		let t = this.map.get(e);
-		t && (this.gl.deleteTexture(t), this.textures.delete(t), this.map.delete(e), this.magFilters.delete(e));
-	}
-	dispose() {
-		for (let e of this.textures) this.gl.deleteTexture(e);
-		this.abandon();
-	}
-	abandon() {
-		this.textures.clear(), t.delete(this);
-	}
-	upload(e, t, n) {
-		let r = this.map.get(e);
-		if (r) return r;
-		let i = this.gl, o = i.createTexture();
-		if (!o) throw Error("GLImageCache: createTexture failed");
-		i.bindTexture(i.TEXTURE_2D, o), i.texImage2D(i.TEXTURE_2D, 0, i.RGBA, i.RGBA, i.UNSIGNED_BYTE, t), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MIN_FILTER, this.minification === "mipmap" ? i.LINEAR_MIPMAP_LINEAR : i.LINEAR), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MAG_FILTER, i.LINEAR), this.magFilters.set(e, i.LINEAR);
-		let [s, c] = a(i, n);
-		return i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_S, s), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_T, c), this.minification === "mipmap" && i.generateMipmap(i.TEXTURE_2D), i.bindTexture(i.TEXTURE_2D, null), this.map.set(e, o), this.textures.add(o), o;
-	}
-	bind(e, t) {
-		let n = this.map.get(e);
-		if (!n) throw Error("GLImageCache: image not uploaded; call upload() first");
-		let r = this.gl;
-		r.activeTexture(r.TEXTURE0 + t), r.bindTexture(r.TEXTURE_2D, n);
-	}
-	setMagFilter(e, t) {
-		this.magFilters.get(e) !== t && (this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, t), this.magFilters.set(e, t));
-	}
-};
-function a(e, t) {
-	switch (t) {
-		case "repeat": return [e.REPEAT, e.REPEAT];
-		case "repeat-x": return [e.REPEAT, e.CLAMP_TO_EDGE];
-		case "repeat-y": return [e.CLAMP_TO_EDGE, e.REPEAT];
-		default: return [e.CLAMP_TO_EDGE, e.CLAMP_TO_EDGE];
-	}
-}
-//#endregion
-export { i as GLImageCache, r as maxImageTextureSide, n as releaseImageSource };
-
-//# sourceMappingURL=GLImageCache.js.map

package/dist/renderer/cache/GLImageCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GLImageCache.js","names":["DEFAULT_MAX_TEXTURE_SIDE","live","releaseImageSource","cache","key","maxImageTextureSide","side","GLImageCache","gl","minification","reported","tex","existing","source","wrapS","wrapT","wrapModes","repetition","unit","filter","rep"],"sources":["../../../src/renderer/cache/GLImageCache.ts"],"sourcesContent":["/**\n * GL texture upload cache for ImageBitmap objects.\n *\n * Key: ImageBitmap (or pattern source object) identity (WeakMap) — lets GC\n * reclaim unreferenced bitmaps. The GL textures are NOT freed when the source\n * is gc'd; a source's owner that knows it will never be drawn again frees them\n * with {@link releaseImageSource}, and `dispose` frees them all.\n *\n * Wrapping is set once at upload time per the `repetition` parameter:\n *   - undefined / 'no-repeat' → CLAMP_TO_EDGE\n *   - 'repeat'   → REPEAT (both axes)\n *   - 'repeat-x' → REPEAT on S, CLAMP on T\n *   - 'repeat-y' → CLAMP on S, REPEAT on T\n *\n * Convention §2: texels stored straight; shader premultiplies.\n */\n\nexport type PatternRepetition = 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';\n\n/** MIN_FILTER strategy for uploaded textures. */\nexport type ImageMinification = 'linear' | 'mipmap';\n\ntype TexSource = ImageBitmap | ImageData | HTMLCanvasElement | HTMLImageElement;\n\n/** Assumed when no live context has reported its `MAX_TEXTURE_SIZE`. Above\n *  WebGL2's guaranteed 2048, and at or below what every current GPU reports. */\nconst DEFAULT_MAX_TEXTURE_SIDE = 4096;\n\nconst live = new Set<GLImageCache>();\n\n/** Free `key`'s texture in every live renderer. For an owner that has replaced\n *  a source and will never draw the old one again — a later draw of it simply\n *  re-uploads. */\nexport function releaseImageSource(key: object): void {\n  for (const cache of live) cache.release(key);\n}\n\n/** The largest texture side every live renderer can hold: the smallest\n *  `MAX_TEXTURE_SIZE` among them, or a conservative default when none is live. */\nexport function maxImageTextureSide(): number {\n  let side = Infinity;\n  for (const cache of live) side = Math.min(side, cache.maxTextureSide);\n  return Number.isFinite(side) ? side : DEFAULT_MAX_TEXTURE_SIDE;\n}\n\nexport class GLImageCache {\n  /** This context's `MAX_TEXTURE_SIZE`. */\n  readonly maxTextureSide: number;\n\n  private readonly map = new WeakMap<object, WebGLTexture>();\n  /** Every texture `map` holds, so `dispose` can reach them — a WeakMap\n   *  cannot be enumerated. */\n  private readonly textures = new Set<WebGLTexture>();\n  /**\n   * MAG_FILTER each texture currently carries, so a redundant write can be\n   * skipped.\n   *\n   * The batch sets this per flush — the same bitmap can be drawn at both\n   * filters in one frame, and the value has to be right at the draw rather than\n   * at upload. Filtering is state on the *texture object*, though, not on the\n   * unit, so re-asserting a value it already has is a write to a live texture\n   * for no reason. On a large sheet that is not free: a consumer's wall samples\n   * a 5652px-square atlas, 122MB resident, and measured `sampling: 'nearest'`\n   * costing up to 8x `'linear'` there — where the linear pass re-asserts the\n   * upload default and the nearest pass changes state on every draw.\n   *\n   * Whether that is the cause is unproven (see `docs/TODO.md`), but the write\n   * was redundant either way.\n   */\n  private readonly magFilters = new WeakMap<object, number>();\n\n  /** `minification` selects the MIN_FILTER strategy for uploaded textures.\n   *  `'linear'` (default) is the screen path's existing behavior. `'mipmap'`\n   *  generates mipmaps and filters LINEAR_MIPMAP_LINEAR — required for\n   *  quality minification when a large source bitmap is drawn small (the\n   *  headless print/export path); bilinear-only minification undersamples\n   *  and produces moiré. */\n  constructor(\n    private readonly gl: WebGL2RenderingContext,\n    private readonly minification: ImageMinification = 'linear',\n  ) {\n    const reported: unknown = gl.getParameter(gl.MAX_TEXTURE_SIZE);\n    this.maxTextureSide = typeof reported === 'number' && reported > 0\n      ? reported\n      : DEFAULT_MAX_TEXTURE_SIDE;\n    live.add(this);\n  }\n\n  /** Delete `key`'s texture, if it has one. */\n  release(key: object): void {\n    const tex = this.map.get(key);\n    if (!tex) return;\n    this.gl.deleteTexture(tex);\n    this.textures.delete(tex);\n    this.map.delete(key);\n    this.magFilters.delete(key);\n  }\n\n  /** Delete every texture this cache uploaded and stop answering\n   *  {@link releaseImageSource} and {@link maxImageTextureSide}. Idempotent. */\n  dispose(): void {\n    for (const tex of this.textures) this.gl.deleteTexture(tex);\n    this.abandon();\n  }\n\n  /** {@link dispose} without the deletes, for a cache whose context was lost:\n   *  its textures died with it. */\n  abandon(): void {\n    this.textures.clear();\n    live.delete(this);\n  }\n\n  upload(\n    key: object,\n    source: TexSource,\n    repetition?: PatternRepetition,\n  ): WebGLTexture {\n    const existing = this.map.get(key);\n    if (existing) return existing;\n\n    const gl = this.gl;\n    const tex = gl.createTexture();\n    if (!tex) throw new Error('GLImageCache: createTexture failed');\n\n    gl.bindTexture(gl.TEXTURE_2D, tex);\n    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source as TexImageSource);\n    gl.texParameteri(\n      gl.TEXTURE_2D,\n      gl.TEXTURE_MIN_FILTER,\n      this.minification === 'mipmap' ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR,\n    );\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);\n    this.magFilters.set(key, gl.LINEAR);\n\n    const [wrapS, wrapT] = wrapModes(gl, repetition);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrapS);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrapT);\n    if (this.minification === 'mipmap') gl.generateMipmap(gl.TEXTURE_2D);\n    gl.bindTexture(gl.TEXTURE_2D, null);\n\n    this.map.set(key, tex);\n    this.textures.add(tex);\n    return tex;\n  }\n\n  bind(key: object, unit: number): void {\n    const tex = this.map.get(key);\n    if (!tex) throw new Error('GLImageCache: image not uploaded; call upload() first');\n    const gl = this.gl;\n    gl.activeTexture(gl.TEXTURE0 + unit);\n    gl.bindTexture(gl.TEXTURE_2D, tex);\n  }\n\n  /** Set `key`'s MAG_FILTER, skipping the call when it already holds that\n   *  value. Its texture must be bound to the active unit — callers pair this\n   *  with `bind`. */\n  setMagFilter(key: object, filter: number): void {\n    if (this.magFilters.get(key) === filter) return;\n    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, filter);\n    this.magFilters.set(key, filter);\n  }\n}\n\nfunction wrapModes(\n  gl: WebGL2RenderingContext,\n  rep?: PatternRepetition,\n): [number, number] {\n  switch (rep) {\n    case 'repeat':   return [gl.REPEAT, gl.REPEAT];\n    case 'repeat-x': return [gl.REPEAT, gl.CLAMP_TO_EDGE];\n    case 'repeat-y': return [gl.CLAMP_TO_EDGE, gl.REPEAT];\n    default:         return [gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE];\n  }\n}\n"],"mappings":"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"}

package/dist/renderer/cache/GLMeshCache.js

@@ -1,102 +0,0 @@
-//#region src/renderer/cache/GLMeshCache.ts
-var e = class {
-	gl;
-	aPositionLoc;
-	map = /* @__PURE__ */ new WeakMap();
-	seen = /* @__PURE__ */ new WeakSet();
-	finalizer;
-	persistent = /* @__PURE__ */ new Set();
-	pendingDeletes = [];
-	disposed = !1;
-	transientThisFrame = [];
-	constructor(e, t) {
-		this.gl = e, this.aPositionLoc = t, this.finalizer = new FinalizationRegistry((e) => {
-			this.persistent.delete(e) && this.pendingDeletes.push(e);
-		});
-	}
-	handleFor(e) {
-		let t = this.map.get(e);
-		if (t) return t;
-		let { handle: n, vbo: r, ibo: i } = this.upload(e);
-		this.map.set(e, n);
-		let a = {
-			vao: n.vao,
-			vbo: r,
-			ibo: i
-		};
-		return this.persistent.add(a), this.finalizer.register(e, a, e), n;
-	}
-	uploadTransient(e) {
-		let { handle: t, vbo: n, ibo: r } = this.upload(e);
-		return this.transientThisFrame.push({
-			vao: t.vao,
-			vbo: n,
-			ibo: r
-		}), t;
-	}
-	uploadRecurring(e) {
-		return this.seen.has(e) ? this.handleFor(e) : (this.seen.add(e), this.uploadTransient(e));
-	}
-	freeTransient() {
-		if (this.transientThisFrame.length === 0) return;
-		let e = this.gl;
-		if (e.isContextLost()) {
-			this.transientThisFrame.length = 0;
-			return;
-		}
-		for (let t of this.transientThisFrame) e.deleteVertexArray(t.vao), e.deleteBuffer(t.vbo), e.deleteBuffer(t.ibo);
-		this.transientThisFrame.length = 0;
-	}
-	_transientCount() {
-		return this.transientThisFrame.length;
-	}
-	drainPendingDeletes() {
-		if (this.pendingDeletes.length === 0) return;
-		let e = this.gl;
-		if (e.isContextLost()) {
-			this.pendingDeletes.length = 0;
-			return;
-		}
-		for (let t of this.pendingDeletes) e.deleteVertexArray(t.vao), e.deleteBuffer(t.vbo), e.deleteBuffer(t.ibo);
-		this.pendingDeletes.length = 0;
-	}
-	dispose() {
-		if (!this.disposed) {
-			this.disposed = !0, this.freeTransient();
-			for (let e of this.persistent) this.pendingDeletes.push(e);
-			this.persistent.clear(), this.drainPendingDeletes();
-		}
-	}
-	_pendingDeleteCount() {
-		return this.pendingDeletes.length;
-	}
-	_enqueueDeleteForTest(e) {
-		this.pendingDeletes.push(e);
-	}
-	upload(e) {
-		let t = this.gl, n = t.createVertexArray();
-		if (!n) throw Error("createVertexArray returned null");
-		t.bindVertexArray(n);
-		let r = t.createBuffer();
-		if (!r) throw Error("createBuffer (VBO) returned null");
-		t.bindBuffer(t.ARRAY_BUFFER, r), t.bufferData(t.ARRAY_BUFFER, e.vertices, t.STATIC_DRAW), t.enableVertexAttribArray(this.aPositionLoc), t.vertexAttribPointer(this.aPositionLoc, 2, t.FLOAT, !1, 0, 0);
-		let i = t.createBuffer();
-		if (!i) throw Error("createBuffer (IBO) returned null");
-		return t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, i), t.bufferData(t.ELEMENT_ARRAY_BUFFER, e.indices, t.STATIC_DRAW), t.bindVertexArray(null), {
-			handle: {
-				vao: n,
-				indexCount: e.indices.length,
-				requiresStencil: e.requiresStencil ?? !1,
-				anchorA: e.anchorA,
-				anchorB: e.anchorB,
-				anchorT: e.anchorT
-			},
-			vbo: r,
-			ibo: i
-		};
-	}
-};
-//#endregion
-export { e as GLMeshCache };
-
-//# sourceMappingURL=GLMeshCache.js.map

package/dist/renderer/cache/GLMeshCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GLMeshCache.js","names":["GLMeshCache","gl","aPositionLoc","resources","cached","mesh","handle","r","vao","vbo","ibo"],"sources":["../../../src/renderer/cache/GLMeshCache.ts"],"sourcesContent":["import type { Mesh } from '@weasel-js/geom/tessellate';\n\nexport interface GLMeshHandle {\n  readonly vao: WebGLVertexArrayObject;\n  readonly indexCount: number;\n  readonly requiresStencil: boolean;\n  readonly anchorA?: Uint32Array;\n  readonly anchorB?: Uint32Array;\n  readonly anchorT?: Float32Array;\n}\n\n/** Resources to release when a Mesh is reclaimed by GC. */\ninterface MeshResources {\n  vao: WebGLVertexArrayObject;\n  vbo: WebGLBuffer;\n  ibo: WebGLBuffer;\n}\n\n/**\n * Caches GL-side buffers + VAO per `Mesh` identity. Upload happens lazily\n * on first `handleFor(mesh)` call.\n *\n * **GC-aware cleanup (deferred-delete queue):** when a Mesh becomes\n * unreachable, the WeakMap entry is dropped automatically — but the\n * underlying GL resources (VAO, VBO, IBO) would leak forever without an\n * explicit `gl.delete*` call. We register each Mesh with a\n * `FinalizationRegistry`; when the Mesh is reclaimed, the finalizer pushes\n * the resources onto an internal queue. The renderer drains this queue at\n * the start of each `render()` call (via `drainPendingDeletes()`), when GL\n * is in a known state — no VAO bound, no draw mid-flight. Deleting from the\n * finalizer directly was racy (it could fire between two `gl.bindVertexArray`\n * calls inside `dispatch()`, sometimes corrupting the next draw); deferring\n * the actual delete to a known-safe point keeps the use-after-free risk to\n * zero.\n *\n * Caveats:\n *   - Finalizer timing is non-deterministic; resources may live for a frame\n *     or two beyond their Mesh, but they will be reclaimed.\n *   - If the GL context is lost between finalizer and drain, the drain\n *     no-ops safely (`gl.isContextLost()` makes deletes no-ops, and\n *     `gl.deleteBuffer(null)` is allowed).\n *\n * The cache is GL-context-bound; if the context is lost and re-created, the\n * renderer should construct a new GLMeshCache. (Context loss handling lives\n * in `WeaselRenderer`.)\n */\nexport class GLMeshCache {\n  private readonly map = new WeakMap<Mesh, GLMeshHandle>();\n  /** Meshes this context has drawn at least once; see `uploadRecurring`. */\n  private readonly seen = new WeakSet<Mesh>();\n  private readonly finalizer: FinalizationRegistry<MeshResources>;\n  /** Every persistent upload not yet freed, so `dispose` can reach them. */\n  private readonly persistent = new Set<MeshResources>();\n  private readonly pendingDeletes: MeshResources[] = [];\n  private disposed = false;\n  /** Transient resources allocated this frame; freed at end of render(). */\n  private readonly transientThisFrame: MeshResources[] = [];\n\n  constructor(\n    private readonly gl: WebGL2RenderingContext,\n    private readonly aPositionLoc: number,\n  ) {\n    this.finalizer = new FinalizationRegistry<MeshResources>((resources) => {\n      // Defer the actual gl.delete* until the renderer's next render(),\n      // when no VAO/buffer is bound mid-draw. Direct deletion from the\n      // finalizer caused use-after-free crashes when GC fired between\n      // bindVertexArray and drawElements inside dispatch().\n      if (!this.persistent.delete(resources)) return;\n      this.pendingDeletes.push(resources);\n    });\n  }\n\n  handleFor(mesh: Mesh): GLMeshHandle {\n    const cached = this.map.get(mesh);\n    if (cached) return cached;\n    const { handle, vbo, ibo } = this.upload(mesh);\n    this.map.set(mesh, handle);\n    const resources = { vao: handle.vao, vbo, ibo };\n    this.persistent.add(resources);\n    // Register so the GL resources get freed when `mesh` is GC'd. The\n    // unregister token (mesh) lets us cancel if the Mesh is somehow\n    // re-uploaded under a different cache, though that's not a normal flow.\n    this.finalizer.register(mesh, resources, mesh);\n    return handle;\n  }\n\n  /**\n   * Upload a Mesh that the caller knows is single-use (e.g. the per-frame\n   * stroke ribbon from `tessellateStroke`). Returns a handle backed by fresh\n   * GL resources that the renderer will free deterministically at the end\n   * of the current frame via `freeTransient()`. Bypasses the WeakMap cache\n   * and the FinalizationRegistry, so transient meshes never wait on GC.\n   */\n  uploadTransient(mesh: Mesh): GLMeshHandle {\n    const { handle, vbo, ibo } = this.upload(mesh);\n    this.transientThisFrame.push({ vao: handle.vao, vbo, ibo });\n    return handle;\n  }\n\n  /**\n   * Upload a Mesh that may or may not recur across frames. Its first sight in\n   * *this* context takes `uploadTransient`; every later one takes the\n   * persistent handle. One transient upload to find out is cheaper than\n   * stranding a persistent VAO on a mesh that never returns, whose release\n   * would wait on GC. The transient upload does not populate the persistent\n   * map, so steady-state reuse begins on the third frame.\n   */\n  uploadRecurring(mesh: Mesh): GLMeshHandle {\n    if (this.seen.has(mesh)) return this.handleFor(mesh);\n    this.seen.add(mesh);\n    return this.uploadTransient(mesh);\n  }\n\n  /**\n   * Free all transient resources allocated since the last call. Called by\n   * the renderer at the end of each `render()`. Safe under context loss.\n   */\n  freeTransient(): void {\n    if (this.transientThisFrame.length === 0) return;\n    const gl = this.gl;\n    if (gl.isContextLost()) {\n      this.transientThisFrame.length = 0;\n      return;\n    }\n    for (const r of this.transientThisFrame) {\n      gl.deleteVertexArray(r.vao);\n      gl.deleteBuffer(r.vbo);\n      gl.deleteBuffer(r.ibo);\n    }\n    this.transientThisFrame.length = 0;\n  }\n\n  /** @internal — for tests asserting the transient-list size. */\n  _transientCount(): number {\n    return this.transientThisFrame.length;\n  }\n\n  /**\n   * Free GL resources whose Mesh has been GC'd since the last drain.\n   * Called by the renderer at the top of each `render()`, before any draws.\n   */\n  drainPendingDeletes(): void {\n    if (this.pendingDeletes.length === 0) return;\n    const gl = this.gl;\n    if (gl.isContextLost()) {\n      this.pendingDeletes.length = 0;\n      return;\n    }\n    for (const r of this.pendingDeletes) {\n      gl.deleteVertexArray(r.vao);\n      gl.deleteBuffer(r.vbo);\n      gl.deleteBuffer(r.ibo);\n    }\n    this.pendingDeletes.length = 0;\n  }\n\n  /**\n   * Free every GL resource this cache holds — persistent, pending and\n   * transient — and ignore finalizers from here on. Idempotent. Unlike the\n   * other paths this does not wait on GC, which is what lets a renderer on a\n   * context it does not own give back everything it uploaded.\n   */\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.freeTransient();\n    for (const r of this.persistent) this.pendingDeletes.push(r);\n    this.persistent.clear();\n    this.drainPendingDeletes();\n  }\n\n  /** @internal — for tests asserting the queue size. */\n  _pendingDeleteCount(): number {\n    return this.pendingDeletes.length;\n  }\n\n  /** @internal — for tests that need to simulate the finalizer firing. */\n  _enqueueDeleteForTest(resources: MeshResources): void {\n    this.pendingDeletes.push(resources);\n  }\n\n  private upload(mesh: Mesh): { handle: GLMeshHandle; vbo: WebGLBuffer; ibo: WebGLBuffer } {\n    const gl = this.gl;\n    const vao = gl.createVertexArray();\n    if (!vao) throw new Error('createVertexArray returned null');\n    gl.bindVertexArray(vao);\n\n    const vbo = gl.createBuffer();\n    if (!vbo) throw new Error('createBuffer (VBO) returned null');\n    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);\n    gl.bufferData(gl.ARRAY_BUFFER, mesh.vertices, gl.STATIC_DRAW);\n\n    gl.enableVertexAttribArray(this.aPositionLoc);\n    gl.vertexAttribPointer(this.aPositionLoc, 2, gl.FLOAT, false, 0, 0);\n\n    const ibo = gl.createBuffer();\n    if (!ibo) throw new Error('createBuffer (IBO) returned null');\n    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);\n    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, mesh.indices, gl.STATIC_DRAW);\n\n    gl.bindVertexArray(null);\n\n    return {\n      handle: {\n        vao,\n        indexCount: mesh.indices.length,\n        requiresStencil: mesh.requiresStencil ?? false,\n        anchorA: mesh.anchorA,\n        anchorB: mesh.anchorB,\n        anchorT: mesh.anchorT,\n      },\n      vbo,\n      ibo,\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/renderer/cache/GLTextureCache.js

@@ -1,51 +0,0 @@
-//#region src/renderer/cache/GLTextureCache.ts
-var e = class {
-	gl;
-	map = /* @__PURE__ */ new Map();
-	wraps = /* @__PURE__ */ new Map();
-	constructor(e) {
-		this.gl = e;
-	}
-	has(e) {
-		return this.map.has(e);
-	}
-	upload(e, t, n = "clamp") {
-		let r = this.map.get(e);
-		if (r) return this.wraps.get(e) !== n && this.applyWrap(e, r, n), e;
-		let i = this.gl, a = i.createTexture();
-		if (!a) throw Error(`GLTextureCache: createTexture failed for id="${e}"`);
-		let o = n === "repeat" ? i.REPEAT : i.CLAMP_TO_EDGE;
-		return i.bindTexture(i.TEXTURE_2D, a), i.texImage2D(i.TEXTURE_2D, 0, i.RGBA, i.RGBA, i.UNSIGNED_BYTE, t), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MIN_FILTER, i.LINEAR), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MAG_FILTER, i.LINEAR), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_S, o), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_T, o), i.bindTexture(i.TEXTURE_2D, null), this.map.set(e, a), this.wraps.set(e, n), e;
-	}
-	applyWrap(e, t, n) {
-		let r = this.gl, i = n === "repeat" ? r.REPEAT : r.CLAMP_TO_EDGE;
-		r.bindTexture(r.TEXTURE_2D, t), r.texParameteri(r.TEXTURE_2D, r.TEXTURE_WRAP_S, i), r.texParameteri(r.TEXTURE_2D, r.TEXTURE_WRAP_T, i), r.bindTexture(r.TEXTURE_2D, null), this.wraps.set(e, n);
-	}
-	uploadR8(e, t, n, r) {
-		if (this.map.has(e)) return;
-		let i = this.gl, a = i.createTexture();
-		if (!a) throw Error(`GLTextureCache: createTexture failed for id="${e}"`);
-		i.bindTexture(i.TEXTURE_2D, a), i.pixelStorei(i.UNPACK_ALIGNMENT, 1), i.texImage2D(i.TEXTURE_2D, 0, i.R8, t, n, 0, i.RED, i.UNSIGNED_BYTE, r), i.pixelStorei(i.UNPACK_ALIGNMENT, 4), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MIN_FILTER, i.LINEAR), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_MAG_FILTER, i.LINEAR), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_S, i.CLAMP_TO_EDGE), i.texParameteri(i.TEXTURE_2D, i.TEXTURE_WRAP_T, i.CLAMP_TO_EDGE), i.bindTexture(i.TEXTURE_2D, null), this.map.set(e, a), this.wraps.set(e, "clamp");
-	}
-	subImageR8(e, t, n, r, i, a) {
-		let o = this.map.get(e);
-		if (!o) throw Error(`GLTextureCache: texture "${e}" not uploaded`);
-		let s = this.gl;
-		s.bindTexture(s.TEXTURE_2D, o), s.pixelStorei(s.UNPACK_ALIGNMENT, 1), s.texSubImage2D(s.TEXTURE_2D, 0, t, n, r, i, s.RED, s.UNSIGNED_BYTE, a), s.pixelStorei(s.UNPACK_ALIGNMENT, 4), s.bindTexture(s.TEXTURE_2D, null);
-	}
-	bind(e, t) {
-		let n = this.map.get(e);
-		if (!n) throw Error(`GLTextureCache: texture "${e}" not uploaded`);
-		let r = this.gl;
-		r.activeTexture(r.TEXTURE0 + t), r.bindTexture(r.TEXTURE_2D, n);
-	}
-	free() {
-		let e = this.gl;
-		for (let t of this.map.values()) e.deleteTexture(t);
-		this.map.clear(), this.wraps.clear();
-	}
-};
-//#endregion
-export { e as GLTextureCache };
-
-//# sourceMappingURL=GLTextureCache.js.map

package/dist/renderer/cache/GLTextureCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GLTextureCache.js","names":["GLTextureCache","gl","id","cached","wrap","tex","wrapMode","source","mode","width","height","data","x","y","w","h","unit"],"sources":["../../../src/renderer/cache/GLTextureCache.ts"],"sourcesContent":["/**\n * GL texture upload + cache for MSDF font atlases (and future images).\n *\n * Textures are keyed by a string id (the font family name or image id).\n * Pixels are uploaded once per id; a later upload of the same id reuses the\n * texture and only re-applies its wrap mode when that changed.\n * The cache is GL-context-bound; discard and create a new one on context loss.\n *\n * Atlas format: RGBA UNSIGNED_BYTE, linear filtering, no mipmaps.\n * Mipmap generation is deliberately skipped — MSDF works correctly with\n * linear filtering, and mipmap resampling corrupts the multi-channel SDF signal.\n */\n\ntype TexSource = HTMLImageElement | ImageBitmap | ImageData | HTMLCanvasElement;\n\n/** How a texture samples outside `0..1`. Pattern tiles need `'repeat'`;\n *  everything else clamps. WebGL2 allows `REPEAT` on NPOT textures, so a\n *  tile of any size tiles correctly. */\nexport type TextureWrap = 'clamp' | 'repeat';\n\nexport class GLTextureCache {\n  private readonly map = new Map<string, WebGLTexture>();\n  private readonly wraps = new Map<string, TextureWrap>();\n\n  constructor(private readonly gl: WebGL2RenderingContext) {}\n\n  has(id: string): boolean {\n    return this.map.has(id);\n  }\n\n  /** Uploads the pixels once per id. `wrap` is re-applied whenever it differs\n   *  from what the id was last uploaded under: the same registered image can\n   *  be a clamped shader texture in one draw and a repeating pattern tile in\n   *  the next, and first-upload-wins gave the second one the first one's mode. */\n  upload(id: string, source: TexSource, wrap: TextureWrap = 'clamp'): string {\n    const cached = this.map.get(id);\n    if (cached) {\n      if (this.wraps.get(id) !== wrap) this.applyWrap(id, cached, wrap);\n      return id;\n    }\n\n    const gl = this.gl;\n    const tex = gl.createTexture();\n    if (!tex) throw new Error(`GLTextureCache: createTexture failed for id=\"${id}\"`);\n\n    const wrapMode = wrap === 'repeat' ? gl.REPEAT : gl.CLAMP_TO_EDGE;\n\n    gl.bindTexture(gl.TEXTURE_2D, tex);\n    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source as TexImageSource);\n\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrapMode);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrapMode);\n\n    gl.bindTexture(gl.TEXTURE_2D, null);\n\n    this.map.set(id, tex);\n    this.wraps.set(id, wrap);\n    return id;\n  }\n\n  private applyWrap(id: string, tex: WebGLTexture, wrap: TextureWrap): void {\n    const gl = this.gl;\n    const mode = wrap === 'repeat' ? gl.REPEAT : gl.CLAMP_TO_EDGE;\n    gl.bindTexture(gl.TEXTURE_2D, tex);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, mode);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, mode);\n    gl.bindTexture(gl.TEXTURE_2D, null);\n    this.wraps.set(id, wrap);\n  }\n\n  /** Create a single-channel R8 texture from raw bytes (full upload).\n   *  No-op if `id` already exists. Same LINEAR/CLAMP params as `upload`;\n   *  UNPACK_ALIGNMENT dropped to 1 for non-4-aligned row widths. */\n  uploadR8(id: string, width: number, height: number, data: Uint8Array): void {\n    if (this.map.has(id)) return;\n    const gl = this.gl;\n    const tex = gl.createTexture();\n    if (!tex) throw new Error(`GLTextureCache: createTexture failed for id=\"${id}\"`);\n    gl.bindTexture(gl.TEXTURE_2D, tex);\n    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);\n    gl.texImage2D(gl.TEXTURE_2D, 0, gl.R8, width, height, 0, gl.RED, gl.UNSIGNED_BYTE, data);\n    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n    gl.bindTexture(gl.TEXTURE_2D, null);\n    this.map.set(id, tex);\n    this.wraps.set(id, 'clamp');\n  }\n\n  /** Patch a rect of an existing R8 texture with tightly-packed w×h bytes. */\n  subImageR8(id: string, x: number, y: number, w: number, h: number, data: Uint8Array): void {\n    const tex = this.map.get(id);\n    if (!tex) throw new Error(`GLTextureCache: texture \"${id}\" not uploaded`);\n    const gl = this.gl;\n    gl.bindTexture(gl.TEXTURE_2D, tex);\n    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);\n    gl.texSubImage2D(gl.TEXTURE_2D, 0, x, y, w, h, gl.RED, gl.UNSIGNED_BYTE, data);\n    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4);\n    gl.bindTexture(gl.TEXTURE_2D, null);\n  }\n\n  bind(id: string, unit: number): void {\n    const tex = this.map.get(id);\n    if (!tex) throw new Error(`GLTextureCache: texture \"${id}\" not uploaded`);\n    const gl = this.gl;\n    gl.activeTexture(gl.TEXTURE0 + unit);\n    gl.bindTexture(gl.TEXTURE_2D, tex);\n  }\n\n  /**\n   * Delete every uploaded GL texture and clear the map. Called by\n   * `WeaselRenderer.dispose()`. The cache is unusable but refillable\n   * afterward — a subsequent `upload()` for a previously-seen id re-creates\n   * the texture rather than restoring the deleted one.\n   */\n  free(): void {\n    const gl = this.gl;\n    for (const tex of this.map.values()) {\n      gl.deleteTexture(tex);\n    }\n    this.map.clear();\n    this.wraps.clear();\n  }\n}\n"],"mappings":"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"}

package/dist/renderer/cache/GradientRampAtlas.js

@@ -1,82 +0,0 @@
-import { resolveGradientStops as e, sampleResolvedStops as t } from "../../core/gradient.js";
-//#region src/renderer/cache/GradientRampAtlas.ts
-var n = 256, r = 16, i = 1024;
-function a(r, i = "rgb") {
-	let a = new Uint8ClampedArray(n * 4);
-	if (r.length === 0) return a;
-	let o = e(r);
-	for (let e = 0; e < n; e++) {
-		let [n, r, s, c] = t(o, e / 255, i);
-		a[e * 4] = n * 255, a[e * 4 + 1] = r * 255, a[e * 4 + 2] = s * 255, a[e * 4 + 3] = c * 255;
-	}
-	return a;
-}
-function o(e, t) {
-	return `${t}|${JSON.stringify(e)}`;
-}
-var s = class {
-	gl;
-	rowByKey = /* @__PURE__ */ new Map();
-	texture = null;
-	rows = 0;
-	pixels = /* @__PURE__ */ new Uint8ClampedArray();
-	totalQueries = 0;
-	cacheHits = 0;
-	constructor(e) {
-		this.gl = e;
-	}
-	get height() {
-		return this.rows;
-	}
-	upload(e, t = "rgb") {
-		let n = o(e, t);
-		this.totalQueries++;
-		let r = this.rowByKey.get(n);
-		if (r !== void 0) return this.cacheHits++, this.rowByKey.delete(n), this.rowByKey.set(n, r), r;
-		let i = this.claimRow();
-		return this.writeRow(i, a(e, t)), this.rowByKey.set(n, i), i;
-	}
-	wouldReshape(e, t = "rgb") {
-		return this.rowByKey.size !== 0 && !this.rowByKey.has(o(e, t)) && this.rowByKey.size >= this.rows;
-	}
-	rowV(e) {
-		return (e + .5) / (this.rows || 1);
-	}
-	bind(e) {
-		let t = this.gl;
-		t.activeTexture(t.TEXTURE0 + e), t.bindTexture(t.TEXTURE_2D, this.texture);
-	}
-	hitRate() {
-		return this.totalQueries === 0 ? 0 : this.cacheHits / this.totalQueries;
-	}
-	resetStats() {
-		this.totalQueries = 0, this.cacheHits = 0;
-	}
-	free() {
-		this.texture && this.gl.deleteTexture(this.texture), this.texture = null, this.rows = 0, this.pixels = /* @__PURE__ */ new Uint8ClampedArray(), this.rowByKey.clear();
-	}
-	claimRow() {
-		if (this.rowByKey.size < this.rows) return this.rowByKey.size;
-		if (this.rows < i) return this.resize(this.rows === 0 ? r : this.rows * 2), this.rowByKey.size;
-		let [e, t] = this.rowByKey.entries().next().value;
-		return this.rowByKey.delete(e), t;
-	}
-	resize(e) {
-		let t = this.gl, r = new Uint8ClampedArray(n * e * 4);
-		if (r.set(this.pixels), this.pixels = r, this.rows = e, this.texture) t.bindTexture(t.TEXTURE_2D, this.texture);
-		else {
-			let e = t.createTexture();
-			if (!e) throw Error("GradientRampAtlas: createTexture failed");
-			this.texture = e, t.bindTexture(t.TEXTURE_2D, e), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.LINEAR), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.LINEAR), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE);
-		}
-		t.texImage2D(t.TEXTURE_2D, 0, t.RGBA, n, e, 0, t.RGBA, t.UNSIGNED_BYTE, this.pixels), t.bindTexture(t.TEXTURE_2D, null);
-	}
-	writeRow(e, t) {
-		let r = this.gl;
-		this.pixels.set(t, e * n * 4), r.bindTexture(r.TEXTURE_2D, this.texture), r.texSubImage2D(r.TEXTURE_2D, 0, 0, e, n, 1, r.RGBA, r.UNSIGNED_BYTE, t), r.bindTexture(r.TEXTURE_2D, null);
-	}
-};
-//#endregion
-export { s as GradientRampAtlas, i as RAMP_ATLAS_MAX_ROWS, n as RAMP_WIDTH, a as buildGradientRamp };
-
-//# sourceMappingURL=GradientRampAtlas.js.map

package/dist/renderer/cache/GradientRampAtlas.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GradientRampAtlas.js","names":["RAMP_WIDTH","INITIAL_ROWS","RAMP_ATLAS_MAX_ROWS","buildGradientRamp","data","stops","resolved","resolveGradientStops","i","r","g","b","a","sampleResolvedStops","space","rampKey","GradientRampAtlas","gl","key","existing","row","unit","lruKey","lruRow","next","rows","tex","ramp"],"sources":["../../../src/renderer/cache/GradientRampAtlas.ts"],"sourcesContent":["/**\n * CPU gradient-ramp builder + the GL texture every baked ramp lives in.\n *\n * Each unique stop list is baked once into a 256-texel strip and written to its\n * own **row** of one RGBA texture, keyed by `JSON.stringify(stops)`. One\n * texture rather than one per ramp is what lets a gradient take a batch texture\n * slot the way a bitmap or a font atlas does: every gradient in a frame samples\n * the same unit, so a run does not break per gradient. The atlas is\n * GL-context-bound; discard and recreate on context loss.\n *\n * Output convention §2: texels are stored as straight RGBA. The fragment\n * shader applies premultiplication before writing outColor.\n */\n\nimport type { ColorSpace, GradStop } from '@weasel-js/paint';\nimport { resolveGradientStops, sampleResolvedStops } from '../../core/gradient';\n\n/** Texels across one ramp — the resolution a gradient is sampled at. */\nexport const RAMP_WIDTH = 256;\n\n/** Rows the atlas starts at, doubling from there. */\nconst INITIAL_ROWS = 16;\n\n/**\n * Rows the atlas stops growing at, past which the least recently used row is\n * recycled.\n *\n * WebGL2 guarantees `MAX_TEXTURE_SIZE` of at least 2048, so this is available\n * everywhere without a `getParameter` — which the GL recorder would answer with\n * a recording function rather than a number. A cap is also what bounds an\n * animating gradient, which mints a new stop list every frame and would\n * otherwise grow the atlas until it could not grow again.\n */\nexport const RAMP_ATLAS_MAX_ROWS = 1024;\n\n/** Bake gradient stops into a 256-entry RGBA lookup strip, which the shader\n *  samples instead of evaluating stops per fragment. `space` is the gradient's\n *  `interpolate` — the ramp is where a non-sRGB blend is paid for, once. */\nexport function buildGradientRamp(stops: GradStop[], space: ColorSpace = 'rgb'): Uint8ClampedArray {\n  const data = new Uint8ClampedArray(RAMP_WIDTH * 4);\n  if (stops.length === 0) return data;\n\n  const resolved = resolveGradientStops(stops);\n  for (let i = 0; i < RAMP_WIDTH; i++) {\n    const [r, g, b, a] = sampleResolvedStops(resolved, i / (RAMP_WIDTH - 1), space);\n    data[i * 4]     = r * 255;\n    data[i * 4 + 1] = g * 255;\n    data[i * 4 + 2] = b * 255;\n    data[i * 4 + 3] = a * 255;\n  }\n\n  return data;\n}\n\n/** The row identity. Two gradients with the same stops and different\n *  `interpolate` bake to different texels, so the space is part of the key. */\nfunction rampKey(stops: GradStop[], space: ColorSpace): string {\n  return `${space}|${JSON.stringify(stops)}`;\n}\n\nexport class GradientRampAtlas {\n  /** Row per stop list, in least-recently-used order: a hit re-inserts, so the\n   *  first entry is the row a full atlas recycles. */\n  private readonly rowByKey = new Map<string, number>();\n  private texture: WebGLTexture | null = null;\n  private rows = 0;\n  /** Mirror of the texture, so growth can respecify it without re-baking every\n   *  ramp it already holds. */\n  private pixels = new Uint8ClampedArray(0);\n  private totalQueries = 0;\n  private cacheHits = 0;\n\n  constructor(private readonly gl: WebGL2RenderingContext) {}\n\n  /** Rows the atlas currently holds — its texture height. */\n  get height(): number {\n    return this.rows;\n  }\n\n  /**\n   * Bake `stops` into a row and return it, reusing the row an identical stop\n   * list already holds.\n   *\n   * **A returned row outlives the frame only while the atlas has room.** Past\n   * `RAMP_ATLAS_MAX_ROWS` an upload recycles the least recently used row, which\n   * rewrites texels a row handed out earlier still names. Nothing that defers\n   * its draw past this call may hold a row across another `upload` without\n   * arranging to be flushed first.\n   */\n  upload(stops: GradStop[], space: ColorSpace = 'rgb'): number {\n    const key = rampKey(stops, space);\n    this.totalQueries++;\n    const existing = this.rowByKey.get(key);\n    if (existing !== undefined) {\n      this.cacheHits++;\n      this.rowByKey.delete(key);\n      this.rowByKey.set(key, existing);\n      return existing;\n    }\n\n    const row = this.claimRow();\n    this.writeRow(row, buildGradientRamp(stops, space));\n    this.rowByKey.set(key, row);\n    return row;\n  }\n\n  /**\n   * Whether uploading `stops` would move where existing rows sit — by growing\n   * the atlas, which changes every row's `v`, or by recycling one, which\n   * rewrites its texels.\n   *\n   * Anything holding a row past this call asks first and gets itself out of\n   * the way, because neither can be undone once it has happened.\n   */\n  wouldReshape(stops: GradStop[], space: ColorSpace = 'rgb'): boolean {\n    // An atlas holding nothing has no row to move, so its first growth is free.\n    if (this.rowByKey.size === 0) return false;\n    return !this.rowByKey.has(rampKey(stops, space))\n      && this.rowByKey.size >= this.rows;\n  }\n\n  /**\n   * The `v` a row is sampled at — its center.\n   *\n   * The center is load-bearing: the atlas filters LINEAR, so a `v` anywhere\n   * else blends the ramp beside it into this one. At the center the neighbor's\n   * weight is exactly zero.\n   */\n  rowV(row: number): number {\n    return (row + 0.5) / (this.rows || 1);\n  }\n\n  bind(unit: number): void {\n    const gl = this.gl;\n    gl.activeTexture(gl.TEXTURE0 + unit);\n    gl.bindTexture(gl.TEXTURE_2D, this.texture);\n  }\n\n  hitRate(): number {\n    if (this.totalQueries === 0) return 0;\n    return this.cacheHits / this.totalQueries;\n  }\n\n  resetStats(): void {\n    this.totalQueries = 0;\n    this.cacheHits = 0;\n  }\n\n  /**\n   * Delete the atlas texture and forget every row in it. Called by\n   * `WeaselRenderer.dispose()`. The CPU mirror goes with it, so the atlas is\n   * unusable but refillable afterward (stats are left as-is; call\n   * `resetStats()` separately if desired).\n   */\n  free(): void {\n    if (this.texture) this.gl.deleteTexture(this.texture);\n    this.texture = null;\n    this.rows = 0;\n    this.pixels = new Uint8ClampedArray(0);\n    this.rowByKey.clear();\n  }\n\n  /** The row the next ramp is written to: a free one, a taller atlas, or the\n   *  least recently used row of a full one. */\n  private claimRow(): number {\n    if (this.rowByKey.size < this.rows) return this.rowByKey.size;\n    if (this.rows < RAMP_ATLAS_MAX_ROWS) {\n      this.resize(this.rows === 0 ? INITIAL_ROWS : this.rows * 2);\n      return this.rowByKey.size;\n    }\n    const [lruKey, lruRow] = this.rowByKey.entries().next().value as [string, number];\n    this.rowByKey.delete(lruKey);\n    return lruRow;\n  }\n\n  /** Grow to `rows`, keeping every row at the index it already had — a row\n   *  index is a stable name, and callers hold them. */\n  private resize(rows: number): void {\n    const gl = this.gl;\n    const next = new Uint8ClampedArray(RAMP_WIDTH * rows * 4);\n    next.set(this.pixels);\n    this.pixels = next;\n    this.rows = rows;\n\n    if (!this.texture) {\n      const tex = gl.createTexture();\n      if (!tex) throw new Error('GradientRampAtlas: createTexture failed');\n      this.texture = tex;\n      gl.bindTexture(gl.TEXTURE_2D, tex);\n      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);\n      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);\n      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n    } else {\n      gl.bindTexture(gl.TEXTURE_2D, this.texture);\n    }\n    gl.texImage2D(\n      gl.TEXTURE_2D, 0, gl.RGBA,\n      RAMP_WIDTH, rows, 0,\n      gl.RGBA, gl.UNSIGNED_BYTE, this.pixels,\n    );\n    gl.bindTexture(gl.TEXTURE_2D, null);\n  }\n\n  private writeRow(row: number, ramp: Uint8ClampedArray): void {\n    const gl = this.gl;\n    this.pixels.set(ramp, row * RAMP_WIDTH * 4);\n    gl.bindTexture(gl.TEXTURE_2D, this.texture);\n    gl.texSubImage2D(\n      gl.TEXTURE_2D, 0, 0, row,\n      RAMP_WIDTH, 1,\n      gl.RGBA, gl.UNSIGNED_BYTE, ramp,\n    );\n    gl.bindTexture(gl.TEXTURE_2D, null);\n  }\n}\n"],"mappings":"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"}

package/dist/renderer/cache/cache.js

@@ -1,13 +0,0 @@
-import { tessellate as e } from "@weasel-js/geom/tessellate";
-//#region src/renderer/cache/cache.ts
-var t = /* @__PURE__ */ new WeakMap();
-function n(n) {
-	let r = t.get(n);
-	if (r !== void 0) return r;
-	let i = e(n);
-	return t.set(n, i), i;
-}
-//#endregion
-export { n as getMesh };
-
-//# sourceMappingURL=cache.js.map

package/dist/renderer/cache/cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache.js","names":["cache","getMesh","cached","path","mesh","tessellate"],"sources":["../../../src/renderer/cache/cache.ts"],"sourcesContent":["import type { Path } from '@weasel-js/core';\nimport { type Mesh, tessellate } from '@weasel-js/geom/tessellate';\n\nlet cache = new WeakMap<Path, Mesh>();\n\n/**\n * Return the tessellated Mesh for `path`, computing and caching on first call.\n * Cached by Path identity (WeakMap) — different Path objects with the same\n * coords are distinct cache entries.\n *\n * Note: solid-fill rect paths bypass this cache entirely — they go into the\n * rect batch in `draw.ts`. The cache only serves polygon paths (where tessellation is\n * non-trivial and Path-object stability is the right contract).\n *\n * Also bypassed whenever `DrawContext.flattenTolerance` is set: `fillMeshHandle`\n * (see `../draw`) routes custom-tolerance fills through a fresh transient\n * tessellation instead of this cache.\n */\nexport function getMesh(path: Path): Mesh {\n  const cached = cache.get(path);\n  if (cached !== undefined) return cached;\n  const mesh = tessellate(path);\n  cache.set(path, mesh);\n  return mesh;\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetCacheForTests(): void {\n  cache = new WeakMap();\n}\n"],"mappings":";;AAGA,IAAIA,oBAAQ,IAAI,QAAoB;AAepC,SAAgBC,EAAQ,GAAkB;CACxC,IAAMC,IAASF,EAAM,IAAIG,CAAI;CAC7B,IAAID,MAAW,KAAA,GAAW,OAAOA;CACjC,IAAME,IAAOC,EAAWF,CAAI;CAE5B,OADAH,EAAM,IAAIG,GAAMC,CAAI,GACbA;AACT"}