@weasel-js/core 1.9.4 → 1.10.0

package/dist/renderer/textures/registerTexture.js

@@ -1,34 +0,0 @@
-import { createReflectable as e } from "@weasel-js/registry";
-//#region src/renderer/textures/registerTexture.ts
-var t = 0, n = e(), r = n.reflection, i = [];
-function a(e, t) {
-	let n = {
-		prefix: e,
-		owner: t
-	};
-	return i.push(n), () => {
-		let e = i.indexOf(n);
-		e !== -1 && i.splice(e, 1);
-	};
-}
-function o(e) {
-	for (let t = 0; t < i.length; t++) if (e.startsWith(i[t].prefix)) return i[t].owner;
-}
-function s(e) {
-	let t = i.length > 0 ? o(e) : void 0, r = n.get(e);
-	return r ? (t?.touched?.(e), r) : t ? (t.revive(e), n.get(e) ?? null) : null;
-}
-function c(e) {
-	let r = `tex_${++t}`;
-	return n.set(r, { source: e }), { id: r };
-}
-function l(e, t) {
-	return n.set(e, { source: t }), { id: e };
-}
-function u(e) {
-	return n.delete(e.id);
-}
-//#endregion
-export { s as getTexture, a as ownTextureIds, c as registerTexture, l as registerTextureAs, r as textureRegistry, u as unregisterTexture };
-
-//# sourceMappingURL=registerTexture.js.map

package/dist/renderer/textures/registerTexture.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerTexture.js","names":["counter","registry","createReflectable","textureRegistry","owners","ownTextureIds","claim","i","ownerOf","id","getTexture","owner","hit","registerTexture","image","registerTextureAs","unregisterTexture","handle"],"sources":["../../../src/renderer/textures/registerTexture.ts"],"sourcesContent":["/**\n * registerTexture — accepts an image source, assigns an opaque id, stores in\n * a module-level registry. Actual GL upload happens lazily at draw time in\n * drawShader() via GLTextureCache.upload (which is idempotent).\n *\n * Lifecycle: a texture lives until `unregisterTexture`. Each renderer frees\n * its own GL copy at the top of its next frame.\n *\n * Convention §9: this registry stores image data only — no per-renderer state.\n * Each WeaselRenderer's GLTextureCache does its own dedup by id and source.\n */\n\nimport type { TextureHandle } from '@weasel-js/paint';\nimport { createReflectable, type Reflection } from '@weasel-js/registry';\n\nexport type { TextureHandle };\n\n/** A registered texture's image source, uploaded to GL lazily at first draw. */\nexport interface TextureEntry {\n  source: HTMLImageElement | ImageBitmap;\n}\n\nlet counter = 0;\nconst registry = createReflectable<TextureEntry>();\n\n/** Every registered texture, keyed by its handle id. */\nexport const textureRegistry: Reflection<TextureEntry> = registry.reflection;\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetTextureRegistryForTests(): void {\n  registry.clear();\n  counter = 0;\n}\n\n/**\n * Whoever mints the ids under one prefix and can rebuild any of them.\n * @internal\n */\nexport interface TextureIdOwner {\n  /** Register `id` again if it can be rebuilt; do nothing otherwise. */\n  revive(id: string): void;\n  /** `id` was looked up and found: something is about to draw it. */\n  touched?(id: string): void;\n}\n\nconst owners: { prefix: string; owner: TextureIdOwner }[] = [];\n\n/**\n * Claim every texture id starting with `prefix`. Returns the release.\n * @internal\n */\nexport function ownTextureIds(prefix: string, owner: TextureIdOwner): () => void {\n  const claim = { prefix, owner };\n  owners.push(claim);\n  return () => {\n    const i = owners.indexOf(claim);\n    if (i !== -1) owners.splice(i, 1);\n  };\n}\n\nfunction ownerOf(id: string): TextureIdOwner | undefined {\n  for (let i = 0; i < owners.length; i++) {\n    if (id.startsWith(owners[i].prefix)) return owners[i].owner;\n  }\n  return undefined;\n}\n\n/**\n * The entry for `id`, as a draw looks it up. An owned id that was\n * unregistered is rebuilt by its owner first, so a handle held past its\n * texture's eviction still draws.\n */\nexport function getTexture(id: string): TextureEntry | null {\n  const owner = owners.length > 0 ? ownerOf(id) : undefined;\n  const hit = registry.get(id);\n  if (hit) {\n    owner?.touched?.(id);\n    return hit;\n  }\n  if (!owner) return null;\n  owner.revive(id);\n  return registry.get(id) ?? null;\n}\n\n/**\n * Register an image for use as a shader texture uniform.\n *\n * Returns a TextureHandle whose `id` can be passed as a ShaderUniform value.\n * The handle is valid for the lifetime of the renderer it will be used with.\n *\n * @param image  The image to register. HTMLImageElement must be fully loaded.\n * @returns      Opaque TextureHandle.\n */\nexport function registerTexture(\n  image: HTMLImageElement | ImageBitmap,\n): TextureHandle {\n  const id = `tex_${++counter}`;\n  registry.set(id, { source: image });\n  return { id };\n}\n\n/**\n * Register an image under an id its caller chose.\n * @internal\n */\nexport function registerTextureAs(\n  id: string,\n  image: HTMLImageElement | ImageBitmap,\n): TextureHandle {\n  registry.set(id, { source: image });\n  return { id };\n}\n\n/**\n * Drop a registered texture. Every renderer that uploaded it frees its GL\n * copy at the top of its next frame; a draw command still holding the handle\n * then draws nothing and warns. The image itself is the caller's to release.\n *\n * @returns Whether the handle was registered.\n */\nexport function unregisterTexture(handle: TextureHandle): boolean {\n  return registry.delete(handle.id);\n}\n"],"mappings":";;AAsBA,IAAIA,IAAU,GACRC,IAAWC,EAAgC,GAGpCC,IAA4CF,EAAS,YAmB5DG,IAAsD,CAAC;AAM7D,SAAgBC,EAAc,GAAgB,GAAmC;CAC/E,IAAMC,IAAQ;EAAE;EAAQ;CAAM;CAE9B,OADAF,EAAO,KAAKE,CAAK,SACJ;EACX,IAAMC,IAAIH,EAAO,QAAQE,CAAK;EAC9B,AAAIC,MAAM,MAAIH,EAAO,OAAOG,GAAG,CAAC;CAClC;AACF;AAEA,SAASC,EAAQ,GAAwC;CACvD,KAAK,IAAID,IAAI,GAAGA,IAAIH,EAAO,QAAQ,KACjC,IAAIK,EAAG,WAAWL,EAAOG,EAAE,CAAC,MAAM,GAAG,OAAOH,EAAOG,EAAE,CAAC;AAG1D;AAOA,SAAgBG,EAAW,GAAiC;CAC1D,IAAMC,IAAQP,EAAO,SAAS,IAAII,EAAQC,CAAE,IAAI,KAAA,GAC1CG,IAAMX,EAAS,IAAIQ,CAAE;CAO3B,OANIG,KACFD,GAAO,UAAUF,CAAE,GACZG,KAEJD,KACLA,EAAM,OAAOF,CAAE,GACRR,EAAS,IAAIQ,CAAE,KAAK,QAFR;AAGrB;AAWA,SAAgBI,EACd,GACe;CACf,IAAMJ,IAAK,OAAO,EAAET;CAEpB,OADAC,EAAS,IAAIQ,GAAI,EAAE,QAAQK,EAAM,CAAC,GAC3B,EAAE,MAAG;AACd;AAMA,SAAgBC,EACd,GACA,GACe;CAEf,OADAd,EAAS,IAAIQ,GAAI,EAAE,QAAQK,EAAM,CAAC,GAC3B,EAAE,MAAG;AACd;AASA,SAAgBE,EAAkB,GAAgC;CAChE,OAAOf,EAAS,OAAOgB,EAAO,EAAE;AAClC"}

package/dist/scheduling/useVisibleRaf.js

@@ -1,69 +0,0 @@
-import { useCallback as e, useLayoutEffect as t, useMemo as n, useRef as r } from "react";
-import { useLatest as i } from "@weasel-js/react";
-//#region src/scheduling/useVisibleRaf.ts
-var a = () => typeof document < "u" && document.hidden, o = (e) => typeof e == "function" ? e() : e?.current ?? null;
-function s(s, c = {}) {
-	let l = i(s), u = i(c), d = r(null), f = r(!1), p = r(!1), m = r(!0), h = r(!0), g = r(null), _ = r(null), v = e(() => u.current.dangerouslyRunWhenHidden === !0 || !a() && h.current, [u]), y = e(() => {
-		d.current !== null && ((u.current.cancelFrame ?? cancelAnimationFrame)(d.current), d.current = null);
-	}, [u]), b = e(() => {
-		d.current === null && m.current && (d.current = (u.current.requestFrame ?? requestAnimationFrame)((e) => {
-			d.current = null, m.current && f.current && v() && (f.current = !1, l.current(e));
-		}));
-	}, [
-		l,
-		v,
-		u
-	]), x = e(() => {
-		let e = g.current;
-		if (!e) return;
-		let t = o(u.current.target);
-		t !== _.current && (_.current && e.unobserve(_.current), _.current = t, h.current = !0, t && e.observe(t));
-	}, [u]), S = e(() => {
-		if (!v()) {
-			if (p.current) return;
-			p.current = !0, y();
-			return;
-		}
-		p.current && (p.current = !1, m.current && (u.current.onResume?.(), f.current && b()));
-	}, [
-		y,
-		v,
-		u,
-		b
-	]), C = e(() => {
-		if (m.current) {
-			if (x(), f.current = !0, !v()) {
-				p.current = !0;
-				return;
-			}
-			b();
-		}
-	}, [
-		v,
-		b,
-		x
-	]), w = e(() => {
-		f.current = !1, y();
-	}, [y]);
-	return t(() => (m.current = !0, document.addEventListener("visibilitychange", S), typeof IntersectionObserver < "u" && (g.current = new IntersectionObserver((e) => {
-		h.current = e.some((e) => e.isIntersecting), S();
-	}), x()), () => {
-		m.current = !1, document.removeEventListener("visibilitychange", S), g.current?.disconnect(), g.current = null, _.current = null, h.current = !0, y(), f.current = !1, p.current = !1;
-	}), [
-		y,
-		S,
-		x
-	]), n(() => ({
-		request: C,
-		cancel: w,
-		isVisible: v
-	}), [
-		C,
-		w,
-		v
-	]);
-}
-//#endregion
-export { s as useVisibleRaf };
-
-//# sourceMappingURL=useVisibleRaf.js.map

package/dist/scheduling/useVisibleRaf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useVisibleRaf.js","names":["documentHidden","resolveTarget","target","useVisibleRaf","frameRef","useLatest","frame","optsRef","options","rafRef","useRef","pendingRef","suspendedRef","aliveRef","intersectingRef","observerRef","observedRef","isVisible","useCallback","cancelRaf","scheduleRaf","time","syncObserver","io","el","syncGate","request","cancel","useLayoutEffect","entries","useMemo"],"sources":["../../src/scheduling/useVisibleRaf.ts"],"sourcesContent":["/**\n * The one place weasel decides whether a frame may run, so that \"a loop does no\n * work nobody can see\" holds by construction rather than by every loop author\n * remembering. Nothing runs while the document is hidden; a loop that names an\n * element also stops while that element is outside the viewport.\n *\n * A request made while suspended is held, not dropped, and re-armed when the\n * surface comes back — so a loop never needs to poll visibility itself.\n */\n\nimport { type RefObject, useCallback, useLayoutEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\n\n/** What a loop names as its element, resolved every time the gate is consulted\n *  so a ref filled in after mount still starts the observer. */\nexport type VisibleRafTarget = RefObject<Element | null> | (() => Element | null);\n\n/** Options for {@link useVisibleRaf}. */\nexport interface VisibleRafOptions {\n  /** Also gate on this element's intersection with the viewport. Omit it and\n   *  the loop is gated on document visibility alone. */\n  target?: VisibleRafTarget;\n  /**\n   * Run frames regardless of visibility. The escape hatch for a loop that is\n   * not painting for a viewer — an offscreen recording, an export driving its\n   * own frames. It is the wrong fix for a loop that stalls after a tab switch:\n   * that is a missing `request()`, and setting this hides it.\n   */\n  dangerouslyRunWhenHidden?: boolean;\n  /** Frame clock. Read live, so a test may inject one after mount. */\n  requestFrame?: (cb: FrameRequestCallback) => number;\n  cancelFrame?: (handle: number) => void;\n  /**\n   * Runs once when the loop leaves suspension, before the frame that follows\n   * it. Where a loop that measures elapsed time drops the interval it spent\n   * suspended — without it, an hour hidden arrives as one hour-long frame.\n   */\n  onResume?: () => void;\n}\n\n/** The handle {@link useVisibleRaf} returns. Nothing runs until `request()` is called. */\nexport interface VisibleRaf {\n  /** Ask for a frame. Idempotent while one is outstanding, and held rather than\n   *  dropped while suspended. Identity is stable for the component's lifetime. */\n  request(): void;\n  /** Drop the outstanding request, held or scheduled. */\n  cancel(): void;\n  /** Whether a frame would run right now. */\n  isVisible(): boolean;\n}\n\nconst documentHidden = (): boolean => typeof document !== 'undefined' && document.hidden;\n\nconst resolveTarget = (target: VisibleRafTarget | undefined): Element | null =>\n  typeof target === 'function' ? target() : (target?.current ?? null);\n\n/**\n * @param frame Runs on the frame, with the timestamp the clock supplied.\n *   A continuous loop calls `request()` again from inside it; a one-shot loop\n *   does not.\n */\nexport function useVisibleRaf(\n  frame: (time: number) => void,\n  options: VisibleRafOptions = {},\n): VisibleRaf {\n  const frameRef = useLatest(frame);\n  const optsRef = useLatest(options);\n\n  const rafRef = useRef<number | null>(null);\n  const pendingRef = useRef(false);\n  const suspendedRef = useRef(false);\n  const aliveRef = useRef(true);\n  const intersectingRef = useRef(true);\n  const observerRef = useRef<IntersectionObserver | null>(null);\n  const observedRef = useRef<Element | null>(null);\n\n  const isVisible = useCallback(\n    (): boolean =>\n      optsRef.current.dangerouslyRunWhenHidden === true ||\n      (!documentHidden() && intersectingRef.current),\n    [optsRef],\n  );\n\n  const cancelRaf = useCallback(() => {\n    if (rafRef.current === null) return;\n    (optsRef.current.cancelFrame ?? cancelAnimationFrame)(rafRef.current);\n    rafRef.current = null;\n  }, [optsRef]);\n\n  const scheduleRaf = useCallback(() => {\n    if (rafRef.current !== null || !aliveRef.current) return;\n    rafRef.current = (optsRef.current.requestFrame ?? requestAnimationFrame)((time) => {\n      // Released before the frame runs, so a `request()` issued from inside it\n      // schedules the next one instead of being swallowed.\n      rafRef.current = null;\n      if (!aliveRef.current || !pendingRef.current || !isVisible()) return;\n      pendingRef.current = false;\n      frameRef.current(time);\n    });\n  }, [frameRef, isVisible, optsRef]);\n\n  /** Attaches the observer once the named element exists. Ref callbacks and\n   *  lazily-mounted hosts fill their refs after this hook's effect has run. */\n  const syncObserver = useCallback(() => {\n    const io = observerRef.current;\n    if (!io) return;\n    const el = resolveTarget(optsRef.current.target);\n    if (el === observedRef.current) return;\n    if (observedRef.current) io.unobserve(observedRef.current);\n    observedRef.current = el;\n    // An element that has gone away stops gating rather than stopping the loop.\n    intersectingRef.current = true;\n    if (el) io.observe(el);\n  }, [optsRef]);\n\n  /** Re-reads the gate after something that could have changed it. Suspending\n   *  drops the outstanding frame but keeps the request; resuming hands the\n   *  loop its rebase before re-arming. */\n  const syncGate = useCallback(() => {\n    if (!isVisible()) {\n      if (suspendedRef.current) return;\n      suspendedRef.current = true;\n      cancelRaf();\n      return;\n    }\n    if (!suspendedRef.current) return;\n    suspendedRef.current = false;\n    if (!aliveRef.current) return;\n    optsRef.current.onResume?.();\n    if (pendingRef.current) scheduleRaf();\n  }, [cancelRaf, isVisible, optsRef, scheduleRaf]);\n\n  const request = useCallback(() => {\n    if (!aliveRef.current) return;\n    syncObserver();\n    pendingRef.current = true;\n    if (!isVisible()) {\n      suspendedRef.current = true;\n      return;\n    }\n    scheduleRaf();\n  }, [isVisible, scheduleRaf, syncObserver]);\n\n  const cancel = useCallback(() => {\n    pendingRef.current = false;\n    cancelRaf();\n  }, [cancelRaf]);\n\n  // Re-armed in setup because the refs survive StrictMode's simulated remount, and\n  // a layout effect so the arming precedes the host's own layout effects — a loop\n  // driven from one of those would otherwise be declined on the second mount.\n  useLayoutEffect(() => {\n    aliveRef.current = true;\n    document.addEventListener('visibilitychange', syncGate);\n    if (typeof IntersectionObserver !== 'undefined') {\n      observerRef.current = new IntersectionObserver((entries) => {\n        intersectingRef.current = entries.some((e) => e.isIntersecting);\n        syncGate();\n      });\n      syncObserver();\n    }\n    return () => {\n      aliveRef.current = false;\n      document.removeEventListener('visibilitychange', syncGate);\n      observerRef.current?.disconnect();\n      observerRef.current = null;\n      observedRef.current = null;\n      intersectingRef.current = true;\n      cancelRaf();\n      pendingRef.current = false;\n      suspendedRef.current = false;\n    };\n  }, [cancelRaf, syncGate, syncObserver]);\n\n  // Stable identity: `requestRedraw` and friends outlive the render that made\n  // them, and consumers capture the handle.\n  return useMemo(() => ({ request, cancel, isVisible }), [request, cancel, isVisible]);\n}\n"],"mappings":"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"}

package/dist/test-seams-DM2B87-g.d.ts

@@ -1,356 +0,0 @@
-import { FillStyle, PosedFill, GradientUnits, GradStop, ColorSpace, MarkerKey, Stroke } from '@weasel-js/paint';
-import { ComponentType } from 'react';
-import { Reflection } from '@weasel-js/registry';
-import { c as ShaderProgram, G as GlMat3, P as ProgramSource } from './registerProgram-T9S_PfAX.js';
-import { Path } from '@weasel-js/geom';
-
-/**
- * Resolve a `units: 'bounds'` gradient into the frame its node is painted in.
- *
- * Node painters bake the pose into their geometry (`pathInPoseFrame`) rather
- * than emitting a per-node transform, so by the time the renderer sees a
- * scene node there is no node-local space left for a gradient to refer to.
- * This is the paint-side counterpart: it maps box-relative gradient geometry
- * onto the same box the path was just projected into, so the two arrive in
- * the renderer in one frame.
- */
-
-/** The box a `'bounds'` gradient's normalized geometry is mapped onto —
- *  usually a node's bounds. */
-interface FillPoseBox {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/**
- * Map a `'bounds'` gradient's `0..1` geometry onto `box`, returning it in the
- * box's own frame (`units: 'local'`). Any other fill — solid, pattern, or a
- * gradient in another space — is returned untouched.
- *
- * Radii scale by the box's normalized diagonal, SVG's rule for a percentage
- * radius against `objectBoundingBox`: `sqrt(w² + h²) / sqrt(2)`, which is
- * exactly `w` for a square box. The renderer's radial gradient is circular,
- * so a non-square box cannot make it the ellipse SVG would — this keeps the
- * radius proportionate instead.
- */
-declare function fillInPoseFrame(fill: FillStyle, box: FillPoseBox): PosedFill;
-/**
- * Inverse of {@link fillInPoseFrame}: express a gradient already positioned
- * in `box`'s frame as `0..1` fractions of that box (`units: 'bounds'`), so
- * it follows the node when moved or resized.
- *
- * The importer's counterpart — SVG `userSpaceOnUse` coordinates arrive in
- * page space, and normalizing them here makes an imported gradient behave
- * exactly like one drawn in the app.
- *
- * A zero-width or zero-height box has no frame to normalize against; the
- * fill is returned untouched rather than divided by zero.
- */
-declare function fillToBoundsFrame(fill: FillStyle, box: FillPoseBox): FillStyle;
-
-/**
- * The paint-kind registry — what makes `FillStyle` open.
- *
- * A consumer registers a sixth kind and it renders, converts between the
- * bounds and pose frames, and serializes, with no kit edits. The five built-in
- * kinds are registered here at module load so an editor's kind bar can
- * enumerate every kind through one list.
- *
- * Each kit layer consults this registry for a kind it does not recognize and
- * otherwise runs its own built-in branch. That split is not laziness: a built-in
- * kind's render slot lives in the GL renderer, its serialize slot lives in
- * `@weasel-js/svg`, and neither can be imported from here without inverting a
- * package dependency.
- */
-
-/** A compiled GL program. A paint kind gets one from
- *  {@link PaintBindContext.program} and hands it back from `bind`. */
-type PaintProgram = ShaderProgram;
-/**
- * `FillStyle`'s discriminant, open on the string the way `ChromeId` is: the
- * five kinds the kit ships, plus whatever a consumer registers.
- */
-type PaintKind = 'solid' | 'linear-gradient' | 'radial-gradient' | 'conic-gradient' | 'pattern' | (string & {});
-/** What a registered kind's editor renders. `PaintInput` in `@weasel-js/ui`
- *  is the control that mounts it. */
-interface PaintKindEditorProps {
-    value: FillStyle;
-    onInput?(next: FillStyle): void;
-    onChange(next: FillStyle): void;
-}
-/**
- * The lifetime a paint kind's GPU state belongs to: one renderer on one live
- * context. The object itself is the key — a kind caches textures in a
- * `WeakMap` on it, so two renderers sharing a context never trade them — and
- * `onRelease` is where it frees them.
- */
-interface PaintResources {
-    /** Run `release` once, when this lifetime ends: the renderer is disposed, or
-     *  its context was lost and restored. Free every GL object made under it
-     *  there. */
-    onRelease(release: () => void): void;
-}
-/**
- * The renderer surface a paint kind binds against, narrowed to what a paint
- * needs. The full `DrawContext` is not consumer surface.
- */
-interface PaintBindContext {
-    readonly gl: WebGL2RenderingContext;
-    /** The group alpha this draw inherits — multiply it into the paint's own. */
-    readonly alpha: number;
-    /**
-     * The compiled program for a `registerProgram` id, compiled against this
-     * renderer on first use. `null` when no source is registered under `id` or
-     * compilation failed.
-     */
-    program(id: string): PaintProgram | null;
-    /** Send `u_proj` and `u_model`, which every kit vertex shader takes. */
-    setProjAndModel(program: PaintProgram): void;
-    /**
-     * `u_worldInv` for a paint declaring `units` — the inverse of the transform
-     * from the paint's space to the frame the geometry arrives in. Paired with
-     * the vertex shader's `v_world` varying this is *the* paint-space
-     * convention; it is not gradient-specific.
-     *
-     * `null` when that space has no inverse — a transform or view that flattens
-     * an axis. Nothing the paint draws there means anything, so `bind` should
-     * return `null` and draw nothing.
-     */
-    spaceInverse(units: GradientUnits | undefined): GlMat3 | null;
-    /**
-     * The transform from the space `units` names to device pixels of the target
-     * this draw lands in — screen pixels times the pixel ratio on screen, output
-     * pixels in a headless render. It is what a paint baking a texture measures
-     * its resolution against. `null` where `spaceInverse` is.
-     */
-    spaceToDevice(units: GradientUnits | undefined): GlMat3 | null;
-    /** The largest texture side this context accepts, `MAX_TEXTURE_SIZE`. */
-    readonly maxTextureSize: number;
-    /** The lifetime GPU state made for this draw belongs to. Stable across the
-     *  frames of one renderer, so it is the key for a kind's texture cache. */
-    readonly resources: PaintResources;
-    /**
-     * Bake a stop ramp into the frame's ramp atlas, bind that atlas to a texture
-     * unit, and return the `v` the ramp's own row sits at — every ramp in a
-     * frame shares one texture, so a paint must sample at the returned `v` and
-     * not at a constant.
-     *
-     * `space` is the blend the stops are baked through, defaulting to `'rgb'`.
-     * It is part of the atlas key, so the same stops under two spaces take two
-     * rows rather than colliding.
-     */
-    bindRamp(stops: GradStop[], unit: number, space?: ColorSpace): number;
-}
-/**
- * One paint kind.
- *
- * `seed`, `label` and `colorOf` are the editor's slots and every kind has
- * them. The rest are optional because a kind may not need them — but
- * `inPoseFrame` and `toBoundsFrame` come as a pair or not at all: a kind that
- * converts one direction and not the other paints correctly once and then
- * drifts on the next resize.
- */
-interface PaintKindEntry {
-    id: string;
-    label: string;
-    /** Glyph naming this kind in an editor's kind bar, as an icon name the UI
-     *  layer resolves — the same indirection `PrefBase.icon` uses. A kind
-     *  without one is named by its `label`. */
-    icon?: string;
-    /** A paint of this kind seeded from a color — what an editor writes when a
-     *  consumer switches a solid to this kind. */
-    seed(fromColor: string): FillStyle;
-    /** The single color this paint shows, or `undefined` when it has none. */
-    colorOf(paint: FillStyle): string | undefined;
-    /** Editor slot. */
-    Editor?: ComponentType<PaintKindEditorProps>;
-    /**
-     * The stop list this paint reads as. With `fromStops`, it is what makes a
-     * kind a gradient: `listGradientKinds` returns the kinds carrying both, and
-     * `switchGradientKind` converts between any two of them through the list.
-     */
-    stopsOf?(paint: FillStyle): GradStop[];
-    /** A paint of this kind built from a stop list, in `bounds` units. The
-     *  converse of `stopsOf`; supply both or neither. */
-    fromStops?(stops: GradStop[]): FillStyle;
-    /**
-     * Render slot: bind program, uniforms and textures for `fill` and return the
-     * bound program; `null` declines the paint.
-     *
-     * Binding is split from drawing on purpose — a caller owning its own stencil
-     * state (an inner/outer-aligned stroke, an even-odd fill) must issue its own
-     * draw call, and the kit's draw wrapper would clobber that state. Shader
-     * output must be premultiplied: `outColor = vec4(rgb * a, a)`.
-     *
-     * The geometry is not always the node's own. Text below the outline tier
-     * paints by drawing a quad over its glyphs' screen box into an offscreen
-     * buffer and masking that with glyph coverage, so a paint must come from
-     * `v_world` through `spaceInverse`, not from where `a_position` happens to
-     * lie.
-     */
-    bind?(ctx: PaintBindContext, fill: FillStyle): PaintProgram | null;
-    /** Bounds frame → the frame the node is painted in. */
-    inPoseFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;
-    /** The inverse. Required whenever `inPoseFrame` is supplied. */
-    toBoundsFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;
-    /**
-     * The `<defs>` entry backing a `url(#id)` reference.
-     *
-     * SVG has paint servers for two gradients and a pattern and nothing else, so
-     * a kind beyond those has no element to target: write a foreign-namespaced
-     * one under the `wzl:` prefix `@weasel-js/svg` declares on the root whenever
-     * a document holds such a paint. That package emits the fallback color
-     * beside the reference on its own, from `colorOf`.
-     */
-    toSvg?(id: string, fill: FillStyle): string;
-    /**
-     * Shader programs `bind` looks up through `ctx.program`, keyed by program
-     * id; registering the kind registers them. Declaring them here rather than
-     * calling `registerProgram` at import keeps a kind loaded by
-     * {@link registerPaintKindLoader} free of core's registries.
-     */
-    programs?: Readonly<Record<string, ProgramSource>>;
-}
-/** Every registered paint kind, with the overrides each displaced. */
-declare const paintKindRegistry: Reflection<PaintKindEntry>;
-/**
- * A consumer's own paint, typed as a `FillStyle`.
- *
- * `FillStyle` stays a closed union: opening its discriminant would widen every
- * built-in member and break the narrowing the kit's own branches depend on.
- * A registered kind declares its own interface instead and passes it through
- * here — the kit reads only `fill` and hands the whole object back to that
- * kind's slots.
- */
-declare function asPaint<T extends {
-    fill: string;
-}>(paint: T): FillStyle;
-/** Register a paint kind. Returns a disposer that removes it. Re-registering an
- *  existing id is an override; disposing it uncovers whatever it displaced. */
-declare function registerPaintKind(entry: PaintKindEntry): () => void;
-/** The entry for `kind`, or `undefined`. A lookup that misses on a kind with
- *  a loader starts that load; see {@link registerPaintKindLoader}. */
-declare function getPaintKind(kind: string | undefined): PaintKindEntry | undefined;
-/** Resolves with the entry for a kind that is loaded on first use. */
-type PaintKindLoader = () => Promise<PaintKindEntry>;
-/**
- * Declare a paint kind that is loaded the first time something looks it up,
- * so its code stays out of the bundle until a paint of it appears — typically
- * `() => import('./myKind').then((m) => m.myKindEntry)`.
- *
- * Until it lands the kind is unregistered: the renderer draws nothing for its
- * paints, and every other reader treats it as unknown. Registering it fires
- * `paintKindRegistry`'s subscribers, which is what `<SceneCanvas>` repaints
- * on. Call {@link warmPaintKinds} to load ahead of the first frame instead.
- *
- * A kind that is already registered never calls its loader. Returns a
- * disposer that removes the loader.
- */
-declare function registerPaintKindLoader(id: string, load: PaintKindLoader): () => void;
-/** Is `id` registered, or declared with a loader? */
-declare function isPaintKindKnown(id: string): boolean;
-/**
- * Load paint kinds ahead of their first use, so the first frame that meets
- * one draws it rather than a blank. With no list, loads every kind that has a
- * loader — the kit's lazily loaded built-ins (`mesh-gradient`) plus any a
- * consumer declared with {@link registerPaintKindLoader}.
- *
- * Resolves once every kind is registered; a kind already registered counts
- * as loaded. Rejects when a load fails, or for a kind that is neither
- * registered nor loadable.
- */
-declare function warmPaintKinds(kinds?: readonly string[]): Promise<void>;
-/** Every registered kind, built-ins first, in registration order. The same
- *  array until the registry changes. */
-declare function listPaintKinds(): readonly PaintKindEntry[];
-/** Every registered gradient kind — the ones that read as and build from a
- *  stop list — in registration order. The same array until the registry
- *  changes. */
-declare function listGradientKinds(): readonly PaintKindEntry[];
-/**
- * `paint` retargeted to gradient kind `kind`, or `undefined` when either side
- * is not a gradient kind.
- *
- * Between two of the stop gradients this is `withGradientKind`, which carries
- * the geometry. Any other pair goes through the stop list — `stopsOf` on the
- * way out, `fromStops` on the way in — keeping `interpolate` and `opacity`.
- * Lossy wherever the kinds hold different information; an editor that wants a
- * switch to be undoable should keep the original paint.
- */
-declare function switchGradientKind(paint: FillStyle, kind: PaintKind): FillStyle | undefined;
-/** The registry entry for a paint, or `undefined` when its kind is unknown. */
-declare function paintKindOf(fill: FillStyle): PaintKindEntry | undefined;
-/** @internal Test helper — do not call from product code. */
-declare function _resetPaintKindsForTests(): void;
-
-/**
- * The stroke-marker registry — arrowheads and other line terminators.
- *
- * Keyed by string, because a key is what sits in `stroke.markerEnd`. That is
- * the difference from `registerNodeShape`, which resolves by first-matching
- * predicate and whose `id` is only a label.
- *
- * A built-in's SVG slot lives in `@weasel-js/svg` and cannot be imported here
- * without inverting a package dependency, so an entry carries `toSvg` for that
- * package to consume — the same split `PaintKindEntry` uses.
- */
-
-/** What an entry's `path` is given. Entries that ignore it may return a
- *  constant path. */
-interface MarkerCtx {
-    /** One geometry unit, in the same world units the ribbon is tessellated in.
-     *  Defaults to the resolved stroke width. */
-    readonly size: number;
-    /** The stroke this marker belongs to, already width-resolved. */
-    readonly stroke: Stroke;
-}
-/** `'line'` means the stroke's own paint — SVG 2's `context-stroke`, as the
- *  default rather than an opt-in. */
-type MarkerPaint = FillStyle | 'line' | 'none';
-/** A stroke-marker registry entry: a terminator's geometry, paint and inset. */
-interface MarkerEntry {
-    /** `'kit:'`-free for built-ins so the key matches the SVG attribute value;
-     *  consumers should prefix (`'app-my-head'`). A key becomes the `id` of the
-     *  emitted `<marker>` def, so it must be a valid XML name — no colons. */
-    id: MarkerKey;
-    /** Geometry with its anchor at the origin, pointing +X, in units of
-     *  `ctx.size`. An arbitrary anchor is expressed by where the geometry is
-     *  drawn, which is why there is no `refX`/`refY`. */
-    path(ctx: MarkerCtx): Path;
-    /** Default `'line'`. */
-    fill?: MarkerPaint;
-    /** Outline width is in the same units as `path`. `false` (the default)
-     *  means no outline. */
-    outline?: {
-        width: number;
-        paint?: MarkerPaint;
-    } | false;
-    /** How far back along the line the stroke stops, in units of `ctx.size`.
-     *  Default 0. A property of the shape, not a setting on the stroke: an open
-     *  V needs 0 or its arms stop meeting the line. */
-    inset?: number;
-    /** `'auto'` (default) follows the line; a number is a fixed angle in
-     *  radians, ignoring the line — SVG's `orient="<angle>"`. */
-    orient?: 'auto' | number;
-    /** The stroke fields `path` reads besides `ctx.size` — `[]` for a shape
-     *  drawn from size alone. Declared, a head is reused across stroke objects
-     *  whose listed fields are equal; omitted, only across frames that pass the
-     *  same stroke object, since `path` might read any of it. */
-    reads?: readonly (keyof Stroke)[];
-    /** Emits the `<marker>` def. Consumed by `@weasel-js/svg`. */
-    toSvg?(id: string, entry: MarkerEntry): string;
-}
-/** Every registered marker, with the overrides each displaced. */
-declare const markerRegistry: Reflection<MarkerEntry>;
-/** Register a marker. Returns a disposer. Re-registering an existing id is an
- *  override; disposing it uncovers whatever it displaced rather than deleting the key. */
-declare function registerMarker(entry: MarkerEntry): () => void;
-/** The entry for `key`, or `undefined`. */
-declare function getMarker(key: string | undefined): MarkerEntry | undefined;
-/** Every registered marker, built-ins first, in registration order. */
-declare function listMarkers(): readonly MarkerEntry[];
-/** Test helper. Do not call from product code. */
-declare function _resetMarkersForTests(): void;
-
-export { type FillPoseBox as F, type MarkerEntry as M, type PaintKindEntry as P, _resetMarkersForTests as _, type MarkerCtx as a, type MarkerPaint as b, type PaintBindContext as c, type PaintKind as d, type PaintKindEditorProps as e, type PaintKindLoader as f, type PaintProgram as g, type PaintResources as h, asPaint as i, fillInPoseFrame as j, fillToBoundsFrame as k, getMarker as l, getPaintKind as m, isPaintKindKnown as n, listGradientKinds as o, listMarkers as p, listPaintKinds as q, markerRegistry as r, paintKindOf as s, paintKindRegistry as t, registerMarker as u, registerPaintKind as v, registerPaintKindLoader as w, switchGradientKind as x, warmPaintKinds as y, _resetPaintKindsForTests as z };