@weasel-js/core 1.6.1 → 1.7.1

package/dist/renderer/cache/GLImageCache.js

@@ -0,0 +1,64 @@
+//#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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,102 @@
+//#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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,51 @@
+//#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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/dist/renderer/cache/markerCommandCache.js

@@ -0,0 +1,59 @@
+import { getMarker as e, markerGeneration as t } from "../../core/strokeMarkers.js";
+import { markerKeyOf as n } from "../../core/markerInset.js";
+import { STROKE_CONFIGS_PER_PATH as r } from "./strokeMeshCache.js";
+import { headCommands as i, markerHeads as a, markerReadsKey as o } from "../../features/paths/markerCommands.js";
+//#region src/renderer/cache/markerCommandCache.ts
+var s = /* @__PURE__ */ new WeakMap(), c = /* @__PURE__ */ new WeakMap(), l = (e) => e === void 0 ? "" : typeof e == "string" ? e : `${e.key}@${String(e.size ?? "")}`;
+function u(t) {
+	let r = "";
+	for (let i of [
+		t.markerStart,
+		t.markerMid,
+		t.markerEnd
+	]) {
+		let a = i === void 0 ? void 0 : e(n(i));
+		if (a === void 0) {
+			r += "/";
+			continue;
+		}
+		let s = o(a, t);
+		if (s === null) return null;
+		r += `${s}/`;
+	}
+	return r;
+}
+function d(e, t, n) {
+	if (n !== null) {
+		let t = s.get(e);
+		return t === void 0 && s.set(e, t = /* @__PURE__ */ new Map()), t;
+	}
+	let r = c.get(e);
+	r === void 0 && c.set(e, r = /* @__PURE__ */ new WeakMap());
+	let i = r.get(t);
+	return i === void 0 && r.set(t, i = /* @__PURE__ */ new Map()), i;
+}
+function f(e, n, o, s, c) {
+	if (o.markerStart === void 0 && o.markerMid === void 0 && o.markerEnd === void 0) return [];
+	let f = u(o), p = d(e, n, f), m = [
+		s,
+		c ?? "",
+		t(),
+		l(o.markerStart),
+		l(o.markerMid),
+		l(o.markerEnd),
+		f ?? ""
+	].join("|"), h = p.get(m);
+	if (h === void 0) {
+		let t = a(e, o, s, c);
+		h = {
+			heads: t,
+			paint: o.paint,
+			cmds: i(t, o)
+		}, p.size >= r && p.clear(), p.set(m, h);
+	} else h.paint !== o.paint && (h.paint = o.paint, h.cmds = i(h.heads, o));
+	return h.cmds;
+}
+//#endregion
+export { f as cachedMarkerCommands };
+
+//# sourceMappingURL=markerCommandCache.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markerCommandCache.js","names":["byValue","byStroke","refKey","ref","readsKey","key","stroke","entry","getMarker","markerKeyOf","reads","markerReadsKey","mapFor","map","path","strokes","source","cachedMarkerCommands","strokeWidth","flattenTolerance","markerGeneration","heads","markerHeads","headCommands","STROKE_CONFIGS_PER_PATH"],"sources":["../../../src/renderer/cache/markerCommandCache.ts"],"sourcesContent":["/**\n * A stroke's marker commands, cached per path. The placed head is a fresh\n * `Path`, and the fill cache keys on path identity — so rebuilding it every\n * frame would re-tessellate and re-upload every head every frame.\n *\n * Keyed on value, so a painter that builds a new stroke object every frame\n * still hits: the resolved lengths, the flatten tolerance, the registry's\n * generation, the marker refs and whatever fields each head declares it reads.\n * A head that does not declare them may read any field, so for it the stroke\n * as the command carried it — before any `{ px }` length was resolved — joins\n * the key by identity. Paint is applied over the cached geometry, so a new\n * paint reuses the heads.\n */\n\nimport type { Path } from '@weasel-js/core';\nimport type { FillStyle, MarkerRef, Stroke } from '@weasel-js/paint';\nimport type { PathDrawCommand } from '../DrawCommand';\nimport {\n  headCommands, markerHeads, markerReadsKey, type MarkerHead,\n} from 'features/paths/markerCommands';\nimport { getMarker, markerGeneration } from '../../core/strokeMarkers';\nimport { markerKeyOf } from '../../core/markerInset';\nimport { STROKE_CONFIGS_PER_PATH } from './strokeMeshCache';\n\ninterface Entry {\n  readonly heads: MarkerHead[];\n  paint: FillStyle | undefined;\n  cmds: PathDrawCommand[];\n}\n\nlet byValue = new WeakMap<Path, Map<string, Entry>>();\nlet byStroke = new WeakMap<Path, WeakMap<Stroke, Map<string, Entry>>>();\n\nconst refKey = (ref: MarkerRef | undefined): string =>\n  ref === undefined ? '' : typeof ref === 'string' ? ref : `${ref.key}@${String(ref.size ?? '')}`;\n\n/** What every head of `stroke` reads, or `null` if any head does not say. */\nfunction readsKey(stroke: Stroke): string | null {\n  let key = '';\n  for (const ref of [stroke.markerStart, stroke.markerMid, stroke.markerEnd]) {\n    const entry = ref === undefined ? undefined : getMarker(markerKeyOf(ref));\n    if (entry === undefined) {\n      key += '/';\n      continue;\n    }\n    const reads = markerReadsKey(entry, stroke);\n    if (reads === null) return null;\n    key += `${reads}/`;\n  }\n  return key;\n}\n\nfunction mapFor(path: Path, source: Stroke, reads: string | null): Map<string, Entry> {\n  if (reads !== null) {\n    let map = byValue.get(path);\n    if (map === undefined) byValue.set(path, (map = new Map()));\n    return map;\n  }\n  let strokes = byStroke.get(path);\n  if (strokes === undefined) byStroke.set(path, (strokes = new WeakMap()));\n  let map = strokes.get(source);\n  if (map === undefined) strokes.set(source, (map = new Map()));\n  return map;\n}\n\n/**\n * The marker commands for `path` under `stroke`, whose lengths are already\n * resolved to world units. `source` is the stroke before that resolution.\n */\nexport function cachedMarkerCommands(\n  path: Path,\n  source: Stroke,\n  stroke: Stroke,\n  strokeWidth: number,\n  flattenTolerance: number | undefined,\n): PathDrawCommand[] {\n  if (stroke.markerStart === undefined && stroke.markerMid === undefined && stroke.markerEnd === undefined) {\n    return [];\n  }\n  const reads = readsKey(stroke);\n  const map = mapFor(path, source, reads);\n  const key = [\n    strokeWidth,\n    flattenTolerance ?? '',\n    markerGeneration(),\n    refKey(stroke.markerStart),\n    refKey(stroke.markerMid),\n    refKey(stroke.markerEnd),\n    reads ?? '',\n  ].join('|');\n  let entry = map.get(key);\n  if (entry === undefined) {\n    const heads = markerHeads(path, stroke, strokeWidth, flattenTolerance);\n    entry = { heads, paint: stroke.paint, cmds: headCommands(heads, stroke) };\n    if (map.size >= STROKE_CONFIGS_PER_PATH) map.clear();\n    map.set(key, entry);\n  } else if (entry.paint !== stroke.paint) {\n    entry.paint = stroke.paint;\n    entry.cmds = headCommands(entry.heads, stroke);\n  }\n  return entry.cmds;\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetMarkerCommandCacheForTests(): void {\n  byValue = new WeakMap();\n  byStroke = new WeakMap();\n}\n"],"mappings":";;;;;AA8BA,IAAIA,oBAAU,IAAI,QAAkC,GAChDC,oBAAW,IAAI,QAAmD,GAEhEC,KAAU,MACdC,MAAQ,KAAA,IAAY,KAAK,OAAOA,KAAQ,WAAWA,IAAM,GAAGA,EAAI,IAAI,GAAG,OAAOA,EAAI,QAAQ,EAAE;AAG9F,SAASC,EAAS,GAA+B;CAC/C,IAAIC,IAAM;CACV,KAAK,IAAMF,KAAO;EAACG,EAAO;EAAaA,EAAO;EAAWA,EAAO;CAAS,GAAG;EAC1E,IAAMC,IAAQJ,MAAQ,KAAA,IAAY,KAAA,IAAYK,EAAUC,EAAYN,CAAG,CAAC;EACxE,IAAII,MAAU,KAAA,GAAW;GACvB,KAAO;GACP;EACF;EACA,IAAMG,IAAQC,EAAeJ,GAAOD,CAAM;EAC1C,IAAII,MAAU,MAAM,OAAO;EAC3B,KAAO,GAAGA,EAAM;CAClB;CACA,OAAOL;AACT;AAEA,SAASO,EAAO,GAAY,GAAgB,GAA0C;CACpF,IAAIF,MAAU,MAAM;EAClB,IAAIG,IAAMb,EAAQ,IAAIc,CAAI;EAE1B,OADID,MAAQ,KAAA,KAAWb,EAAQ,IAAIc,GAAO,oBAAM,IAAI,IAAI,CAAE,GACnDD;CACT;CACA,IAAIE,IAAUd,EAAS,IAAIa,CAAI;CAC/B,AAAIC,MAAY,KAAA,KAAWd,EAAS,IAAIa,GAAO,oBAAU,IAAI,QAAQ,CAAE;CACvE,IAAID,IAAME,EAAQ,IAAIC,CAAM;CAE5B,OADIH,MAAQ,KAAA,KAAWE,EAAQ,IAAIC,GAAS,oBAAM,IAAI,IAAI,CAAE,GACrDH;AACT;AAMA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GACmB;CACnB,IAAIX,EAAO,gBAAgB,KAAA,KAAaA,EAAO,cAAc,KAAA,KAAaA,EAAO,cAAc,KAAA,GAC7F,OAAO,CAAC;CAEV,IAAMI,IAAQN,EAASE,CAAM,GACvBO,IAAMD,EAAOE,GAAME,GAAQN,CAAK,GAChCL,IAAM;EACVa;EACAC,KAAoB;EACpBC,EAAiB;EACjBlB,EAAOI,EAAO,WAAW;EACzBJ,EAAOI,EAAO,SAAS;EACvBJ,EAAOI,EAAO,SAAS;EACvBI,KAAS;CACX,CAAC,CAAC,KAAK,GAAG,GACNH,IAAQM,EAAI,IAAIR,CAAG;CACvB,IAAIE,MAAU,KAAA,GAAW;EACvB,IAAMc,IAAQC,EAAYR,GAAMR,GAAQY,GAAaC,CAAgB;EAGrE,AAFA,IAAQ;GAAE;GAAO,OAAOb,EAAO;GAAO,MAAMiB,EAAaF,GAAOf,CAAM;EAAE,GACpEO,EAAI,QAAQW,KAAyBX,EAAI,MAAM,GACnDA,EAAI,IAAIR,GAAKE,CAAK;CACpB,OAAO,AAAIA,EAAM,UAAUD,EAAO,UAChC,EAAM,QAAQA,EAAO,OACrB,EAAM,OAAOiB,EAAahB,EAAM,OAAOD,CAAM;CAE/C,OAAOC,EAAM;AACf"}

package/dist/renderer/cache/outlineMeshCache.js

@@ -0,0 +1,15 @@
+import { pathFromD as e } from "@weasel-js/geom";
+import { tessellate as t } from "@weasel-js/geom/tessellate";
+//#region src/renderer/cache/outlineMeshCache.ts
+var n = 1 / 4096, r = 2048, i = /* @__PURE__ */ new Map();
+function a(a, o) {
+	let s = i.get(a);
+	if (s !== void 0) return s;
+	i.size >= r && (i = /* @__PURE__ */ new Map());
+	let c = t(e(o), { flattenTolerance: n });
+	return i.set(a, c), c;
+}
+//#endregion
+export { n as OUTLINE_FLATTEN_TOLERANCE, r as OUTLINE_MESH_CACHE_LIMIT, a as outlineMesh };
+
+//# sourceMappingURL=outlineMeshCache.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outlineMeshCache.js","names":["OUTLINE_FLATTEN_TOLERANCE","OUTLINE_MESH_CACHE_LIMIT","cache","outlineMesh","cached","key","mesh","tessellate","pathFromD","d"],"sources":["../../../src/renderer/cache/outlineMeshCache.ts"],"sourcesContent":["/**\n * Tessellated glyph outlines, in em space.\n *\n * This is the half of the outline text tier that is expensive: parsing `d`\n * into a path and running earcut over it costs far more than the per-instance\n * transform that follows. It is also the half that does not vary — em space\n * is unit-scale and baseline-relative, so the same glyph of the same face is\n * the same triangles at every size, position and zoom. Tessellate once, keep\n * it, and pay only a scale-and-translate per occurrence.\n *\n * That is why the renderer transforms cached vertices on the CPU and appends\n * them into one shared buffer rather than giving each glyph its own model\n * matrix: a per-glyph matrix would mean a draw call per glyph, throwing away\n * the batching the atlas tier already has, in exchange for saving an\n * arithmetic pass over a few hundred vertices.\n *\n * ### Flatten tolerance\n *\n * Tessellating once means committing to a curve tolerance once, and em space\n * makes that a clean tradeoff rather than a guess: an error of `T` em shows\n * up as `T × fontSize × viewScale` screen pixels. At 1/4096 em, a glyph would\n * have to reach ~4000 screen pixels tall before the flattening error covered\n * a single pixel — well past any size a document is read at, and far enough\n * past the tier's own threshold that the two never interact.\n *\n * ### Bound\n *\n * A plain `Map` with a cap and wholesale eviction. Glyph tessellations are\n * small (a few hundred vertices) and the working set is a charset, not a\n * document — the cap exists so a page that cycles through many faces cannot\n * grow without limit, not because pressure is expected. Wholesale rather than\n * LRU because the refill cost is bounded by what is actually on screen, and\n * an LRU's bookkeeping would cost more than the misses it avoids.\n */\n\nimport { pathFromD } from '@weasel-js/geom';\nimport { tessellate, type Mesh } from '@weasel-js/geom/tessellate';\n\n/** Curve flattening tolerance for glyph outlines, in em. See the header. */\nexport const OUTLINE_FLATTEN_TOLERANCE = 1 / 4096;\n\n/** Cached glyph tessellations before the cache is dropped wholesale. */\nexport const OUTLINE_MESH_CACHE_LIMIT = 2048;\n\nlet cache = new Map<string, Mesh>();\n\n/**\n * The em-space tessellation of one glyph.\n *\n * `key` identifies the glyph — face identity plus codepoint, assembled by\n * `layoutRuns`. `d` is only read on a miss, so passing the path data on every\n * call costs nothing; it is already in hand from the same source.\n */\nexport function outlineMesh(key: string, d: string): Mesh {\n  const cached = cache.get(key);\n  if (cached !== undefined) return cached;\n  if (cache.size >= OUTLINE_MESH_CACHE_LIMIT) cache = new Map();\n  const mesh = tessellate(pathFromD(d), { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE });\n  cache.set(key, mesh);\n  return mesh;\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetOutlineMeshCacheForTests(): void {\n  cache = new Map();\n}\n"],"mappings":";;;AAuCA,IAAaA,IAA4B,IAAI,MAGhCC,IAA2B,MAEpCC,oBAAQ,IAAI,IAAkB;AASlC,SAAgBC,EAAY,GAAa,GAAiB;CACxD,IAAMC,IAASF,EAAM,IAAIG,CAAG;CAC5B,IAAID,MAAW,KAAA,GAAW,OAAOA;CACjC,AAAIF,EAAM,QAAQD,MAA0B,oBAAQ,IAAI,IAAI;CAC5D,IAAMK,IAAOC,EAAWC,EAAUC,CAAC,GAAG,EAAE,kBAAkBT,EAA0B,CAAC;CAErF,OADAE,EAAM,IAAIG,GAAKC,CAAI,GACZA;AACT"}

package/dist/renderer/cache/outlineStrokeMeshCache.js

@@ -0,0 +1,31 @@
+import { tessellateStroke as e } from "../../features/paths/tessellate/stroke.js";
+import { OUTLINE_FLATTEN_TOLERANCE as t } from "./outlineMeshCache.js";
+import { pathFromD as n } from "@weasel-js/geom";
+//#region src/renderer/cache/outlineStrokeMeshCache.ts
+var r = 2048, i = 1 / 1024, a = /* @__PURE__ */ new Map();
+function o(e) {
+	return Math.round(e / i) * i;
+}
+function s(i, o, s, c) {
+	if (!(s > 0)) return null;
+	let l = [
+		i,
+		s,
+		c.join ?? "miter",
+		c.cap ?? "butt",
+		c.miterLimit ?? "",
+		c.align ?? "center",
+		(c.dash ?? []).join(",")
+	].join("|"), u = a.get(l);
+	if (u !== void 0) return u.indices.length === 0 ? null : u;
+	a.size >= r && (a = /* @__PURE__ */ new Map());
+	let d = e(n(o), {
+		...c,
+		width: s
+	}, { flattenTolerance: t });
+	return a.set(l, d), d.indices.length === 0 ? null : d;
+}
+//#endregion
+export { r as OUTLINE_STROKE_MESH_CACHE_LIMIT, s as outlineStrokeMesh, o as quantizeEmWidth };
+
+//# sourceMappingURL=outlineStrokeMeshCache.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outlineStrokeMeshCache.js","names":["OUTLINE_STROKE_MESH_CACHE_LIMIT","WIDTH_QUANTUM","cache","quantizeEmWidth","emWidth","outlineStrokeMesh","key","glyphKey","stroke","cached","mesh","tessellateStroke","pathFromD","d","OUTLINE_FLATTEN_TOLERANCE"],"sources":["../../../src/renderer/cache/outlineStrokeMeshCache.ts"],"sourcesContent":["/**\n * Tessellated glyph *outlines' strokes*, in em space.\n *\n * The sibling of `outlineMeshCache`, and cached for the same reason: parsing\n * `d` and tessellating a ribbon costs far more than the per-instance\n * transform that follows, and em space is size- and position-independent, so\n * one tessellation serves every occurrence of that glyph.\n *\n * ### Why the width is in the key\n *\n * A fill mesh is the same triangles at every size. A stroke's is not — the\n * ribbon's width relative to the glyph decides the geometry, so the em-space\n * mesh depends on `strokeWidth / fontSize`. That ratio is a property of the\n * run's style, not of the frame, so it is stable across frames and makes a\n * perfectly good cache key; what it is *not* is free, so a document that\n * animates stroke width or font size will miss every frame. That is the same\n * bargain `tessellate` makes everywhere else, and it is the reason the width\n * is quantized before it reaches the key: neighbouring sub-quantum widths\n * would otherwise each get their own entry and evict each other.\n *\n * Joins, caps, miter limit, alignment and dash all change the ribbon too, so\n * they are in the key as well — assembled by the caller, which already has\n * the `Stroke` in hand.\n */\n\nimport { pathFromD } from '@weasel-js/geom';\nimport { tessellateStroke } from 'features/paths/tessellate/stroke';\nimport type { Stroke } from '@weasel-js/paint';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\nimport { OUTLINE_FLATTEN_TOLERANCE } from './outlineMeshCache';\n\n/** Cached ribbons before the cache is dropped wholesale. Matches the fill\n *  cache's cap: the working set is a charset times the handful of stroke\n *  widths a document actually uses. */\nexport const OUTLINE_STROKE_MESH_CACHE_LIMIT = 2048;\n\n/**\n * Em-width quantum. 1/1024 em is finer than any width a reader can\n * distinguish at the sizes this tier serves — a 0.001 em difference is a\n * fifth of a screen pixel on 200px text — and coarse enough that a slider\n * dragged across a range lands on a bounded set of keys.\n */\nconst WIDTH_QUANTUM = 1 / 1024;\n\nlet cache = new Map<string, Mesh>();\n\n/** Quantized em width, exported so the key builder and the tessellator agree\n *  on the number rather than each rounding for themselves. */\nexport function quantizeEmWidth(emWidth: number): number {\n  return Math.round(emWidth / WIDTH_QUANTUM) * WIDTH_QUANTUM;\n}\n\n/**\n * The em-space stroke tessellation of one glyph.\n *\n * `glyphKey` identifies the glyph (face identity plus codepoint, assembled by\n * `layoutRuns`); `emWidth` is the stroke width divided by the run's font\n * size, already quantized. `d` is only read on a miss.\n *\n * Returns `null` when the ribbon has no area — a zero or negative width, or a\n * glyph whose path is empty (a space).\n */\nexport function outlineStrokeMesh(\n  glyphKey: string,\n  d: string,\n  emWidth: number,\n  stroke: Stroke,\n): Mesh | null {\n  if (!(emWidth > 0)) return null;\n  const key = [\n    glyphKey, emWidth, stroke.join ?? 'miter', stroke.cap ?? 'butt',\n    stroke.miterLimit ?? '', stroke.align ?? 'center', (stroke.dash ?? []).join(','),\n  ].join('|');\n\n  const cached = cache.get(key);\n  if (cached !== undefined) return cached.indices.length === 0 ? null : cached;\n  if (cache.size >= OUTLINE_STROKE_MESH_CACHE_LIMIT) cache = new Map();\n\n  const mesh = tessellateStroke(\n    pathFromD(d),\n    { ...stroke, width: emWidth },\n    { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE },\n  );\n  cache.set(key, mesh);\n  return mesh.indices.length === 0 ? null : mesh;\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetOutlineStrokeMeshCacheForTests(): void {\n  cache = new Map();\n}\n"],"mappings":";;;;AAkCA,IAAaA,IAAkC,MAQzCC,IAAgB,IAAI,MAEtBC,oBAAQ,IAAI,IAAkB;AAIlC,SAAgBC,EAAgB,GAAyB;CACvD,OAAO,KAAK,MAAMC,IAAUH,CAAa,IAAIA;AAC/C;AAYA,SAAgBI,EACd,GACA,GACA,GACA,GACa;CACb,IAAI,EAAED,IAAU,IAAI,OAAO;CAC3B,IAAME,IAAM;EACVC;EAAUH;EAASI,EAAO,QAAQ;EAASA,EAAO,OAAO;EACzDA,EAAO,cAAc;EAAIA,EAAO,SAAS;GAAWA,EAAO,QAAQ,CAAC,EAAA,CAAG,KAAK,GAAG;CACjF,CAAC,CAAC,KAAK,GAAG,GAEJC,IAASP,EAAM,IAAII,CAAG;CAC5B,IAAIG,MAAW,KAAA,GAAW,OAAOA,EAAO,QAAQ,WAAW,IAAI,OAAOA;CACtE,AAAIP,EAAM,QAAQF,MAAiC,oBAAQ,IAAI,IAAI;CAEnE,IAAMU,IAAOC,EACXC,EAAUC,CAAC,GACX;EAAE,GAAGL;EAAQ,OAAOJ;CAAQ,GAC5B,EAAE,kBAAkBU,EAA0B,CAChD;CAEA,OADAZ,EAAM,IAAII,GAAKI,CAAI,GACZA,EAAK,QAAQ,WAAW,IAAI,OAAOA;AAC5C"}

package/dist/renderer/cache/strokeMeshCache.js

@@ -0,0 +1,44 @@
+import { resolveStrokeWidth as e, tessellateStroke as t } from "../../features/paths/tessellate/stroke.js";
+import { strokeInsets as n } from "../../core/markerInset.js";
+//#region src/renderer/cache/strokeMeshCache.ts
+var r = 8, i = 1 / 8;
+function a(e, t) {
+	if (!(e > 0) || !(t > 0) || !Number.isFinite(t)) return t;
+	let n = Math.ceil(Math.LN2 / (2 * Math.log1p(i / e)));
+	return 2 ** (Math.round(Math.log2(t) * n) / n);
+}
+var o = /* @__PURE__ */ new WeakMap();
+function s(t, r) {
+	let i = e(t.width ?? 1, 1), a = n(t, i);
+	return [
+		i,
+		t.cap ?? "butt",
+		t.join ?? "miter",
+		t.miterLimit ?? "",
+		t.align ?? "center",
+		(t.dash ?? []).join(","),
+		t.varyingWidthJoinThreshold ?? "",
+		r ?? "",
+		a.start,
+		a.end
+	].join("|");
+}
+function c(i, a, c) {
+	let l = o.get(i);
+	l === void 0 && (l = /* @__PURE__ */ new Map(), o.set(i, l));
+	let u = s(a, c), d = l.get(u);
+	if (d !== void 0 && d.vertexWidths === a.vertexWidths) return d.mesh;
+	let f = e(a.width ?? 1, 1), p = n(a, f), m = t(i, a, {
+		flattenTolerance: c,
+		startInset: p.start,
+		endInset: p.end
+	});
+	return d === void 0 && l.size >= r && l.clear(), l.set(u, {
+		mesh: m,
+		vertexWidths: a.vertexWidths
+	}), m;
+}
+//#endregion
+export { r as STROKE_CONFIGS_PER_PATH, a as quantizeStrokeScale, c as strokeMesh };
+
+//# sourceMappingURL=strokeMeshCache.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strokeMeshCache.js","names":["STROKE_CONFIGS_PER_PATH","PX_WIDTH_TOLERANCE","quantizeStrokeScale","px","scale","stepsPerOctave","cache","configKey","width","resolveStrokeWidth","stroke","insets","strokeInsets","flattenTolerance","strokeMesh","byConfig","path","key","entry","mesh","tessellateStroke"],"sources":["../../../src/renderer/cache/strokeMeshCache.ts"],"sourcesContent":["/**\n * Tessellated stroke ribbons for scene paths, keyed on `Path` identity.\n *\n * The sibling of `cache.ts` (fills) and `outlineStrokeMeshCache.ts` (glyph\n * ribbons in em space), and it inherits their contract: identity, not content.\n * A `Path` rebuilt with equal coords is a distinct entry.\n *\n * Design: `docs/superpowers/specs/2026-08-15-stroke-ribbon-cache-design.md`.\n */\n\nimport type { Path } from '@weasel-js/core';\nimport type { Stroke } from '@weasel-js/paint';\nimport { tessellateStroke, resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport { strokeInsets } from '../../core/markerInset';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\n\n/**\n * Distinct stroke configurations kept per path before that path's map is\n * dropped wholesale. A document uses a handful; a width slider passes this on\n * its first drag and then degrades to tessellating every frame, which is what\n * it did before this cache existed.\n */\nexport const STROKE_CONFIGS_PER_PATH = 8;\n\n/** Screen-pixel bound on how far a quantized `{ px }` ribbon's width may\n *  drift from the width asked for: each edge moves at most half of it. */\nconst PX_WIDTH_TOLERANCE = 1 / 8;\n\n/**\n * `scale` snapped to a log-spaced grid, for resolving a `{ px }` width against.\n * Resolving against the raw scale gives a continuous zoom a new cache key every\n * frame. The grid is fine enough that the resolved ribbon stays within\n * `PX_WIDTH_TOLERANCE` screen pixels of `px`, so it is coarser for thin\n * strokes, and powers of two land on it exactly.\n */\nexport function quantizeStrokeScale(px: number, scale: number): number {\n  if (!(px > 0) || !(scale > 0) || !Number.isFinite(scale)) return scale;\n  const stepsPerOctave = Math.ceil(Math.LN2 / (2 * Math.log1p(PX_WIDTH_TOLERANCE / px)));\n  return 2 ** (Math.round(Math.log2(scale) * stepsPerOctave) / stepsPerOctave);\n}\n\ninterface StrokeEntry {\n  readonly mesh: Mesh;\n  /** Compared by reference — long enough that stringifying it per frame would\n   *  cost what the cache saves. */\n  readonly vertexWidths: number[] | undefined;\n}\n\nlet cache = new WeakMap<Path, Map<string, StrokeEntry>>();\n\n/** The stroke parameters that change the ribbon's geometry. `paint` and\n *  `vertexColors` are absent on purpose: both are applied over the same\n *  triangles at draw time. Marker *identity* is absent too — only the\n *  resolved trim distance affects these triangles, so two heads with the\n *  same inset share one entry. */\nfunction configKey(stroke: Stroke, flattenTolerance: number | undefined): string {\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  const insets = strokeInsets(stroke, width);\n  return [\n    width,\n    stroke.cap ?? 'butt',\n    stroke.join ?? 'miter',\n    stroke.miterLimit ?? '',\n    stroke.align ?? 'center',\n    (stroke.dash ?? []).join(','),\n    stroke.varyingWidthJoinThreshold ?? '',\n    flattenTolerance ?? '',\n    insets.start,\n    insets.end,\n  ].join('|');\n}\n\n/** The tessellated ribbon for `path` under `stroke`. The same `Mesh` object\n *  comes back for as long as the entry lives. */\nexport function strokeMesh(\n  path: Path,\n  stroke: Stroke,\n  flattenTolerance: number | undefined,\n): Mesh {\n  let byConfig = cache.get(path);\n  if (byConfig === undefined) {\n    byConfig = new Map<string, StrokeEntry>();\n    cache.set(path, byConfig);\n  }\n\n  const key = configKey(stroke, flattenTolerance);\n  const entry = byConfig.get(key);\n  if (entry !== undefined && entry.vertexWidths === stroke.vertexWidths) {\n    return entry.mesh;\n  }\n\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  const insets = strokeInsets(stroke, width);\n  const mesh = tessellateStroke(path, stroke, {\n    flattenTolerance,\n    startInset: insets.start,\n    endInset: insets.end,\n  });\n  // Only a new key grows the map; replacing one under a churning\n  // `vertexWidths` must not evict the other configurations alongside it.\n  if (entry === undefined && byConfig.size >= STROKE_CONFIGS_PER_PATH) byConfig.clear();\n  byConfig.set(key, { mesh, vertexWidths: stroke.vertexWidths });\n  return mesh;\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetStrokeMeshCacheForTests(): void {\n  cache = new WeakMap();\n}\n"],"mappings":";;;AAsBA,IAAaA,IAA0B,GAIjCC,IAAqB,IAAI;AAS/B,SAAgBC,EAAoB,GAAY,GAAuB;CACrE,IAAI,EAAEC,IAAK,MAAM,EAAEC,IAAQ,MAAM,CAAC,OAAO,SAASA,CAAK,GAAG,OAAOA;CACjE,IAAMC,IAAiB,KAAK,KAAK,KAAK,OAAO,IAAI,KAAK,MAAMJ,IAAqBE,CAAE,EAAE;CACrF,OAAO,MAAM,KAAK,MAAM,KAAK,KAAKC,CAAK,IAAIC,CAAc,IAAIA;AAC/D;AASA,IAAIC,oBAAQ,IAAI,QAAwC;AAOxD,SAASC,EAAU,GAAgB,GAA8C;CAC/E,IAAMC,IAAQC,EAAmBC,EAAO,SAAS,GAAG,CAAC,GAC/CC,IAASC,EAAaF,GAAQF,CAAK;CACzC,OAAO;EACLA;EACAE,EAAO,OAAO;EACdA,EAAO,QAAQ;EACfA,EAAO,cAAc;EACrBA,EAAO,SAAS;GACfA,EAAO,QAAQ,CAAC,EAAA,CAAG,KAAK,GAAG;EAC5BA,EAAO,6BAA6B;EACpCG,KAAoB;EACpBF,EAAO;EACPA,EAAO;CACT,CAAC,CAAC,KAAK,GAAG;AACZ;AAIA,SAAgBG,EACd,GACA,GACA,GACM;CACN,IAAIC,IAAWT,EAAM,IAAIU,CAAI;CAC7B,AAAID,MAAa,KAAA,MACf,oBAAW,IAAI,IAAyB,GACxCT,EAAM,IAAIU,GAAMD,CAAQ;CAG1B,IAAME,IAAMV,EAAUG,GAAQG,CAAgB,GACxCK,IAAQH,EAAS,IAAIE,CAAG;CAC9B,IAAIC,MAAU,KAAA,KAAaA,EAAM,iBAAiBR,EAAO,cACvD,OAAOQ,EAAM;CAGf,IAAMV,IAAQC,EAAmBC,EAAO,SAAS,GAAG,CAAC,GAC/CC,IAASC,EAAaF,GAAQF,CAAK,GACnCW,IAAOC,EAAiBJ,GAAMN,GAAQ;EAC1C;EACA,YAAYC,EAAO;EACnB,UAAUA,EAAO;CACnB,CAAC;CAKD,OAFIO,MAAU,KAAA,KAAaH,EAAS,QAAQf,KAAyBe,EAAS,MAAM,GACpFA,EAAS,IAAIE,GAAK;EAAE;EAAM,cAAcP,EAAO;CAAa,CAAC,GACtDS;AACT"}