@weasel-js/core 1.9.3 → 1.10.0

package/dist/layout/arrivals.js.map

@@ -1 +1 @@
-{"version":3,"file":"arrivals.js","names":["layoutArrivalHandler","opts","getLayout","layouts","id","layoutOf","scene","d","AUTO_POSE_DESCRIPTOR","descriptorOf","poseDescriptorForNode","frame","pose","from","to","IDENTITY_POSE_COMPOSITION","runLayoutPass","arrivals","changed","departures","useLayoutArrivals","latest","useLatest","wired"],"sources":["../../src/layout/arrivals.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { runLayoutPass, type ResolvedLayoutFrame } from 'core/scene/layoutPass';\nimport type { NodeId, Scene, SceneArrivalHandler } from 'core/scene/types';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { IDENTITY_POSE_COMPOSITION, type PoseComposition } from 'features/groups/composePose';\nimport type { LayoutStrategy } from './types';\n\n/** Where a container's layout comes from: a map by container id, or a\n *  resolver. The same shape `<SceneCanvas layouts>` takes. */\nexport type LayoutSource<TPose> =\n  | Record<string, LayoutStrategy<TPose>>\n  | ((containerId: string) => LayoutStrategy<TPose> | null);\n\n/** Options for {@link layoutArrivalHandler} and {@link useLayoutArrivals}. */\nexport interface LayoutArrivalOptions<TPose> {\n  layouts: LayoutSource<TPose>;\n  /** How poses are read and resized. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** How a child's stored pose folds into its parent's frame. Default: the\n   *  absolute-pose model, where it does not. */\n  poseComposition?: PoseComposition<TPose>;\n}\n\n/**\n * A scene arrival handler over `layouts`: the scene's own layout pass\n * (`depart` for children that left a container, `arrive` for children that\n * joined it, `childPoses` for any other change to its children or size),\n * measured through the canvas's pose\n * descriptor and composition. A container that declares its own layout\n * (`ContainerNode.layout`) is arranged by that one; `layouts` fills in for\n * the rest.\n */\nexport function layoutArrivalHandler<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  opts: LayoutArrivalOptions<TPose>,\n): SceneArrivalHandler<TPose> {\n  const { layouts } = opts;\n  const getLayout = typeof layouts === 'function'\n    ? layouts\n    : (id: string) => layouts[id] ?? null;\n  const layoutOf = (id: NodeId) => scene.layoutOf(id) ?? getLayout(id as string);\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const descriptorOf = (id: NodeId) => poseDescriptorForNode(d, scene.get(id));\n  const frame: ResolvedLayoutFrame<TPose> = {\n    bounds: (pose, id) => descriptorOf(id).getBounds(pose),\n    remap: (pose, from, to, id) => descriptorOf(id).remapBounds(pose, from, to),\n    composition: (opts.poseComposition ?? IDENTITY_POSE_COMPOSITION) as PoseComposition<TPose>,\n  };\n  return (arrivals, changed, departures) =>\n    runLayoutPass(scene, layoutOf, arrivals, changed, frame, departures);\n}\n\n/**\n * Install {@link layoutArrivalHandler} on `scene` for as long as the calling\n * component is mounted. `<SceneCanvas layouts>` does this itself; call it\n * when a canvas is wired by hand through `sceneToAdapter({ layouts })`.\n */\nexport function useLayoutArrivals<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  opts: Partial<LayoutArrivalOptions<TPose>>,\n): void {\n  const latest = useLatest(opts);\n  const wired = opts.layouts !== undefined;\n  useEffect(() => {\n    if (!wired) return;\n    return scene.setArrivalHandler((arrivals, changed, departures) => {\n      const { layouts, poseDescriptor, poseComposition } = latest.current;\n      if (!layouts) return new Map();\n      return layoutArrivalHandler(scene, { layouts, poseDescriptor, poseComposition })(arrivals, changed, departures);\n    });\n  }, [scene, wired, latest]);\n}\n"],"mappings":";;;;;;;AAkCA,SAAgBA,EACd,GACA,GAC4B;CAC5B,IAAM,EAAE,eAAYC,GACdC,IAAY,OAAOC,KAAY,aACjCA,KACC,MAAeA,EAAQC,MAAO,MAC7BC,KAAY,MAAeC,EAAM,SAASF,CAAE,KAAKF,EAAUE,CAAY,GACvEG,IAAKN,EAAK,kBAAkBO,GAC5BC,KAAgB,MAAeC,EAAsBH,GAAGD,EAAM,IAAIF,CAAE,CAAC,GACrEO,IAAoC;EACxC,SAAS,GAAM,MAAOF,EAAaL,CAAE,CAAC,CAAC,UAAUQ,CAAI;EACrD,QAAQ,GAAM,GAAM,GAAI,MAAOH,EAAaL,CAAE,CAAC,CAAC,YAAYQ,GAAMC,GAAMC,CAAE;EAC1E,aAAcb,EAAK,mBAAmBc;CACxC;CACA,QAAQ,GAAU,GAAS,MACzBC,EAAcV,GAAOD,GAAUY,GAAUC,GAASP,GAAOQ,CAAU;AACvE;AAOA,SAAgBC,EACd,GACA,GACM;CACN,IAAMC,IAASC,EAAUrB,CAAI,GACvBsB,IAAQtB,EAAK,YAAY,KAAA;CAC/B,QAAgB;EACd,IAAKsB,GACL,OAAOjB,EAAM,mBAAmB,GAAU,GAAS,MAAe;GAChE,IAAM,EAAE,YAAS,mBAAgB,uBAAoBe,EAAO;GAE5D,OADKlB,IACEH,EAAqBM,GAAO;IAAE;IAAS;IAAgB;GAAgB,CAAC,CAAC,CAACW,GAAUC,GAASC,CAAU,oBADzF,IAAI,IAAI;EAE/B,CAAC;CACH,GAAG;EAACb;EAAOiB;EAAOF;CAAM,CAAC;AAC3B"}
+{"version":3,"file":"arrivals.js","names":["layoutArrivalHandler","opts","getLayout","layouts","id","layoutOf","scene","d","AUTO_POSE_DESCRIPTOR","descriptorOf","poseDescriptorForNode","frame","pose","from","to","runLayoutPass","arrivals","changed","departures","useLayoutArrivals","latest","useLatest","wired"],"sources":["../../src/layout/arrivals.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { runLayoutPass, type ResolvedLayoutFrame } from 'core/scene/layoutPass';\nimport type { NodeId, Scene, SceneArrivalHandler } from 'core/scene/types';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport type { LayoutStrategy } from './types';\n\n/** Where a container's layout comes from: a map by container id, or a\n *  resolver. The same shape `<SceneCanvas layouts>` takes. */\nexport type LayoutSource<TPose> =\n  | Record<string, LayoutStrategy<TPose>>\n  | ((containerId: string) => LayoutStrategy<TPose> | null);\n\n/** Options for {@link layoutArrivalHandler} and {@link useLayoutArrivals}. */\nexport interface LayoutArrivalOptions<TPose> {\n  layouts: LayoutSource<TPose>;\n  /** How poses are read and resized. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n}\n\n/**\n * A scene arrival handler over `layouts`: the scene's own layout pass\n * (`depart` for children that left a container, `arrive` for children that\n * joined it, `childPoses` for any other change to its children or size),\n * measured through the canvas's pose\n * descriptor. A container that declares its own layout\n * (`ContainerNode.layout`) is arranged by that one; `layouts` fills in for\n * the rest.\n */\nexport function layoutArrivalHandler<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  opts: LayoutArrivalOptions<TPose>,\n): SceneArrivalHandler<TPose> {\n  const { layouts } = opts;\n  const getLayout = typeof layouts === 'function'\n    ? layouts\n    : (id: string) => layouts[id] ?? null;\n  const layoutOf = (id: NodeId) => scene.layoutOf(id) ?? getLayout(id as string);\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const descriptorOf = (id: NodeId) => poseDescriptorForNode(d, scene.get(id));\n  const frame: ResolvedLayoutFrame<TPose> = {\n    bounds: (pose, id) => descriptorOf(id).getBounds(pose),\n    remap: (pose, from, to, id) => descriptorOf(id).remapBounds(pose, from, to),\n  };\n  return (arrivals, changed, departures) =>\n    runLayoutPass(scene, layoutOf, arrivals, changed, frame, departures);\n}\n\n/**\n * Install {@link layoutArrivalHandler} on `scene` for as long as the calling\n * component is mounted. `<SceneCanvas layouts>` does this itself; call it\n * when a canvas is wired by hand through `sceneToAdapter({ layouts })`.\n */\nexport function useLayoutArrivals<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  opts: Partial<LayoutArrivalOptions<TPose>>,\n): void {\n  const latest = useLatest(opts);\n  const wired = opts.layouts !== undefined;\n  useEffect(() => {\n    if (!wired) return;\n    return scene.setArrivalHandler((arrivals, changed, departures) => {\n      const { layouts, poseDescriptor } = latest.current;\n      if (!layouts) return new Map();\n      return layoutArrivalHandler(scene, { layouts, poseDescriptor })(arrivals, changed, departures);\n    });\n  }, [scene, wired, latest]);\n}\n"],"mappings":";;;;;;AA8BA,SAAgBA,EACd,GACA,GAC4B;CAC5B,IAAM,EAAE,eAAYC,GACdC,IAAY,OAAOC,KAAY,aACjCA,KACC,MAAeA,EAAQC,MAAO,MAC7BC,KAAY,MAAeC,EAAM,SAASF,CAAE,KAAKF,EAAUE,CAAY,GACvEG,IAAKN,EAAK,kBAAkBO,GAC5BC,KAAgB,MAAeC,EAAsBH,GAAGD,EAAM,IAAIF,CAAE,CAAC,GACrEO,IAAoC;EACxC,SAAS,GAAM,MAAOF,EAAaL,CAAE,CAAC,CAAC,UAAUQ,CAAI;EACrD,QAAQ,GAAM,GAAM,GAAI,MAAOH,EAAaL,CAAE,CAAC,CAAC,YAAYQ,GAAMC,GAAMC,CAAE;CAC5E;CACA,QAAQ,GAAU,GAAS,MACzBC,EAAcT,GAAOD,GAAUW,GAAUC,GAASN,GAAOO,CAAU;AACvE;AAOA,SAAgBC,EACd,GACA,GACM;CACN,IAAMC,IAASC,EAAUpB,CAAI,GACvBqB,IAAQrB,EAAK,YAAY,KAAA;CAC/B,QAAgB;EACd,IAAKqB,GACL,OAAOhB,EAAM,mBAAmB,GAAU,GAAS,MAAe;GAChE,IAAM,EAAE,YAAS,sBAAmBc,EAAO;GAE3C,OADKjB,IACEH,EAAqBM,GAAO;IAAE;IAAS;GAAe,CAAC,CAAC,CAACU,GAAUC,GAASC,CAAU,oBADxE,IAAI,IAAI;EAE/B,CAAC;CACH,GAAG;EAACZ;EAAOgB;EAAOF;CAAM,CAAC;AAC3B"}

package/dist/math-CYUjoyyU.d.ts

@@ -0,0 +1,33 @@
+import '@weasel-js/geom';
+import { Bounds } from '@weasel-js/routing';
+import { b as RotatedPose } from './poseDescriptor-Bqk-11Rl.js';
+import '@weasel-js/simulation';
+import './autoPoseDescriptor-DHg5KqaJ.js';
+
+/** AABB center of an unrotated rect — the canonical rotation pivot. */
+declare function aabbCenter(bounds: Bounds): {
+    x: number;
+    y: number;
+};
+/** Rotate `(px, py)` by `angle` (radians) around `(cx, cy)`. */
+declare function rotatePoint(px: number, py: number, cx: number, cy: number, angle: number): {
+    x: number;
+    y: number;
+};
+/** Four corners of an unrotated rect, in TL/TR/BR/BL order. */
+declare function rectCorners(bounds: Bounds): {
+    x: number;
+    y: number;
+}[];
+/** Four corners of a rotated rect (rotation around AABB center), in
+ *  TL/TR/BR/BL order. Useful for selection-overlay rendering. */
+declare function rotatedRectCorners(pose: RotatedPose): {
+    x: number;
+    y: number;
+}[];
+/** Hit-test a world point against a rotated rect (rotation around AABB
+ *  center). Standard pattern: invert the rotation and AABB-test in the
+ *  rect's local frame. */
+declare function pointInRotatedRect(pose: RotatedPose, worldX: number, worldY: number): boolean;
+
+export { aabbCenter as a, rotatePoint as b, rotatedRectCorners as c, pointInRotatedRect as p, rectCorners as r };

package/dist/math.d.ts

@@ -1,5 +1,7 @@
 export { DEFAULT_FLATTEN_TOLERANCE, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, Path, PathBuilder, PathFillRule, PolygonPath, RectPath, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pathCommandCoordCount, pointAlongPath, polygonFromPoints, polylineFromPoints, rectPath } from '@weasel-js/geom';
 export { Point2 as Vec2 } from '@weasel-js/routing';
-export { P as PoseDescriptor, t as translatePoseViaDescriptor } from './poseDescriptor-D-OH-tu5.js';
-export { a as Simulation, d as SimulationCore, e as SimulationForce, S as SimulationNode, f as SimulationOptions, h as createSimulation, i as rotatePoint } from './math-Drrw4ewZ.js';
-export { A as AUTO_POSE_DESCRIPTOR } from './autoPoseDescriptor-vCdt55xm.js';
+export { P as PoseDescriptor, t as translatePoseViaDescriptor } from './poseDescriptor-Bqk-11Rl.js';
+export { Simulation, SimulationCore, SimulationForce, SimulationNode, SimulationOptions, createSimulation } from '@weasel-js/simulation';
+export { A as AUTO_POSE_DESCRIPTOR } from './autoPoseDescriptor-DHg5KqaJ.js';
+export { b as rotatePoint } from './math-CYUjoyyU.js';
+import '@weasel-js/animator';

package/dist/math.js

@@ -1,6 +1,6 @@
-import { createSimulation as e } from "./features/simulation/createSimulation.js";
-import { translatePoseViaDescriptor as t } from "./core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as n } from "./interactions/actions/resize/autoPoseDescriptor.js";
-import { rotatePoint as r } from "./interactions/actions/rotate/geometry.js";
-import { DEFAULT_FLATTEN_TOLERANCE as i, PATH_C as a, PATH_CMD_LENGTHS as o, PATH_L as s, PATH_M as c, PATH_Q as l, PATH_Z as u, PathBuilder as d, flattenCubic as f, flattenCubicWithArcLen as p, flattenQuadratic as m, flattenQuadraticWithArcLen as h, pathCommandCoordCount as g, pointAlongPath as _, polygonFromPoints as v, polylineFromPoints as y, rectPath as b } from "@weasel-js/geom";
-export { n as AUTO_POSE_DESCRIPTOR, i as DEFAULT_FLATTEN_TOLERANCE, a as PATH_C, o as PATH_CMD_LENGTHS, s as PATH_L, c as PATH_M, l as PATH_Q, u as PATH_Z, d as PathBuilder, e as createSimulation, f as flattenCubic, p as flattenCubicWithArcLen, m as flattenQuadratic, h as flattenQuadraticWithArcLen, g as pathCommandCoordCount, _ as pointAlongPath, v as polygonFromPoints, y as polylineFromPoints, b as rectPath, r as rotatePoint, t as translatePoseViaDescriptor };
+import { translatePoseViaDescriptor as e } from "./core/geometry/poseDescriptor.js";
+import { AUTO_POSE_DESCRIPTOR as t } from "./core/geometry/autoPoseDescriptor.js";
+import { rotatePoint as n } from "./interactions/actions/rotate/geometry.js";
+import { DEFAULT_FLATTEN_TOLERANCE as r, PATH_C as i, PATH_CMD_LENGTHS as a, PATH_L as o, PATH_M as s, PATH_Q as c, PATH_Z as l, PathBuilder as u, flattenCubic as d, flattenCubicWithArcLen as f, flattenQuadratic as p, flattenQuadraticWithArcLen as m, pathCommandCoordCount as h, pointAlongPath as g, polygonFromPoints as _, polylineFromPoints as v, rectPath as y } from "@weasel-js/geom";
+import { createSimulation as b } from "@weasel-js/simulation";
+export { t as AUTO_POSE_DESCRIPTOR, r as DEFAULT_FLATTEN_TOLERANCE, i as PATH_C, a as PATH_CMD_LENGTHS, o as PATH_L, s as PATH_M, c as PATH_Q, l as PATH_Z, u as PathBuilder, b as createSimulation, d as flattenCubic, f as flattenCubicWithArcLen, p as flattenQuadratic, m as flattenQuadraticWithArcLen, h as pathCommandCoordCount, g as pointAlongPath, _ as polygonFromPoints, v as polylineFromPoints, y as rectPath, n as rotatePoint, e as translatePoseViaDescriptor };

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,15 +1,18 @@
-import { O as OriginProjection } from './originProjection-DEklpDc_.js';
-export { U as UseMoveOptions } from './originProjection-DEklpDc_.js';
-import { S as SnapTarget } from './types-A37hYkeR.js';
-import { M as MoveBehavior } from './types-B_9g6hMM.js';
+import { O as OriginProjection } from './originProjection-PPT88jZv.js';
+export { U as UseMoveOptions } from './originProjection-PPT88jZv.js';
+import { S as SnapTarget } from './types-CIKDwlsP.js';
+import { M as MoveBehavior } from './clone-2a5hVbBd.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 node into a container it hovers over
- * for `dwellMs`, reparenting it and taking the pose the container's layout
- * assigns.
+ * Move behavior that drops the dragged nodes into a container the pointer
+ * hovers over for `dwellMs`, reparenting each and giving it the slot
+ * `findTarget` answers for its id. A node `findTarget` has no slot for in
+ * that container rides along with the first, at its offset from it.
  *
  * The dwell is what keeps a drag that merely passes over a container from
  * being captured by it.
@@ -24,10 +27,10 @@ declare function snapToContainer<TPose>(args: {
 
 /**
  * Move behavior for a drag that is only meaningful near where it started:
- * release inside `radius` and the node returns to its original pose; release
- * outside it and the node either springs back anyway or is deleted, per
- * `onFreeRelease`. A deletion is recorded as an undoable op with paint order
- * preserved.
+ * release inside `radius` and every dragged node returns to its original
+ * pose; release outside it and they all either spring back anyway or are
+ * deleted, per `onFreeRelease`. The distance is the first dragged node's. A
+ * deletion is recorded as undoable ops with paint order preserved.
  */
 declare function snapBackOrDelete<TPose extends {
     x: number;

package/dist/{originProjection-DEklpDc_.d.ts → originProjection-PPT88jZv.d.ts}

@@ -1,4 +1,4 @@
-import { M as MoveBehavior } from './types-B_9g6hMM.js';
+import { M as MoveBehavior } from './clone-2a5hVbBd.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 };