@weasel-js/core 1.9.4 → 1.10.1

package/dist/mesh.d.ts

@@ -1,268 +1,4 @@
-import { GradientUnits, ColorSpace, FillStyle, GradStop } from '@weasel-js/paint';
-
-/**
- * Coons and tensor-product patch surfaces — PDF's shading types 6 and 7, as
- * pure geometry.
- *
- * A patch is a curved quadrilateral: four cubic Bézier edges and a color at
- * each corner. The interior is what the edges imply — a Coons patch reads it
- * off the boundary alone; a tensor patch adds four interior control points
- * that pull it around. Both evaluate at a `(u, v)` in the unit square, which
- * is what lets the renderer subdivide a patch into as many triangles as it
- * wants without the patch knowing.
- *
- * Nothing here touches GL, a color string, or a scene. `evalPatch` is the
- * whole contract.
- */
-/** A point in the patch's own space. */
-interface MeshPoint {
-    x: number;
-    y: number;
-}
-/**
- * One patch.
- *
- * `points` walks the boundary: corner 0, the two control points of the edge
- * leaving it, corner 1, its two, and so on — twelve points, ending with the
- * two controls that return to corner 0. A tensor patch appends its four
- * interior points, in the order `(1,1)`, `(1,2)`, `(2,2)`, `(2,1)` of the
- * bicubic control net, which is PDF's own order.
- *
- * Twelve points is a Coons patch and sixteen is a tensor patch; there is no
- * flag, because the count already says which it is.
- *
- * `colors` are the corner colors in the same walk order, as whatever color
- * form the caller resolves — the renderer hands premultiplied RGBA in, the
- * serializer hands CSS strings.
- */
-interface MeshPatch<TColor = string> {
-    points: readonly MeshPoint[];
-    colors: readonly [TColor, TColor, TColor, TColor];
-}
-/** Corner `i` of the boundary walk. */
-declare function patchCorner(patch: MeshPatch<unknown>, i: number): MeshPoint;
-/** `true` when the patch carries the four interior points a tensor patch adds. */
-declare function isTensorPatch(patch: MeshPatch<unknown>): boolean;
-/** A patch is twelve boundary points, or sixteen with the interior. Anything
- *  else cannot be evaluated, and saying so here beats painting nonsense. */
-declare function isValidPatch(patch: MeshPatch<unknown>): boolean;
-/**
- * The patch surface at `(u, v)`, both in `0..1`.
- *
- * `u` runs along the edge leaving corner 0 and `v` along the edge leaving
- * corner 1, so `(0,0)` is corner 0, `(1,0)` corner 1, `(1,1)` corner 2 and
- * `(0,1)` corner 3 — the same walk `colors` is in.
- */
-declare function evalPatch(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint;
-/**
- * The four corner weights at `(u, v)` — bilinear, in the corner walk order.
- *
- * Color is separate from position on purpose: it interpolates in whatever
- * space the caller chose, which is not a thing the surface can do for it.
- */
-declare function cornerWeights(u: number, v: number): [number, number, number, number];
-/** Axis-aligned bounds of a patch, sampled on a grid. Control points alone
- *  bound a Bézier but not tightly, and a mesh paint is baked into a texture
- *  sized from this — a loose box wastes texels on every side. */
-declare function patchBounds(patch: MeshPatch<unknown>, steps?: number): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-
-/**
- * The `mesh-gradient` paint kind — PDF's shading types 6 and 7 as a registered
- * paint.
- *
- * A mesh gradient is a set of curved quadrilateral patches, each with a color
- * at every corner. It is the paint SVG tried to standardize as
- * `<meshgradient>` and abandoned, and the one PDF has had since 1993; what it
- * buys over the three gradients is a color field that bends, so a highlight
- * can follow a form instead of running straight across it.
- *
- * This is a registered kind rather than a sixth branch in the renderer, and
- * deliberately: it uses only the slots `registerPaintKind` gives a consumer, so
- * whatever it can do, a consumer's own kind can do too. Its one concession is
- * living in this package, because that is where the shader registry is.
- *
- * `docs/proposals/2026-09-17-paint-kinds-beyond-svg.md` is the design.
- */
-
-/**
- * A mesh gradient paint.
- *
- * `patches` are in the space `units` names, the same way a gradient's
- * geometry is — under `'bounds'` every point is a fraction of the painted
- * node's box, which is what lets the paint survive a resize.
- *
- * `interpolate` is the space corner colors blend through, matching the three
- * gradients. It is more visible here than there: a mesh blends in two
- * directions at once, so an sRGB blend's muddy middle covers area rather than
- * a line.
- */
-interface MeshGradientFill {
-    fill: 'mesh-gradient';
-    patches: MeshPatch[];
-    units?: GradientUnits;
-    interpolate?: ColorSpace;
-    opacity?: number;
-}
-/** The kind's id, as `FillStyle['fill']` carries it. */
-declare const MESH_GRADIENT_KIND = "mesh-gradient";
-/** A mesh paint, narrowed. */
-declare function isMeshGradientFill(fill: FillStyle | null | undefined): fill is FillStyle & MeshGradientFill;
-/** A one-patch square covering the unit box, its four corners four readings of
- *  `color` — a mesh seeded from a solid has to show *something* curved, or
- *  switching kind looks like nothing happened. */
-declare function seedMeshPatch(color: string): MeshGradientFill;
-/**
- * A stop list as a mesh: one full-height band per gap between neighboring
- * stops, colored left to right. The bands blend exactly the way the ramp
- * does, so a horizontal gradient survives the switch unchanged. A zero-width
- * gap is a hard break and gets no band.
- */
-declare function meshFromStops(stops: readonly GradStop[]): MeshGradientFill;
-/**
- * A mesh read as a stop list: every patch's top edge — corner 0 to corner 1 —
- * placed by its `x` across the mesh's horizontal extent. The inverse of
- * `meshFromStops`, and for any other mesh the ramp across its top.
- */
-declare function meshStops(mesh: MeshGradientFill): GradStop[];
-/**
- * The `<defs>` entry for a mesh paint, in weasel's own namespace.
- *
- * Not SVG's abandoned `<meshgradient>`: that vocabulary only reaches Coons
- * patches, shares patch edges implicitly — a reader that gets the sharing
- * wrong tears the surface rather than failing outright — and has exactly one
- * implementation in the world. Ours writes every patch's points in full.
- * `@weasel-js/svg` puts the paint fallback color beside the reference, so a
- * foreign renderer paints flat instead of nothing.
- */
-declare function meshGradientXml(id: string, mesh: MeshGradientFill): string;
-
-/**
- * A mesh paint baked into one RGBA bitmap.
- *
- * A patch is a surface over `(u, v)`, but a paint has to answer "what color is
- * this fragment", which is the inverse question — and inverting a bicubic is
- * Newton iteration per fragment. Every renderer that draws these instead
- * subdivides the patch into small quads and rasterizes them forward, which is
- * what this does, once per paint, into a texture the shader then samples. The
- * cost is a texture and a resolution; the gain is that the paint composes with
- * every fill the renderer already knows how to draw, clipping included.
- *
- * The bitmap is straight (non-premultiplied) RGBA, matching the ramp atlas;
- * the fragment shader premultiplies.
- */
-
-/** Texels on a side of a bake when the caller names no size. The renderer
- *  sizes each bake from how large the paint draws — see `meshBakeSize`. */
-declare const MESH_BAKE_SIZE = 256;
-/** The box a bake covers, in the paint's own space. */
-interface MeshBox {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/** The bitmap `bakeMesh` produces, and the paint-space box it covers. */
-interface BakedMesh {
-    /** `size` × `size` texels, straight RGBA. */
-    pixels: Uint8ClampedArray;
-    /** Texels on a side; `MESH_BAKE_SIZE` unless the caller asked otherwise. */
-    size: number;
-    /** Where the bitmap sits in paint space, which is what the shader maps a
-     *  fragment through. */
-    box: MeshBox;
-}
-/** The union of every patch's bounds, or `null` when nothing is drawable. */
-declare function meshBounds(patches: readonly MeshPatch[]): MeshBox | null;
-/**
- * Rasterize `patches` into a square bitmap covering their union.
- *
- * Returns `null` when no patch is drawable, which is the caller's cue to paint
- * nothing rather than a blank square.
- */
-declare function bakeMesh(patches: readonly MeshPatch[], space?: ColorSpace, size?: number): BakedMesh | null;
-
-/**
- * How large a mesh bake is, and the bounded cache the bakes live in.
- *
- * A gradient's ramp is one-dimensional, so 256 texels cover it at any size. A
- * mesh's bake is two-dimensional and is stretched over whatever the paint
- * covers, so a fixed size shows its texels once the paint draws large. The
- * bake is sized from the device pixels it covers instead, in power-of-two
- * buckets so a zoom inside one bucket reuses the bake it already has.
- */
-/** The smallest bake: below this a texture costs more in bookkeeping than in
- *  bytes. */
-declare const MESH_BAKE_MIN = 32;
-/** The largest bake, whatever the context allows: 16 MiB of RGBA, and a bake
- *  that already takes a noticeable moment on the CPU. */
-declare const MESH_BAKE_MAX = 2048;
-/**
- * The bake side for a paint drawn `devicePx` device pixels across, on a
- * context accepting `maxTextureSize`: the next power of two at or above it,
- * clamped to `[MESH_BAKE_MIN, MESH_BAKE_MAX]` and to the context. A size that
- * cannot be measured gets `MESH_BAKE_SIZE`.
- */
-declare function meshBakeSize(devicePx: number, maxTextureSize: number): number;
-
-/**
- * The draggable points of a mesh paint, as pure geometry — what an on-canvas
- * editor lists, and what moving one of them does to the paint.
- *
- * Nothing here knows a frame: the handles are in whatever space the mesh's
- * points are, so a caller resolves a `'bounds'` mesh onto its box first
- * (`fillInPoseFrame`) and normalizes the result back (`fillToBoundsFrame`).
- */
-
-/** What a handle moves: a patch corner, one of the two controls of an edge,
- *  or one of a tensor patch's four interior points. */
-type MeshHandleKind = 'corner' | 'control' | 'interior';
-/** One stored point: `patches[patch].points[index]`. */
-interface MeshPointRef {
-    patch: number;
-    index: number;
-}
-/**
- * One draggable point.
- *
- * Patches store their points in full rather than sharing edges, so two
- * patches that meet each carry a copy of the corner and controls they meet
- * at. Those copies are one handle, with a `ref` per copy — dragging one of
- * them alone would tear the surface open along the seam.
- */
-interface MeshHandle {
-    /** Stable while the handle moves: its first ref, as `"patch:index"`. */
-    id: string;
-    kind: MeshHandleKind;
-    at: MeshPoint;
-    refs: readonly MeshPointRef[];
-}
-/**
- * Every draggable point of `mesh`, in walk order: each patch's corners and
- * edge controls, then a tensor patch's interior. Coincident points of one
- * kind merge into one handle. A patch that cannot be evaluated has none.
- */
-declare function meshHandles(mesh: MeshGradientFill): MeshHandle[];
-/**
- * `mesh` with `handle` moved to `to`. A corner carries its edge controls
- * and interior neighbor along by the same offset, the way a path editor's
- * anchor carries its handles; a control or interior point moves alone.
- * Returns a new paint; `mesh` is not modified.
- */
-declare function moveMeshHandle(mesh: MeshGradientFill, handle: MeshHandle, to: MeshPoint): MeshGradientFill;
-/** The lines an editor draws under the handles, as control polygons. */
-interface MeshGuides {
-    /** Every patch edge as its four cubic control points, from the corner it
-     *  leaves to the corner it reaches. */
-    edges: [MeshPoint, MeshPoint, MeshPoint, MeshPoint][];
-    /** Corner to each point it carries — an edge control or interior point. */
-    arms: [MeshPoint, MeshPoint][];
-}
-/** The guides for `mesh`'s valid patches. Shared edges appear once per patch. */
-declare function meshGuides(mesh: MeshGradientFill): MeshGuides;
-
-export { type BakedMesh, MESH_BAKE_MAX, MESH_BAKE_MIN, MESH_BAKE_SIZE, MESH_GRADIENT_KIND, type MeshBox, type MeshGradientFill, type MeshGuides, type MeshHandle, type MeshHandleKind, type MeshPatch, type MeshPoint, type MeshPointRef, bakeMesh, cornerWeights, evalPatch, isMeshGradientFill, isTensorPatch, isValidPatch, meshBakeSize, meshBounds, meshFromStops, meshGradientXml, meshGuides, meshHandles, meshStops, moveMeshHandle, patchBounds, patchCorner, seedMeshPatch };
+export { BakedMesh, MESH_BAKE_MAX, MESH_BAKE_MIN, MESH_BAKE_SIZE, MESH_GRADIENT_KIND, MeshBox, MeshGradientPaint, MeshGuides, MeshHandle, MeshHandleKind, MeshPatch, MeshPoint, MeshPointRef, bakeMesh, cornerWeights, evalPatch, isMeshGradientPaint, isTensorPatch, isValidPatch, meshBakeSize, meshBounds, meshFromStops, meshGradientXml, meshGuides, meshHandles, meshStops, moveMeshHandle, patchBounds, patchCorner, seedMeshPatch } from '@weasel-js/renderer/mesh';
+import '@weasel-js/renderer/patterns-builtin';
+import '@weasel-js/renderer';
+import '@weasel-js/routing';

package/dist/mesh.js

@@ -1,7 +1,3 @@
-import { cornerWeights as e, evalPatch as t, isTensorPatch as n, isValidPatch as r, patchBounds as i, patchCorner as a } from "./features/meshPaint/surface.js";
-import { MESH_BAKE_SIZE as o, bakeMesh as s, meshBounds as c } from "./features/meshPaint/bake.js";
-import { MESH_BAKE_MAX as l, MESH_BAKE_MIN as u, meshBakeSize as d } from "./features/meshPaint/bakeCache.js";
-import { MESH_GRADIENT_KIND as f, isMeshGradientFill as p, meshFromStops as m, meshGradientXml as h, meshStops as g, seedMeshPatch as _ } from "./features/meshPaint/meshPaint.js";
-import "./features/meshPaint/register.js";
-import { meshGuides as v, meshHandles as y, moveMeshHandle as b } from "./features/meshPaint/handles.js";
-export { l as MESH_BAKE_MAX, u as MESH_BAKE_MIN, o as MESH_BAKE_SIZE, f as MESH_GRADIENT_KIND, s as bakeMesh, e as cornerWeights, t as evalPatch, p as isMeshGradientFill, n as isTensorPatch, r as isValidPatch, d as meshBakeSize, c as meshBounds, m as meshFromStops, h as meshGradientXml, v as meshGuides, y as meshHandles, g as meshStops, b as moveMeshHandle, i as patchBounds, a as patchCorner, _ as seedMeshPatch };
+import "./core/paint/registerMesh.js";
+import { MESH_BAKE_MAX as e, MESH_BAKE_MIN as t, MESH_BAKE_SIZE as n, MESH_GRADIENT_KIND as r, bakeMesh as i, cornerWeights as a, evalPatch as o, isMeshGradientPaint as s, isTensorPatch as c, isValidPatch as l, meshBakeSize as u, meshBounds as d, meshFromStops as f, meshGradientXml as p, meshGuides as m, meshHandles as h, meshStops as g, moveMeshHandle as _, patchBounds as v, patchCorner as y, seedMeshPatch as b } from "@weasel-js/renderer/mesh";
+export { e as MESH_BAKE_MAX, t as MESH_BAKE_MIN, n as MESH_BAKE_SIZE, r as MESH_GRADIENT_KIND, i as bakeMesh, a as cornerWeights, o as evalPatch, s as isMeshGradientPaint, c as isTensorPatch, l as isValidPatch, u as meshBakeSize, d as meshBounds, f as meshFromStops, p as meshGradientXml, m as meshGuides, h as meshHandles, g as meshStops, _ as moveMeshHandle, v as patchBounds, y as patchCorner, b as seedMeshPatch };

package/dist/move.d.ts

@@ -1,10 +1,12 @@
-import { O as OriginProjection } from './originProjection-gHnOup4e.js';
-export { U as UseMoveOptions } from './originProjection-gHnOup4e.js';
-import { S as SnapTarget } from './types-k-5Oqh-U.js';
-import { M as MoveBehavior } from './types-B4iJRHC3.js';
+import { O as OriginProjection } from './originProjection-CoNVpITV.js';
+export { U as UseMoveOptions } from './originProjection-CoNVpITV.js';
+import { S as SnapTarget } from './types-DBbbCy0i.js';
+import { M as MoveBehavior } from './clone-C0eADtS0.js';
 import '@weasel-js/history';
 import '@weasel-js/geom';
 import '@weasel-js/routing';
+import './poseDescriptor-Bqk-11Rl.js';
+import '@weasel-js/animator';
 
 /**
  * Move behavior that drops the dragged nodes into a container the pointer

package/dist/{originProjection-gHnOup4e.d.ts → originProjection-CoNVpITV.d.ts}

@@ -1,4 +1,4 @@
-import { M as MoveBehavior } from './types-B4iJRHC3.js';
+import { M as MoveBehavior } from './clone-C0eADtS0.js';
 
 /** Option surface for the `move` action. */
 

package/dist/patterns-builtin.d.ts

@@ -1,118 +1 @@
-import { TilePatternSpec, TextureHandle } from '@weasel-js/paint';
-
-/**
- * The shapes a built-in tile is made of, as data.
- *
- * One description, two renderers: `patterns-builtin` strokes/fills these to
- * an `OffscreenCanvas` to build the GL texture, and `@weasel-js/svg` maps
- * them to `<pattern>` children. Duplicating the tile drawing in the
- * serializer would let the raster and vector forms drift apart silently.
- */
-
-/** One primitive within a pattern tile, in tile-local coordinates. */
-type TileShape = {
-    kind: 'line';
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-    width: number;
-    color: string;
-} | {
-    kind: 'circle';
-    cx: number;
-    cy: number;
-    r: number;
-    color: string;
-} | {
-    kind: 'ellipse';
-    cx: number;
-    cy: number;
-    rx: number;
-    ry: number;
-    rotation: number;
-    color: string;
-} | {
-    kind: 'rect';
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    color: string;
-};
-/** A built-in tile's shapes plus the edge length they're drawn within. */
-interface TileGeometry {
-    size: number;
-    shapes: TileShape[];
-}
-/** Defaults per tile kind, matching each factory's signature. */
-declare function tileSize(spec: TilePatternSpec): number;
-/** Resolve a pattern spec to the shapes that make up one tile. Consumers that
- *  want to draw a pattern swatch themselves — a picker, an SVG export — read
- *  this rather than rasterizing a texture. */
-declare function tileGeometry(spec: TilePatternSpec): TileGeometry;
-/** Draw a tile's shapes to a 2D context — the raster half of the pair. */
-declare function drawTileShapes(oc: CanvasRenderingContext2D, geometry: TileGeometry): void;
-
-/**
- * Built-in pattern factories — generic line/dot/scatter textures. Each
- * returns a `TextureHandle` you can wrap in a `FillStyle` of
- * `{ fill: 'pattern', pattern }` and pass to anything that accepts a `FillStyle`
- * (`FillStyle`-aware layers, path fills, etc.).
- * Imported from a subpath so consumers that ship their own catalog can
- * avoid the bundle cost.
- *
- * All factories require an explicit `color` (and `bg` for `chunks`). No
- * defaults are baked in — the caller's design system is the source of truth
- * for palette decisions.
- *
- * Each is a thin wrapper over `tileGeometry`, which describes the tile as
- * shapes so `@weasel-js/svg` can emit the same tile as a `<pattern>`.
- * Prefer naming a tile in a `TilePatternSpec` over calling these directly —
- * a spec serializes, a `TextureHandle` does not.
- */
-
-/** Diagonal hatch (forward slash). */
-interface HatchParams {
-    color: string;
-    size?: number;
-    lineWidth?: number;
-}
-/** Build a diagonal-hatch pattern texture. */
-declare function hatch(params: HatchParams): TextureHandle | null;
-/** Diagonal hatch in both directions. */
-interface CrosshatchParams {
-    color: string;
-    size?: number;
-    lineWidth?: number;
-}
-/** Build a crosshatch pattern texture. */
-declare function crosshatch(params: CrosshatchParams): TextureHandle | null;
-/** Regular grid of filled dots. */
-interface DotsParams {
-    color: string;
-    size?: number;
-    radius?: number;
-}
-/** Build a dot-grid pattern texture. */
-declare function dots(params: DotsParams): TextureHandle | null;
-/**
- * Random scatter of small ellipses on top of a solid background. Driven by a
- * seeded PRNG so the same `seed` produces a deterministic tile.
- *
- * Note: the `bg` field is optional — omit it for a transparent background
- * (the scatter shapes draw directly onto whatever sits beneath the overlay).
- */
-interface ChunksParams {
-    color: string;
-    bg?: string;
-    size?: number;
-    /** Coverage: `chunks * chunkSize²` per `size²` tile. Range ~[0, 1]. */
-    density?: number;
-    chunkSize?: number;
-    seed?: number;
-}
-/** Build a seeded random-scatter pattern texture. */
-declare function chunks(params: ChunksParams): TextureHandle | null;
-
-export { type ChunksParams, type CrosshatchParams, type DotsParams, type HatchParams, type TileGeometry, type TileShape, chunks, crosshatch, dots, drawTileShapes, hatch, tileGeometry, tileSize };
+export { ChunksParams, CrosshatchParams, DotsParams, HatchParams, TileGeometry, TileShape, chunks, crosshatch, dots, drawTileShapes, hatch, tileGeometry, tileSize } from '@weasel-js/renderer/patterns-builtin';

package/dist/patterns-builtin.js

@@ -1,3 +1,2 @@
-import { drawTileShapes as e, tileGeometry as t, tileSize as n } from "./features/patterns/tileGeometry.js";
-import { chunks as r, crosshatch as i, dots as a, hatch as o } from "./features/patterns/patterns-builtin.js";
-export { r as chunks, i as crosshatch, a as dots, e as drawTileShapes, o as hatch, t as tileGeometry, n as tileSize };
+import { chunks as e, crosshatch as t, dots as n, drawTileShapes as r, hatch as i, tileGeometry as a, tileSize as o } from "@weasel-js/renderer/patterns-builtin";
+export { e as chunks, t as crosshatch, n as dots, r as drawTileShapes, i as hatch, a as tileGeometry, o as tileSize };

package/dist/poseDescriptor-Bqk-11Rl.d.ts

@@ -0,0 +1,73 @@
+import { Bounds } from '@weasel-js/routing';
+import { TargetAxes } from '@weasel-js/animator';
+
+/** `Bounds` with a required rotation angle (radians). Pivot is the AABB
+ *  center of the unrotated `{x, y, width, height}`. */
+interface RotatedPose extends Bounds {
+    rotation: number;
+}
+/**
+ * Bridges arbitrary `TPose` shapes into the kit's bounds-driven math: bounds
+ * are read via `getBounds`, and `remapBounds` projects a result back into
+ * TPose.
+ *
+ * `remapBounds(pose, src, dst)` subsumes both "set my own AABB to dst"
+ * (single-leaf resize) and "scale me as a leaf inside parent's src→dst rect"
+ * (group resize) — they're the same affine map.
+ */
+interface PoseDescriptor<TPose, TNode = unknown> {
+    getBounds(pose: TPose): Bounds;
+    remapBounds(pose: TPose, src: Bounds, dst: Bounds): TPose;
+    /** A pose occupying `bounds`, of the same kind as `template`. Unlike
+     *  `remapBounds`, the result carries none of the template's shape. */
+    fromBounds(bounds: Bounds, template: TPose): TPose;
+    /** Translate the pose by (dx, dy). Optional — when omitted, callers fall
+     *  back to a translation derived from `remapBounds` (origin shifted, no
+     *  scale). Path-shaped poses should provide this for performance. */
+    translate?(pose: TPose, dx: number, dy: number): TPose;
+    /** Interpolate between two poses. Optional — animation helpers fall back to
+     *  rect-shape lerp when omitted (which fails for non-rect poses). */
+    lerp?(a: TPose, b: TPose, t: number): TPose;
+    /** How a pose of `like`'s kind maps to the flat numbers an animation moves, and which of them
+     *  are angles. `from` keeps the fields of `like` that are not axes. Null for a pose this
+     *  descriptor cannot map; absent, a pose animates by its flat numeric fields. */
+    axes?(like: TPose): TargetAxes<TPose> | null;
+    /** Read the pose's rotation in radians. Pivot is the AABB center
+     *  (`getBounds(pose)` center). Default 0 when omitted. */
+    getRotation?(pose: TPose): number;
+    /** True iff this pose shape can carry a rotation; the rotation affordance
+     *  hides when it is `false`. When omitted, the kit assumes `true`, so a
+     *  descriptor whose poses cannot rotate (e.g. polygon Paths) should
+     *  return `false`. */
+    supportsRotation?(pose: TPose): boolean;
+    /** Write a rotation (radians) into the pose, bounds unchanged. Absent means
+     *  the pose cannot carry one, and the rotate action leaves it alone. */
+    withRotation?(pose: TPose, rotation: number): TPose;
+    /**
+     * A descriptor specialized to one node. Every other method here sees only
+     * the pose, so shapes sharing a pose type are indistinguishable to them.
+     * Implement this to read `node.data` once and hand back a descriptor that
+     * knows which shape it is describing. Callers reach it through
+     * {@link poseDescriptorForNode}; sites with only an id keep using the
+     * unspecialized descriptor.
+     */
+    forNode?(node: TNode): PoseDescriptor<TPose, TNode>;
+}
+/** The descriptor `node` should be read through: its own specialization when
+ *  it declares one, and otherwise the descriptor unchanged. */
+declare function poseDescriptorForNode<TPose, TNode>(descriptor: PoseDescriptor<TPose, TNode>, node: TNode): PoseDescriptor<TPose, TNode>;
+/** Identity geometry for `TPose extends Bounds`. Treats the pose as its
+ *  own bounds and remaps via affine scale against `src`/`dst`. */
+declare const RECT_POSE_DESCRIPTOR: PoseDescriptor<Bounds>;
+/** Identity geometry for `RotatedPose`: `RECT_POSE_DESCRIPTOR`'s projection,
+ *  with a required `rotation`. */
+declare const ROTATED_POSE_DESCRIPTOR: PoseDescriptor<RotatedPose>;
+/** The pose's visual bounds: its box expanded to cover the box as drawn
+ *  under its rotation and `transform`, so a turned or skewed shape reports
+ *  the extent of its ink. */
+declare function visualBoundsViaDescriptor<TPose>(pose: TPose, geometry: PoseDescriptor<TPose>): Bounds;
+/** Translate through `geometry.translate`, or via `remapBounds` onto a shifted
+ *  copy of the pose's own bounds when the descriptor has none. */
+declare function translatePoseViaDescriptor<TPose>(pose: TPose, dx: number, dy: number, geometry: PoseDescriptor<TPose>): TPose;
+
+export { type PoseDescriptor as P, RECT_POSE_DESCRIPTOR as R, ROTATED_POSE_DESCRIPTOR as a, type RotatedPose as b, poseDescriptorForNode as p, translatePoseViaDescriptor as t, visualBoundsViaDescriptor as v };

package/dist/renderer.d.ts

@@ -1,92 +1 @@
-export { C as CullRect, D as DrawCommand, E as Effect, G as GroupDrawCommand, I as IDENTITY_COLOR_MATRIX, a as ImageDrawCommand, b as ImageMinification, P as PathDrawCommand, R as RenderOptions, c as RenderSpan, d as RenderSpanStats, e as RenderStats, f as RenderTarget, S as SPRITE_STRIDE, g as ShaderDrawCommand, h as SolidPaint, i as SpriteSheet, j as SpritesDrawCommand, k as StrokeOptions, T as TextDrawCommand, W as WeaselRenderer, l as WeaselRendererOptions, m as blur, n as buildGradientRamp, o as cullDrawCommands, p as frameRect, r as registerEffect, q as releaseImageSource, t as tessellateStroke, v as viewToMat3, s as vignette } from './builtins-DPcdghtB.js';
-import { TextureHandle } from '@weasel-js/paint';
-export { CommandFill, CommandPaintUnits, CommandStroke, PosedFill, SolidFill, TextureHandle } from '@weasel-js/paint';
-export { G as GlMat3, P as ProgramSource, S as ShaderCompileError, a as ShaderProgramHandle, b as ShaderUniform, m as mat3, p as programSourceRegistry, r as registerProgram } from './registerProgram-T9S_PfAX.js';
-export { Mesh, TessellateOptions, tessellate } from '@weasel-js/geom/tessellate';
-export { RegisterFontOptions, canQueryLocalFonts, cssFontFamily, cssFontFamilyLoading, enableLocalFontOutlines, fontOutlineRegistry, fontRegistry, hasFontOutlines, isCanvasFont, listFontOutlines, loadFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
-import { Reflection } from '@weasel-js/registry';
-export { View as ViewLike } from '@weasel-js/routing';
-import '@weasel-js/geom';
-import '@weasel-js/text';
-
-/**
- * registerTexture — accepts an image source, assigns an opaque id, stores in
- * a module-level registry. Actual GL upload happens lazily at draw time in
- * drawShader() via GLTextureCache.upload (which is idempotent).
- *
- * Lifecycle: a texture lives until `unregisterTexture`. Each renderer frees
- * its own GL copy at the top of its next frame.
- *
- * Convention §9: this registry stores image data only — no per-renderer state.
- * Each WeaselRenderer's GLTextureCache does its own dedup by id and source.
- */
-
-/** A registered texture's image source, uploaded to GL lazily at first draw. */
-interface TextureEntry {
-    source: HTMLImageElement | ImageBitmap;
-}
-/** Every registered texture, keyed by its handle id. */
-declare const textureRegistry: Reflection<TextureEntry>;
-/**
- * Register an image for use as a shader texture uniform.
- *
- * Returns a TextureHandle whose `id` can be passed as a ShaderUniform value.
- * The handle is valid for the lifetime of the renderer it will be used with.
- *
- * @param image  The image to register. HTMLImageElement must be fully loaded.
- * @returns      Opaque TextureHandle.
- */
-declare function registerTexture(image: HTMLImageElement | ImageBitmap): TextureHandle;
-/**
- * Drop a registered texture. Every renderer that uploaded it frees its GL
- * copy at the top of its next frame; a draw command still holding the handle
- * then draws nothing and warns. The image itself is the caller's to release.
- *
- * @returns Whether the handle was registered.
- */
-declare function unregisterTexture(handle: TextureHandle): boolean;
-
-/**
- * On-screen glyph size (CSS px) at or above which a face with registered
- * outlines is drawn as geometry instead of sampled from a distance field.
- *
- * 48 is the dynamic tier's own `BAKE_SIZE`, which makes it the size at which
- * that tier stops being an interpolation and starts being a magnification:
- * `glyphRasterizer.ts` measures coverage error bottoming out *at* the bake
- * size and rising on both sides, and past a few times it the reconstructed
- * field shows the raster as contour wobble. The same number is a safe
- * crossing for the baked MSDF atlas, which is still crisp here — outlines are
- * exact, so switching early costs nothing but the tessellation, and the
- * hinting the atlas has and outlines don't stopped mattering well below this.
- */
-declare const OUTLINE_MIN_SCREEN_PX = 48;
-
-/**
- * Kit-supplied vertex shader for a full-screen effect pass.
- *
- * Distinct from `CUSTOM_VERT_SRC` on purpose. That one places its quad through
- * `u_bounds` and `u_proj`, so its `v_uv` runs top-down in *screen* space; an
- * effect samples a texture the scene was just rendered into, whose v axis runs
- * the other way. Passing `a_position` straight to `gl_Position` and `a_uv`
- * straight out keeps the two aligned — `QUAD_VERTICES` already carries
- * `a_uv == (a_position + 1) / 2` on both axes.
- *
- * PUBLIC CONTRACT — what every effect fragment shader may read:
- *
- *   in  vec2      v_uv           0..1 across the source texture
- *   uniform sampler2D u_source   what has been drawn so far
- *   uniform vec2  u_resolution   source size in device pixels
- *   uniform vec2  u_texel        1.0 / u_resolution — one texel step
- *
- * PREMULTIPLIED ALPHA: `u_source` holds premultiplied RGBA, because that is
- * what the scene blends into it. An effect that weights neighbouring samples
- * (a blur) is doing the right thing on premultiplied values; one that
- * manipulates rgb against a must premultiply its own output the same way the
- * custom-shader prelude requires.
- */
-declare const EFFECT_VERT_SRC = "#version 300 es\nin vec2 a_position;\nin vec2 a_uv;\nout vec2 v_uv;\n\nvoid main() {\n  v_uv = a_uv;\n  gl_Position = vec4(a_position, 0.0, 1.0);\n}\n";
-/** Uniforms the renderer sets on every effect pass. An effect must not
- *  redeclare them with different meanings; it may leave any of them out. */
-declare const EFFECT_KIT_UNIFORMS: readonly ["u_source", "u_resolution", "u_texel"];
-
-export { EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, OUTLINE_MIN_SCREEN_PX, type TextureEntry, registerTexture, textureRegistry, unregisterTexture };
+export { CommandPaint, CommandPaintUnits, CommandStroke, CullRect, DrawCommand, EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, Effect, GlMat3, GroupDrawCommand, IDENTITY_COLOR_MATRIX, ImageDrawCommand, ImageMinification, Mesh, OUTLINE_MIN_SCREEN_PX, PathDrawCommand, PosedPaint, ProgramSource, RegisterFontOptions, RenderOptions, RenderSpan, RenderSpanStats, RenderStats, RenderTarget, SPRITE_STRIDE, ShaderCompileError, ShaderDrawCommand, ShaderProgramHandle, ShaderUniform, SolidPaint, SpriteSheet, SpritesDrawCommand, StrokeOptions, TessellateOptions, TextDrawCommand, TextureEntry, TextureHandle, ViewLike, WeaselRenderer, WeaselRendererOptions, blur, buildGradientRamp, canQueryLocalFonts, cssFontFamily, cssFontFamilyLoading, cullDrawCommands, enableLocalFontOutlines, fontOutlineRegistry, fontRegistry, frameRect, hasFontOutlines, isCanvasFont, listFontOutlines, loadFontOutlines, mat3, outlineStatus, programSourceRegistry, registerCanvasFont, registerEffect, registerFont, registerFontOutlines, registerProgram, registerTexture, releaseImageSource, subscribeGlyphReady, tessellate, tessellateStroke, textureRegistry, unregisterCanvasFont, unregisterFontOutlines, unregisterTexture, viewToMat3, vignette } from '@weasel-js/renderer';

package/dist/renderer.js

@@ -1,19 +1,2 @@
-import { ShaderCompileError as e } from "./renderer/shaders/ShaderProgram.js";
-import { registerTexture as t, textureRegistry as n, unregisterTexture as r } from "./renderer/textures/registerTexture.js";
-import { releaseImageSource as i } from "./renderer/cache/GLImageCache.js";
-import { buildGradientRamp as a } from "./renderer/cache/GradientRampAtlas.js";
-import { mat3 as o } from "./renderer/math/mat3.js";
-import { IDENTITY_COLOR_MATRIX as s } from "./renderer/state/GroupState.js";
-import { programSourceRegistry as c, registerProgram as l } from "./renderer/shaders/registerProgram.js";
-import { EFFECT_KIT_UNIFORMS as u, EFFECT_VERT_SRC as d } from "./renderer/effects/effectPrelude.js";
-import { tessellateStroke as f } from "./features/paths/tessellate/stroke.js";
-import { OUTLINE_MIN_SCREEN_PX as p } from "./renderer/draw/text.js";
-import { SPRITE_STRIDE as m } from "./renderer/DrawCommand.js";
-import { WeaselRenderer as h } from "./renderer/WeaselRenderer.js";
-import { frameRect as g } from "./renderer/spriteSheet.js";
-import { viewToMat3 as _ } from "./renderer/math/viewToMat3.js";
-import { cullDrawCommands as v } from "./renderer/cullDrawCommands.js";
-import { registerEffect as y } from "./renderer/effects/types.js";
-import { blur as b, vignette as x } from "./renderer/effects/builtins.js";
-import { canQueryLocalFonts as S, cssFontFamily as C, cssFontFamilyLoading as w, enableLocalFontOutlines as T, fontOutlineRegistry as E, fontRegistry as D, hasFontOutlines as O, isCanvasFont as k, listFontOutlines as A, loadFontOutlines as j, outlineStatus as M, registerCanvasFont as N, registerFont as P, registerFontOutlines as F, subscribeGlyphReady as I, tessellate as L, unregisterCanvasFont as R, unregisterFontOutlines as z } from "./renderer/index.js";
-export { u as EFFECT_KIT_UNIFORMS, d as EFFECT_VERT_SRC, s as IDENTITY_COLOR_MATRIX, p as OUTLINE_MIN_SCREEN_PX, m as SPRITE_STRIDE, e as ShaderCompileError, h as WeaselRenderer, b as blur, a as buildGradientRamp, S as canQueryLocalFonts, C as cssFontFamily, w as cssFontFamilyLoading, v as cullDrawCommands, T as enableLocalFontOutlines, E as fontOutlineRegistry, D as fontRegistry, g as frameRect, O as hasFontOutlines, k as isCanvasFont, A as listFontOutlines, j as loadFontOutlines, o as mat3, M as outlineStatus, c as programSourceRegistry, N as registerCanvasFont, y as registerEffect, P as registerFont, F as registerFontOutlines, l as registerProgram, t as registerTexture, i as releaseImageSource, I as subscribeGlyphReady, L as tessellate, f as tessellateStroke, n as textureRegistry, R as unregisterCanvasFont, z as unregisterFontOutlines, r as unregisterTexture, _ as viewToMat3, x as vignette };
+import { EFFECT_KIT_UNIFORMS as e, EFFECT_VERT_SRC as t, IDENTITY_COLOR_MATRIX as n, OUTLINE_MIN_SCREEN_PX as r, SPRITE_STRIDE as i, ShaderCompileError as a, WeaselRenderer as o, blur as s, buildGradientRamp as c, canQueryLocalFonts as l, cssFontFamily as u, cssFontFamilyLoading as d, cullDrawCommands as f, enableLocalFontOutlines as p, fontOutlineRegistry as m, fontRegistry as h, frameRect as g, hasFontOutlines as _, isCanvasFont as v, listFontOutlines as y, loadFontOutlines as b, mat3 as x, outlineStatus as S, programSourceRegistry as C, registerCanvasFont as w, registerEffect as T, registerFont as E, registerFontOutlines as D, registerProgram as O, registerTexture as k, releaseImageSource as A, subscribeGlyphReady as j, tessellate as M, tessellateStroke as N, textureRegistry as P, unregisterCanvasFont as F, unregisterFontOutlines as I, unregisterTexture as L, viewToMat3 as R, vignette as z } from "@weasel-js/renderer";
+export { e as EFFECT_KIT_UNIFORMS, t as EFFECT_VERT_SRC, n as IDENTITY_COLOR_MATRIX, r as OUTLINE_MIN_SCREEN_PX, i as SPRITE_STRIDE, a as ShaderCompileError, o as WeaselRenderer, s as blur, c as buildGradientRamp, l as canQueryLocalFonts, u as cssFontFamily, d as cssFontFamilyLoading, f as cullDrawCommands, p as enableLocalFontOutlines, m as fontOutlineRegistry, h as fontRegistry, g as frameRect, _ as hasFontOutlines, v as isCanvasFont, y as listFontOutlines, b as loadFontOutlines, x as mat3, S as outlineStatus, C as programSourceRegistry, w as registerCanvasFont, T as registerEffect, E as registerFont, D as registerFontOutlines, O as registerProgram, k as registerTexture, A as releaseImageSource, j as subscribeGlyphReady, M as tessellate, N as tessellateStroke, P as textureRegistry, F as unregisterCanvasFont, I as unregisterFontOutlines, L as unregisterTexture, R as viewToMat3, z as vignette };