@weasel-js/core 1.9.3 → 1.10.0

package/dist/{poseDescriptor-D-OH-tu5.d.ts → poseDescriptor-Bqk-11Rl.d.ts}

@@ -1,4 +1,5 @@
 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}`. */
@@ -6,16 +7,13 @@ interface RotatedPose extends Bounds {
     rotation: number;
 }
 /**
- * Bridges arbitrary `TPose` shapes into the resize hook's bounds-driven math.
- * The hook reads bounds via `getBounds`, runs anchor-relative math on those
- * bounds, then asks `remapBounds` to project the result back into TPose.
+ * 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)` is a single operation that 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. For rect-shaped poses the default geometry interprets the pose as
- * its own bounds; for Path or polygon poses the consumer supplies a
- * projection that knows how to read and rewrite the underlying geometry.
+ * `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;
@@ -30,34 +28,28 @@ interface PoseDescriptor<TPose, TNode = unknown> {
     /** 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 — descriptor
-     *  declares "this pose has no rotation." When supplied and non-zero,
-     *  `useResize` projects the drag delta into the leaf's local frame,
-     *  runs anchor math there, and translates the resulting pose so the
-     *  diagonally opposite world-space corner is pinned. */
+     *  (`getBounds(pose)` center). Default 0 when omitted. */
     getRotation?(pose: TPose): number;
-    /** True iff this pose shape can carry a rotation. Consulted by the
-     *  rotation affordance to decide whether to render the rotate cursor /
-     *  drag-band over a selection. When omitted, the kit assumes `true` for
-     *  back-compat — descriptors whose poses lack `x/y/width/height/rotation`
-     *  fields (e.g. polygon Paths) should return `false` so the affordance
-     *  hides instead of exposing a non-functional rotate cursor. */
+    /** 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 — a sphere and a box both posed by
-     * position/rotation/scale — 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}, at whichever site
-     * holds the node; the specialized descriptor then travels into the bounds and
-     * hit-test helpers in place of this one. Sites with only an id keep using the
-     * unspecialized descriptor, which is why this is optional on both ends.
+     * 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>;
 }
@@ -67,14 +59,12 @@ declare function poseDescriptorForNode<TPose, TNode>(descriptor: PoseDescriptor<
 /** 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`. Inherits rect-shape projection
- *  from `RECT_POSE_DESCRIPTOR` (the `RotatedPose extends Bounds`
- *  subtype lets the rect descriptor's methods apply directly; `remapBounds`
- *  preserves the `rotation` field via `...p` spread). Adds `getRotation` so
- *  `useResize` knows to take the rotation-aware math path. */
+/** 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 frame expanded to cover the rotated
- *  rectangle, so a turned shape reports the extent of its ink. */
+/** 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. */

package/dist/renderer.d.ts

@@ -1,91 +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, t as tessellateStroke, v as viewToMat3, q as vignette } from './builtins-C-VgUlWI.js';
-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-BMZRDgrh.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 { TextureHandle } from '@weasel-js/paint';
-export { TextureHandle } from '@weasel-js/paint';
-import { Reflection } from '@weasel-js/registry';
-export { View as ViewLike } from '@weasel-js/routing';
-import '@weasel-js/geom';
-import 'react';
-import '@weasel-js/history';
-import './types-A37hYkeR.js';
-import '@weasel-js/text';
-import './poseDescriptor-D-OH-tu5.js';
-import '@weasel-js/routing/react';
-import './types-B_9g6hMM.js';
-import '@weasel-js/cursor';
-import '@weasel-js/gestures';
-
-/**
- * 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: textures live for the renderer's lifetime. No unregister in v1.
- *
- * Convention §9: this registry stores image data only — no per-renderer state.
- * Each WeaselRenderer's GLTextureCache does its own dedup via has(id).
- */
-
-/** 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;
-
-/**
- * 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 };
+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,18 +1,2 @@
-import { ShaderCompileError as e } from "./renderer/shaders/ShaderProgram.js";
-import { buildGradientRamp as t } from "./renderer/cache/GradientRampAtlas.js";
-import { mat3 as n } from "./renderer/math/mat3.js";
-import { IDENTITY_COLOR_MATRIX as r } from "./renderer/state/GroupState.js";
-import { registerTexture as i, textureRegistry as a } from "./renderer/textures/registerTexture.js";
-import { programSourceRegistry as o, registerProgram as s } from "./renderer/shaders/registerProgram.js";
-import { SPRITE_STRIDE as c } from "./renderer/DrawCommand.js";
-import { tessellateStroke as l } from "./features/paths/tessellate/stroke.js";
-import { EFFECT_KIT_UNIFORMS as u, EFFECT_VERT_SRC as d } from "./renderer/effects/effectPrelude.js";
-import { OUTLINE_MIN_SCREEN_PX as f } from "./renderer/draw.js";
-import { WeaselRenderer as p } from "./renderer/WeaselRenderer.js";
-import { frameRect as m } from "./renderer/spriteSheet.js";
-import { viewToMat3 as h } from "./renderer/math/viewToMat3.js";
-import { cullDrawCommands as g } from "./renderer/cullDrawCommands.js";
-import { registerEffect as _ } from "./renderer/effects/types.js";
-import { blur as v, vignette as y } from "./renderer/effects/builtins.js";
-import { canQueryLocalFonts as b, cssFontFamily as x, cssFontFamilyLoading as S, enableLocalFontOutlines as C, fontOutlineRegistry as w, fontRegistry as T, hasFontOutlines as E, isCanvasFont as D, listFontOutlines as O, loadFontOutlines as k, outlineStatus as A, registerCanvasFont as j, registerFont as M, registerFontOutlines as N, subscribeGlyphReady as P, tessellate as F, unregisterCanvasFont as I, unregisterFontOutlines as L } from "./renderer/index.js";
-export { u as EFFECT_KIT_UNIFORMS, d as EFFECT_VERT_SRC, r as IDENTITY_COLOR_MATRIX, f as OUTLINE_MIN_SCREEN_PX, c as SPRITE_STRIDE, e as ShaderCompileError, p as WeaselRenderer, v as blur, t as buildGradientRamp, b as canQueryLocalFonts, x as cssFontFamily, S as cssFontFamilyLoading, g as cullDrawCommands, C as enableLocalFontOutlines, w as fontOutlineRegistry, T as fontRegistry, m as frameRect, E as hasFontOutlines, D as isCanvasFont, O as listFontOutlines, k as loadFontOutlines, n as mat3, A as outlineStatus, o as programSourceRegistry, j as registerCanvasFont, _ as registerEffect, M as registerFont, N as registerFontOutlines, s as registerProgram, i as registerTexture, P as subscribeGlyphReady, F as tessellate, l as tessellateStroke, a as textureRegistry, I as unregisterCanvasFont, L as unregisterFontOutlines, h as viewToMat3, y 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 };

package/dist/resize.d.ts

@@ -1,9 +1,10 @@
-export { C as CORNER_ANCHORS, a as CornerAnchor, b as CornerHandle, U as UseResizeOptions, c as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, h as hitCornerHandle } from './cornerHandles-BCrDp_mH.js';
-export { P as PoseDescriptor, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode } from './poseDescriptor-D-OH-tu5.js';
-import { B as BoundsConstraint } from './types-B_9g6hMM.js';
+export { C as CORNER_ANCHORS, a as CornerAnchor, b as CornerHandle, U as UseResizeOptions, c as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, h as hitCornerHandle } from './cornerHandles-BEshc4z3.js';
+export { P as PoseDescriptor, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode } from './poseDescriptor-Bqk-11Rl.js';
+import { B as BoundsConstraint } from './clone-2a5hVbBd.js';
 import { Bounds, ModifierState } from '@weasel-js/routing';
-export { A as AUTO_POSE_DESCRIPTOR, i as isPathLike, a as isRectPose } from './autoPoseDescriptor-vCdt55xm.js';
-import './types-A37hYkeR.js';
+export { A as AUTO_POSE_DESCRIPTOR, i as isPathLike, a as isRectPose } from './autoPoseDescriptor-DHg5KqaJ.js';
+import '@weasel-js/animator';
+import './types-CIKDwlsP.js';
 import '@weasel-js/history';
 import '@weasel-js/geom';
 
@@ -19,23 +20,10 @@ type ModKey = keyof ModifierState;
 /** Aspect-ratio lock: drag a corner/edge with `key` (default `'shift'`) held
  *  to keep the resized bounds at the start-pose's `width / height` ratio.
  *
- *  Strategy:
- *  - Compute the proposed deltas in width and height (signed, relative to
- *    origin). Whichever axis has the larger absolute delta "wins"; the other
- *    is recomputed from `(originW / originH) * winnerDelta`.
- *  - The opposite corner/edge stays anchored — for the corner case we infer
- *    the anchor from the proposed bounds; for an edge handle we resize the
- *    orthogonal axis symmetrically around the dragged edge's anchor (the
- *    handle's own line stays put, the orthogonal axis grows/shrinks centered
- *    on the un-dragged edge — see notes below).
- *  - No-op when the modifier is not held, when the origin has zero width or
- *    height (no defined ratio), or when the proposed pose hasn't moved.
- *
- *  Edge-handle handling: with `anchor.x !== 'free' && anchor.y === 'free'`
- *  (an `e` or `w` handle), only the width was driven by the pointer. We pick
- *  the new height as `width / ratio` and pin it to the un-dragged y axis by
- *  anchoring at the origin's top edge (`y` stays at `origin.y`). Symmetric
- *  for `n` / `s`.
+ *  On a corner handle the axis with the larger absolute delta wins and the
+ *  other follows from the ratio, with the opposite corner anchored. On an
+ *  edge handle the driven axis sets the other, which stays centered on the
+ *  origin. No-op when the origin has zero width or height.
  */
 declare function lockAspectWithModifier<TPose extends Bounds>(opts?: {
     key?: ModKey;

package/dist/resize.js

@@ -1,7 +1,7 @@
 import { RECT_POSE_DESCRIPTOR as e, ROTATED_POSE_DESCRIPTOR as t, poseDescriptorForNode as n } from "./core/geometry/poseDescriptor.js";
-import { AUTO_POSE_DESCRIPTOR as r, isPathLike as i, isRectPose as a } from "./interactions/actions/resize/autoPoseDescriptor.js";
-import { clampMinSize as o } from "./interactions/actions/resize/behaviors/clampMinSize.js";
-import { lockAspectWithModifier as s } from "./interactions/actions/resize/behaviors/lockAspect.js";
-import { DEFAULT_RESIZE_BEHAVIORS as c } from "./interactions/actions/resize/behaviors/index.js";
-import { CORNER_ANCHORS as l, cornerPoint as u, cornerResizeHandles as d, fixedCornerOf as f, hitCornerHandle as p } from "./interactions/actions/resize/cornerHandles.js";
-export { r as AUTO_POSE_DESCRIPTOR, l as CORNER_ANCHORS, c as DEFAULT_RESIZE_BEHAVIORS, e as RECT_POSE_DESCRIPTOR, t as ROTATED_POSE_DESCRIPTOR, o as clampMinSize, u as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, p as hitCornerHandle, i as isPathLike, a as isRectPose, s as lockAspectWithModifier, n as poseDescriptorForNode };
+import { AUTO_POSE_DESCRIPTOR as r, isPathLike as i, isRectPose as a } from "./core/geometry/autoPoseDescriptor.js";
+import { CORNER_ANCHORS as o, cornerPoint as s, cornerResizeHandles as c, fixedCornerOf as l, hitCornerHandle as u } from "./interactions/actions/resize/cornerHandles.js";
+import { clampMinSize as d } from "./interactions/actions/resize/behaviors/clampMinSize.js";
+import { lockAspectWithModifier as f } from "./interactions/actions/resize/behaviors/lockAspect.js";
+import { DEFAULT_RESIZE_BEHAVIORS as p } from "./interactions/actions/resize/behaviors/index.js";
+export { r as AUTO_POSE_DESCRIPTOR, o as CORNER_ANCHORS, p as DEFAULT_RESIZE_BEHAVIORS, e as RECT_POSE_DESCRIPTOR, t as ROTATED_POSE_DESCRIPTOR, d as clampMinSize, s as cornerPoint, c as cornerResizeHandles, l as fixedCornerOf, u as hitCornerHandle, i as isPathLike, a as isRectPose, f as lockAspectWithModifier, n as poseDescriptorForNode };

package/dist/style.css

@@ -1,2 +1,2 @@
-._numeric_zns9n_4{font-family:var(--wzl-font-numeric);font-variant-numeric:tabular-nums}._hud_1hv8c_3{z-index:10000;color:#e8e8e8;pointer-events:none;text-align:right;background:#000000b3;border-radius:4px;padding:6px 8px;font:11px/1.4 ui-monospace,SFMono-Regular,Menlo,monospace;position:fixed}._sized_1hv8c_17{min-width:120px;max-width:260px}._readings_1hv8c_22{grid-template-columns:auto auto;column-gap:8px;margin:0;display:grid}._readings_1hv8c_22 dt{text-align:left}._readings_1hv8c_22 dd{white-space:nowrap;margin:0}._muted_1hv8c_39{color:#888}._absent_1hv8c_44{color:#888;font-style:italic}._header_1hv8c_49{margin-bottom:2px}._list_1hv8c_53{flex-direction:column;gap:1px;margin:0;padding:0;list-style:none;display:flex}._item_1hv8c_62{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}._itemBest_1hv8c_68{font-weight:700}._row_1hv8c_72{white-space:nowrap;justify-content:flex-end;gap:8px;display:flex}._stack_1hv8c_79{flex-direction:column;align-items:flex-end;display:flex}
+:where(._surface_c2e145){width:var(--wzl-surface-width);height:var(--wzl-surface-height)}._numeric_25fd0b{font-family:var(--wzl-font-numeric);font-variant-numeric:tabular-nums}._hud_4467cb{z-index:var(--wzl-z-hud,900);color:#e8e8e8;padding:var(--wzl-space-3,6px) var(--wzl-space-4,8px);pointer-events:none;text-align:right;background:#000000b3;border-radius:4px;font:11px/1.4 ui-monospace,SFMono-Regular,Menlo,monospace;position:fixed}._sized_4467cb{min-width:120px;max-width:260px}._readings_4467cb{column-gap:var(--wzl-space-4,8px);grid-template-columns:auto auto;margin:0;display:grid}._readings_4467cb dt{text-align:left}._readings_4467cb dd{white-space:nowrap;margin:0}._muted_4467cb{color:#888}._absent_4467cb{color:#888;font-style:italic}._header_4467cb{margin-bottom:var(--wzl-space-1,2px)}._list_4467cb{flex-direction:column;gap:1px;margin:0;padding:0;list-style:none;display:flex}._item_4467cb{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}._itemBest_4467cb{font-weight:700}._row_4467cb{gap:var(--wzl-space-4,8px);white-space:nowrap;justify-content:flex-end;display:flex}._stack_4467cb{flex-direction:column;align-items:flex-end;display:flex}
 /*$vite$:1*/

package/dist/test-hook/install.js

@@ -1,12 +1,18 @@
 import { createTestHook as e } from "./createTestHook.js";
 //#region src/test-hook/install.ts
-function t(t) {
-	if (typeof window > "u" || typeof process < "u" && process.env.NODE_ENV === "production" || new URLSearchParams(window.location.search).get("test") !== "1") return null;
-	if (window.__weaselTest) return window.__weaselTest;
-	let n = e(t);
-	return window.__weaselTest = n, n;
+var t = [];
+function n(n) {
+	if (typeof window > "u" || typeof process < "u" && process.env.NODE_ENV === "production" || new URLSearchParams(window.location.search).get("test") !== "1" || window.__weaselTest && window.__weaselTest !== t[0]) return null;
+	let r = e(n);
+	return t.push(r), window.__weaselTest = t[0], r;
+}
+function r(e) {
+	let n = t.indexOf(e);
+	if (n < 0) return;
+	let r = typeof window < "u" && window.__weaselTest === e;
+	t.splice(n, 1), r && (t.length > 0 ? window.__weaselTest = t[0] : delete window.__weaselTest);
 }
 //#endregion
-export { t as installTestHookIfRequested };
+export { n as installTestHookIfRequested, r as releaseTestHook };
 
 //# sourceMappingURL=install.js.map

package/dist/test-hook/install.js.map

@@ -1 +1 @@
-{"version":3,"file":"install.js","names":["installTestHookIfRequested","hook","createTestHook","refs"],"sources":["../../src/test-hook/install.ts"],"sourcesContent":["// src/test-hook/install.ts\nimport { createTestHook } from './createTestHook';\nimport type { TestHookRefs, WeaselTestHook } from './types';\n\n/** Attach `window.__weaselTest` and return the hook iff\n *    - `process.env.NODE_ENV !== 'production'` (never in production consumer\n *      builds — paired with a call-site gate in SceneCanvas so the entire\n *      module DCEs out), AND\n *    - the URL contains `?test=1`.\n *  Otherwise returns null and does not touch `window`. */\nexport function installTestHookIfRequested(refs: TestHookRefs): WeaselTestHook | null {\n  if (typeof window === 'undefined') return null;\n  // Defense in depth: even if the call-site gate is bypassed, never expose\n  // the hook in production.\n  if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') return null;\n  const params = new URLSearchParams(window.location.search);\n  if (params.get('test') !== '1') return null;\n  // If a hook is already installed (HMR), keep it.\n  if (window.__weaselTest) return window.__weaselTest;\n  const hook = createTestHook(refs);\n  window.__weaselTest = hook;\n  return hook;\n}\n"],"mappings":";;AAUA,SAAgBA,EAA2B,GAA2C;CAMpF,IALI,OAAO,SAAW,OAGlB,OAAO,UAAY,OAAA,QAAA,IAAA,aAAyC,gBAE5D,IADe,gBAAgB,OAAO,SAAS,MAC/C,CAAA,CAAO,IAAI,MAAM,MAAM,KAAK,OAAO;CAEvC,IAAI,OAAO,cAAc,OAAO,OAAO;CACvC,IAAMC,IAAOC,EAAeC,CAAI;CAEhC,OADA,OAAO,eAAeF,GACfA;AACT"}
+{"version":3,"file":"install.js","names":["live","installTestHookIfRequested","hook","createTestHook","refs","releaseTestHook","i","owned"],"sources":["../../src/test-hook/install.ts"],"sourcesContent":["// src/test-hook/install.ts\nimport { createTestHook } from './createTestHook';\nimport type { TestHookRefs, WeaselTestHook } from './types';\n\n/** Hooks of the canvases mounted now, oldest first. `window.__weaselTest` is the first. */\nconst live: WeaselTestHook[] = [];\n\n/** Make a hook for this canvas and return it iff\n *    - `process.env.NODE_ENV !== 'production'` (never in production consumer\n *      builds — paired with a call-site gate in `useTestHook` so the entire\n *      module DCEs out), AND\n *    - the URL contains `?test=1`, AND\n *    - `window.__weaselTest` is not held by something other than a canvas.\n *  Otherwise returns null and does not touch `window`. `window.__weaselTest`\n *  answers for the earliest canvas still mounted; the caller hands its hook to\n *  `releaseTestHook` when it unmounts. */\nexport function installTestHookIfRequested(refs: TestHookRefs): WeaselTestHook | null {\n  if (typeof window === 'undefined') return null;\n  // Defense in depth: even if the call-site gate is bypassed, never expose\n  // the hook in production.\n  if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') return null;\n  const params = new URLSearchParams(window.location.search);\n  if (params.get('test') !== '1') return null;\n  if (window.__weaselTest && window.__weaselTest !== live[0]) return null;\n  const hook = createTestHook(refs);\n  live.push(hook);\n  window.__weaselTest = live[0];\n  return hook;\n}\n\n/** Drop `hook`; if it held `window.__weaselTest`, the next canvas's hook takes over. */\nexport function releaseTestHook(hook: WeaselTestHook): void {\n  const i = live.indexOf(hook);\n  if (i < 0) return;\n  const owned = typeof window !== 'undefined' && window.__weaselTest === hook;\n  live.splice(i, 1);\n  if (!owned) return;\n  if (live.length > 0) window.__weaselTest = live[0];\n  else delete window.__weaselTest;\n}\n"],"mappings":";;AAKA,IAAMA,IAAyB,CAAC;AAWhC,SAAgBC,EAA2B,GAA2C;CAOpF,IANI,OAAO,SAAW,OAGlB,OAAO,UAAY,OAAA,QAAA,IAAA,aAAyC,gBAE5D,IADe,gBAAgB,OAAO,SAAS,MAC/C,CAAA,CAAO,IAAI,MAAM,MAAM,OACvB,OAAO,gBAAgB,OAAO,iBAAiBD,EAAK,IAAI,OAAO;CACnE,IAAME,IAAOC,EAAeC,CAAI;CAGhC,OAFAJ,EAAK,KAAKE,CAAI,GACd,OAAO,eAAeF,EAAK,IACpBE;AACT;AAGA,SAAgBG,EAAgB,GAA4B;CAC1D,IAAMC,IAAIN,EAAK,QAAQE,CAAI;CAC3B,IAAII,IAAI,GAAG;CACX,IAAMC,IAAQ,OAAO,SAAW,OAAe,OAAO,iBAAiBL;CAEvE,AADAF,EAAK,OAAOM,GAAG,CAAC,GACXC,MACDP,EAAK,SAAS,IAAG,OAAO,eAAeA,EAAK,KAC3C,OAAO,OAAO;AACrB"}

package/dist/test-hook/useTestHook.js

@@ -0,0 +1,22 @@
+import { installTestHookIfRequested as e, releaseTestHook as t } from "./install.js";
+import { useEffect as n } from "react";
+import { useLatest as r } from "@weasel-js/react";
+//#region src/test-hook/useTestHook.ts
+function i(i) {
+	let a = r(i);
+	n(() => {
+		if (process.env.NODE_ENV !== "production") {
+			let n = e({
+				getScene: () => a.current.getScene(),
+				getSelectionIds: () => a.current.getSelectionIds(),
+				getView: () => a.current.getView(),
+				getActiveToolId: () => a.current.getActiveToolId()
+			});
+			if (n) return n._markReady(), () => t(n);
+		}
+	}, [a]);
+}
+//#endregion
+export { i as useTestHook };
+
+//# sourceMappingURL=useTestHook.js.map

package/dist/test-hook/useTestHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTestHook.js","names":["useTestHook","live","useLatest","read","hook","installTestHookIfRequested","releaseTestHook"],"sources":["../../src/test-hook/useTestHook.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { installTestHookIfRequested, releaseTestHook } from './install';\nimport type { TestHookRefs } from './types';\n\n/** The test hook for one canvas: opt-in via `?test=1`, never in a production\n *  build. `read` is called for the values of the last committed render. */\nexport function useTestHook(read: TestHookRefs): void {\n  const live = useLatest(read);\n  useEffect(() => {\n    // The gate must sit at this call site: a consumer's production build constant-folds\n    // `process.env.NODE_ENV` and drops this block, but a called function can't be\n    // tree-shaken even if its body is dead.\n    if (process.env.NODE_ENV !== 'production') {\n      const hook = installTestHookIfRequested({\n        getScene: () => live.current.getScene(),\n        getSelectionIds: () => live.current.getSelectionIds(),\n        getView: () => live.current.getView(),\n        getActiveToolId: () => live.current.getActiveToolId(),\n      });\n      if (hook) {\n        hook._markReady();\n        return () => releaseTestHook(hook);\n      }\n    }\n    return undefined;\n  }, [live]);\n}\n"],"mappings":";;;;AAOA,SAAgBA,EAAY,GAA0B;CACpD,IAAMC,IAAOC,EAAUC,CAAI;CAC3B,QAAgB;EAId,IAAA,QAAA,IAAA,aAA6B,cAAc;GACzC,IAAMC,IAAOC,EAA2B;IACtC,gBAAgBJ,EAAK,QAAQ,SAAS;IACtC,uBAAuBA,EAAK,QAAQ,gBAAgB;IACpD,eAAeA,EAAK,QAAQ,QAAQ;IACpC,uBAAuBA,EAAK,QAAQ,gBAAgB;GACtD,CAAC;GACD,IAAIG,GAEF,OADAA,EAAK,WAAW,SACHE,EAAgBF,CAAI;EAErC;CAEF,GAAG,CAACH,CAAI,CAAC;AACX"}

package/dist/test-seams-D0pyV3pR.d.ts

@@ -0,0 +1,149 @@
+import { TileKind, Paint, GradStop, TilePaint } from '@weasel-js/paint';
+import { Reflection } from '@weasel-js/registry';
+import { ComponentType } from 'react';
+import { PaintDrawKind } from '@weasel-js/renderer';
+import '@weasel-js/stroke/test-seams';
+
+/**
+ * `Paint`'s discriminant, open on the string the way `ChromeId` is: the
+ * kinds the kit ships, plus whatever a consumer registers.
+ */
+type PaintKind = 'solid' | 'linear-gradient' | 'radial-gradient' | 'conic-gradient' | TileKind | 'texture' | (string & {});
+/**
+ * A set of kinds an editor offers as one choice. Kinds sharing a family show
+ * as a single segment in a kind bar, named by the family, and the member is
+ * picked inside that segment's body. The built-in tiles and `texture` are the
+ * `patternFamily`.
+ */
+interface PaintKindFamily {
+    id: string;
+    label: string;
+    /** Glyph for the family's segment, resolved the way an entry's `icon` is. */
+    icon?: string;
+}
+/** What a registered kind's editor renders. `PaintInput` in `@weasel-js/ui`
+ *  is the control that mounts it. */
+interface PaintKindEditorProps {
+    value: Paint;
+    onInput?(next: Paint): void;
+    onChange(next: Paint): void;
+}
+/**
+ * One paint kind: the renderer's draw slots, plus what an editor and a
+ * serializer read.
+ *
+ * `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.
+ */
+interface PaintKindEntry extends PaintDrawKind {
+    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;
+    /** The family this kind is offered under; see {@link PaintKindFamily}. A
+     *  kind without one is its own segment. */
+    family?: PaintKindFamily;
+    /** 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): Paint;
+    /** The single color this paint shows, or `undefined` when it has none. */
+    colorOf(paint: Paint): 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: Paint): 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[]): Paint;
+    /**
+     * 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: Paint): string;
+}
+/**
+ * A consumer's own paint, typed as a `Paint`.
+ *
+ * `Paint` 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 `kind` and hands the whole object back to that
+ * kind's slots.
+ */
+declare function asPaint<T extends {
+    kind: string;
+}>(paint: T): Paint;
+
+/**
+ * The paint-kind registry — what makes `Paint` open. The built-in kinds
+ * are registered here at module load so an editor's kind bar can enumerate
+ * every kind through one list.
+ *
+ * Every entry is also handed to the renderer's own registry, which reads only
+ * its draw slots. A built-in kind has none: its render slot is a branch in the
+ * GL renderer and its serialize slot lives in `@weasel-js/svg`.
+ */
+
+/** The family the built-in tiles and `texture` are offered under. A consumer's
+ *  own pattern kind joins it by naming this as its `family`. */
+declare const patternFamily: PaintKindFamily;
+/** A tile paint seeded from a color. `units: 'bounds'` anchors the tile to the
+ *  node's box, so the texture travels with the shape. */
+declare function seedTile(kind: TileKind, color: string): TilePaint;
+/** Resolves with the entry for a kind that is loaded on first use. */
+type PaintKindLoader = () => Promise<PaintKindEntry>;
+/** Every registered paint kind, with the overrides each displaced. */
+declare const paintKindRegistry: Reflection<PaintKindEntry>;
+/** 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;
+/**
+ * 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. Call `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;
+/** 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;
+/** 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.
+ */
+declare function switchGradientKind(paint: Paint, kind: PaintKind): Paint | undefined;
+/** The registry entry for a paint, or `undefined` when its kind is unknown. */
+declare function paintKindOf(fill: Paint): PaintKindEntry | undefined;
+/** @internal Test helper — do not call from product code. */
+declare function _resetPaintKindsForTests(): void;
+
+export { type PaintKindEntry as P, _resetPaintKindsForTests as _, type PaintKind as a, type PaintKindEditorProps as b, type PaintKindFamily as c, type PaintKindLoader as d, asPaint as e, listPaintKinds as f, getPaintKind as g, paintKindRegistry as h, patternFamily as i, registerPaintKindLoader as j, switchGradientKind as k, listGradientKinds as l, paintKindOf as p, registerPaintKind as r, seedTile as s };

package/dist/test-seams.d.ts

@@ -1,6 +1,6 @@
-export { _ as _resetMarkersForTests, z as _resetPaintKindsForTests } from './test-seams-CuIxe0xY.js';
+export { _ as _resetPaintKindsForTests } from './test-seams-D0pyV3pR.js';
+export { _resetMarkersForTests } from '@weasel-js/stroke/test-seams';
 import '@weasel-js/paint';
-import 'react';
 import '@weasel-js/registry';
-import './registerProgram-BMZRDgrh.js';
-import '@weasel-js/geom';
+import 'react';
+import '@weasel-js/renderer';

package/dist/test-seams.js

@@ -1,3 +1,3 @@
-import { _resetPaintKindsForTests as e } from "./core/paintKinds.js";
-import { _resetMarkersForTests as t } from "./core/strokeMarkers.js";
+import { _resetPaintKindsForTests as e } from "./core/paint/paintKinds.js";
+import { _resetMarkersForTests as t } from "@weasel-js/stroke/test-seams";
 export { t as _resetMarkersForTests, e as _resetPaintKindsForTests };