@weasel-js/core 1.4.4 → 1.5.1

package/dist/{autoPoseDescriptor-DF1SnnSx.d.ts → pointSnapToGrid-CgcK2R_I.d.ts}

@@ -1,7 +1,5 @@
-import { c as ResizeAnchor, R as ResizePose, B as BoundsConstraint, P as PointSnapBehavior, d as PointSnapFrame, M as ModifierState } from './types-ei3UMl9R.js';
-import { B as Bounds, P as PoseProjection } from './geometry-6fCNhAux.js';
-import { D as DebugSink } from './types-BHK2dkMu.js';
-import { P as Path } from './path-JEV2c5If.js';
+import { ResizeAnchor, Bounds, DebugSink, ModifierState } from '@weasel-js/routing';
+import { B as BoundsConstraint, P as PointSnapBehavior, a as PointSnapFrame } from './types-BHGdrOcu.js';
 
 /** Corner resize-handle: world-space center plus the anchor that pins the opposite corner during resize. */
 interface CornerHandle {
@@ -72,14 +70,13 @@ declare function fixedCornerOf(bounds: Bounds, anchor: ResizeAnchor): {
  *  Consumers should import from here directly; `resize.ts` re-exports the
  *  same symbol for back-compat. */
 
-/** Options for the `resize` action: how the pose projects to and from a
- *  bounding box, and the constraints applied to that box during the drag. */
+/** Options for the `resize` action: the constraints applied to the dragged
+ *  bounding box, and how a gesture expands a group into its leaves. */
 interface UseResizeOptions<TPose> {
-    /** Behaviors are rect-typed: they read/write `{x,y,width,height}`. When
-     *  `TPose` is non-rect, pass `geometry` to project pose↔bounds; behaviors
-     *  in that case are typed `never` because none in the kit's library would
-     *  understand the pose shape. */
-    behaviors?: TPose extends ResizePose ? BoundsConstraint<TPose>[] : never;
+    /** Behaviors are rect-typed: they read/write `{x,y,width,height}`. For a
+     *  non-rect `TPose`, constraints are typed `never`; the pose descriptor
+     *  comes from `<SceneCanvas poseDescriptor>`. */
+    behaviors?: TPose extends Bounds ? BoundsConstraint<TPose>[] : never;
     resizeLabel?: string;
     /** Reserved; resize is never transient in practice. Ignored. */
     transient?: boolean;
@@ -99,16 +96,12 @@ interface UseResizeOptions<TPose> {
      *
      *  Called once at `start()`. Returning `[]` aborts the gesture cleanly. */
     expandIds?: (ids: string[]) => string[];
-    /** Projection from `TPose` to bounds and back. Defaults to rect identity
-     *  when `TPose extends ResizePose`. Required for non-rect TPose (Path,
-     *  polygon, etc.). */
-    geometry?: PoseProjection<TPose>;
     /** Behaviors that operate on world-space anchor points. Fire after
      *  `behaviors[]` (bounds-frame). Each behavior receives a `PointSnapContext`
      *  with world-space frame points and returns at most one `PointSnapResult`;
      *  the hook back-solves the local pose so the chosen frame's world point
      *  lands on the snap target. First non-null result wins. */
-    pointSnapBehaviors?: TPose extends ResizePose ? PointSnapBehavior<TPose>[] : never;
+    pointSnapBehaviors?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never;
     /** Optional debug sink. When supplied, records corner-handle positions +
      *  circular hitboxes when the gesture starts (covers the on-screen
      *  handles for the resized target). Tree-shakes via optional-chain
@@ -132,24 +125,10 @@ interface UseResizeOptions<TPose> {
  *  corner, the fixed corner, or the center, per `frame` — to a grid, moving
  *  the whole pose by the same delta. Unlike the bounds-level `snapToGrid`,
  *  this preserves the node's dimensions. */
-declare function pointSnapToGrid<TPose extends ResizePose>(args: {
+declare function pointSnapToGrid<TPose extends Bounds>(args: {
     spacing: number;
     frame?: PointSnapFrame;
     bypassKey?: keyof ModifierState;
 }): PointSnapBehavior<TPose>;
 
-/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for
- *  callers that need to fork between `pathPoseDescriptor` and
- *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire `geometry`
- *  explicitly. */
-declare function isPathLike(p: unknown): p is Path;
-/** Per-call dispatch: if the pose looks like a Path, route to
- *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing
- *  demos with Path TPose to wire `geometry={pathPoseDescriptor}` explicitly.
- *  `getRotation` surfaces a `pose.rotation` field on non-Path poses so demos
- *  using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to wire
- *  `geometry={ROTATED_POSE_DESCRIPTOR}` just to get rotated selection chrome
- *  and rotation-aware corner hit-tests. */
-declare const AUTO_POSE_DESCRIPTOR: PoseProjection<unknown>;
-
-export { AUTO_POSE_DESCRIPTOR as A, CORNER_ANCHORS as C, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, cornerPoint as c, cornerResizeHandles as d, type CornerEdge as e, fixedCornerOf as f, hitCornerHandle as h, isPathLike as i, pointSnapToGrid as p };
+export { CORNER_ANCHORS as C, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, cornerPoint as c, cornerResizeHandles as d, type CornerEdge as e, fixedCornerOf as f, hitCornerHandle as h, pointSnapToGrid as p };

package/dist/poseDescriptor-PgfVKfa0.d.ts

@@ -0,0 +1,134 @@
+import { Bounds } from '@weasel-js/routing';
+
+/**
+ * Path data model. Vector-graphics primitive used kit-wide as the canonical
+ * shape (replacing per-shape ad-hoc poses). SVG-style command stream so we
+ * cover lines, polygons, beziers, and multi-contour shapes (think the inner
+ * hole of an "O") under one type.
+ *
+ * Storage: command codes in a `Uint8Array`, parameters in a `Float32Array`.
+ * Each command consumes a fixed number of float coords from the parameter
+ * array; the parser walks both arrays in lockstep. This keeps interaction
+ * hot loops monomorphic and keeps GC pressure low under heavy edits.
+ *
+ * Two path subtypes are distinguished at the type level so common-case
+ * machinery (selection AABBs, area-select intersection, hit-testing rect
+ * silhouettes) can short-circuit on `RectPath` without paying the polygon
+ * kernel cost. Polymorphic kernels accept either via the `Path` union and
+ * dispatch on `kind`.
+ */
+
+/** Fill rule used by polygon path hit-testing and `ctx.fill()`. */
+type PathFillRule = 'nonzero' | 'evenodd';
+/**
+ * Polygon path with arbitrary contours and optional bezier segments.
+ * Multi-contour: each `M` opens a new subpath; `Z` closes the current one.
+ * Open subpaths (no `Z`) render as polylines and don't contribute to fills.
+ */
+interface PolygonPath {
+    kind: 'polygon';
+    commands: Uint8Array;
+    coords: Float32Array;
+    fillRule: PathFillRule;
+}
+/**
+ * Axis-aligned rectangle. Fast path for the (very common) case where the
+ * shape is just a rect — preserves O(1) bounds and hit-test, avoids the
+ * polygon kernel entirely. Promote to `PolygonPath` only when the shape
+ * grows beyond what a rect can express.
+ */
+interface RectPath {
+    kind: 'rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Canonical path shape — either an axis-aligned rect (fast path) or a polygon command stream. */
+type Path = PolygonPath | RectPath;
+
+/** `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 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.
+ *
+ * `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.
+ */
+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;
+    /** True iff any portion of the pose's geometry intersects `rect`. Optional
+     *  — when omitted, area-select and similar callers test against `getBounds`
+     *  AABB (looser, but correct for axis-aligned rect poses). */
+    intersectsRect?(pose: TPose, rect: Bounds): boolean;
+    /** 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;
+    /** 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. */
+    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. */
+    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.
+     */
+    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`. 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. */
+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. */
+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, type Path as a, ROTATED_POSE_DESCRIPTOR as b, type PolygonPath as c, type RotatedPose as d, type RectPath as e, type PathFillRule as f, poseDescriptorForNode as p, translatePoseViaDescriptor as t, visualBoundsViaDescriptor as v };

package/dist/renderer.d.ts

@@ -1,11 +1,16 @@
-import { M as Mesh } from './builtins-BXFBXegF.js';
-export { I as IDENTITY_COLOR_MATRIX, a as ImageMinification, R as RenderTarget, S as ShaderCompileError, b as SpriteSheet, c as StrokeOptions, V as ViewLike, W as WeaselRenderer, d as WeaselRendererOptions, e as blur, f as buildGradientRamp, g as frameRect, t as tessellateStroke, v as viewToMat3, h as vignette } from './builtins-BXFBXegF.js';
-export { D as DrawCommand, E as Effect, G as GroupDrawCommand, I as ImageDrawCommand, M as Mat3, P as PathDrawCommand, S as SPRITE_STRIDE, a as ShaderDrawCommand, b as ShaderProgramHandle, c as ShaderUniform, d as SolidPaint, e as SpritesDrawCommand, T as TextDrawCommand, m as mat3, r as registerEffect, f as registerProgram } from './DrawCommand-CD-ug3d9.js';
-import { P as Path } from './path-JEV2c5If.js';
+import { M as Mesh } from './depSchema-BubKMv-2.js';
+export { C as CullRect, D as DrawCommand, E as Effect, G as GroupDrawCommand, I as IDENTITY_COLOR_MATRIX, a as ImageDrawCommand, b as ImageMinification, c as Mat3, P as PathDrawCommand, R as RenderTarget, S as SPRITE_STRIDE, d as ShaderCompileError, e as ShaderDrawCommand, f as ShaderProgramHandle, g as ShaderUniform, h as SolidPaint, i as SpriteSheet, j as SpritesDrawCommand, k as StrokeOptions, T as TextDrawCommand, V as ViewLike, W as WeaselRenderer, l as WeaselRendererOptions, m as blur, n as buildGradientRamp, o as cullDrawCommands, p as frameRect, q as mat3, r as registerEffect, s as registerProgram, t as tessellateStroke, v as viewToMat3, u as vignette } from './depSchema-BubKMv-2.js';
+import { a as Path } from './poseDescriptor-PgfVKfa0.js';
 export { canQueryLocalFonts, enableLocalFontOutlines, hasFontOutlines, isCanvasFont, listFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
 import { TextureHandle } from '@weasel-js/paint';
 export { TextureHandle } from '@weasel-js/paint';
 import '@weasel-js/text';
+import '@weasel-js/history';
+import '@weasel-js/routing';
+import './types-BdaK9PcP.js';
+import '@weasel-js/routing/react';
+import './types-BHGdrOcu.js';
+import '@weasel-js/geom';
 
 /**
  * registerTexture — accepts an image source, assigns an opaque id, stores in

package/dist/renderer.js

@@ -1,8 +1,9 @@
-export { EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, IDENTITY_COLOR_MATRIX, OUTLINE_MIN_SCREEN_PX, SPRITE_STRIDE, ShaderCompileError, WeaselRenderer, blur, buildGradientRamp, canQueryLocalFonts, enableLocalFontOutlines, frameRect, hasFontOutlines, isCanvasFont, listFontOutlines, mat3, outlineStatus, registerCanvasFont, registerEffect, registerFont, registerFontOutlines, registerProgram, subscribeGlyphReady, tessellate, tessellateStroke, unregisterCanvasFont, unregisterFontOutlines, viewToMat3, vignette } from './chunk-R3AWPTLZ.js';
-import './chunk-BL65SHCX.js';
-import './chunk-2VXGHUVL.js';
-import './chunk-PRGBGMH3.js';
-import './chunk-WPM42WJP.js';
+export { EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, IDENTITY_COLOR_MATRIX, OUTLINE_MIN_SCREEN_PX, SPRITE_STRIDE, ShaderCompileError, WeaselRenderer, blur, buildGradientRamp, canQueryLocalFonts, cullDrawCommands, enableLocalFontOutlines, frameRect, hasFontOutlines, isCanvasFont, listFontOutlines, mat3, outlineStatus, registerCanvasFont, registerEffect, registerFont, registerFontOutlines, registerProgram, subscribeGlyphReady, tessellate, tessellateStroke, unregisterCanvasFont, unregisterFontOutlines, viewToMat3, vignette } from './chunk-GREL4MVO.js';
+import './chunk-LXJDWBEL.js';
+import './chunk-P6MGECVO.js';
+import './chunk-XXQ6FLCJ.js';
+import './chunk-HAGOFNP5.js';
+import './chunk-3LPQ2XZG.js';
 import './chunk-T3UQ3F6R.js';
 import './chunk-D4AAWR64.js';
 import './chunk-DOBSZOPR.js';

package/dist/resize.d.ts

@@ -1,17 +1,16 @@
-export { A as AUTO_POSE_DESCRIPTOR, 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, i as isPathLike, p as pointSnapToGrid } from './autoPoseDescriptor-DF1SnnSx.js';
-export { P as PoseProjection, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR } from './geometry-6fCNhAux.js';
-import { R as ResizePose, B as BoundsConstraint, M as ModifierState } from './types-ei3UMl9R.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, p as pointSnapToGrid } from './pointSnapToGrid-CgcK2R_I.js';
+export { P as PoseDescriptor, R as RECT_POSE_DESCRIPTOR, b as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode } from './poseDescriptor-PgfVKfa0.js';
+import { B as BoundsConstraint } from './types-BHGdrOcu.js';
+import { Bounds, ModifierState, View } from '@weasel-js/routing';
+export { A as AUTO_POSE_DESCRIPTOR, i as isPathLike, a as isRectPose } from './autoPoseDescriptor-Dr6CwNZK.js';
 import { G as Guide } from './types-D2tTKEU0.js';
-import { V as View } from './view-DSQgxBJB.js';
-import './types-BHK2dkMu.js';
-import './path-JEV2c5If.js';
 import '@weasel-js/history';
-import './types-DEALFt5F.js';
+import './types-BdaK9PcP.js';
 
 /** Resize constraint that stops a node shrinking past a minimum. The anchored
  *  edge stays put, so clamping pushes the dragged edge back rather than moving
  *  the node. */
-declare function clampMinSize<TPose extends ResizePose>(args: {
+declare function clampMinSize<TPose extends Bounds>(args: {
     minWidth: number;
     minHeight: number;
 }): BoundsConstraint<TPose>;
@@ -38,7 +37,7 @@ type ModKey$2 = keyof ModifierState;
  *  anchoring at the origin's top edge (`y` stays at `origin.y`). Symmetric
  *  for `n` / `s`.
  */
-declare function lockAspectWithModifier<TPose extends ResizePose>(opts?: {
+declare function lockAspectWithModifier<TPose extends Bounds>(opts?: {
     key?: ModKey$2;
 }): BoundsConstraint<TPose>;
 
@@ -47,7 +46,7 @@ type ModKey$1 = keyof ModifierState;
  *  anchored ones where they are. By default a node already smaller than one
  *  grid cell on an axis is left unsnapped on that axis, so it stays resizable
  *  at sub-grid sizes. */
-declare function snapToGrid<TPose extends ResizePose>(args: {
+declare function snapToGrid<TPose extends Bounds>(args: {
     spacing: number;
     bypassKey?: ModKey$1;
     suspendBelowDim?: boolean;
@@ -75,12 +74,12 @@ interface SnapToGuidesResizeArgs {
  * edge — east when `anchor.x === 'min'` (west pinned), west when `'max'`.
  * Likewise on Y for horizontal guides.
  */
-declare function snapToGuides<TPose extends ResizePose>(args: SnapToGuidesResizeArgs): BoundsConstraint<TPose>;
+declare function snapToGuides<TPose extends Bounds>(args: SnapToGuidesResizeArgs): BoundsConstraint<TPose>;
 
 /** The kit's standard resize behaviors, applied when a consumer doesn't
  *  supply its own list: shift-drag locks the start pose's aspect ratio.
  *  Pass an explicit `behaviors: []` to opt out. Stateless, so one shared
  *  frozen instance is safe across every gesture. */
-declare const DEFAULT_RESIZE_BEHAVIORS: readonly BoundsConstraint<ResizePose>[];
+declare const DEFAULT_RESIZE_BEHAVIORS: readonly BoundsConstraint<Bounds>[];
 
 export { DEFAULT_RESIZE_BEHAVIORS, clampMinSize, lockAspectWithModifier, snapToGrid, snapToGuides };

package/dist/resize.js

@@ -1,4 +1,5 @@
-export { CORNER_ANCHORS, DEFAULT_RESIZE_BEHAVIORS, clampMinSize, cornerPoint, cornerResizeHandles, fixedCornerOf, hitCornerHandle, lockAspectWithModifier, pointSnapToGrid, snapToGrid, snapToGuides } from './chunk-PRGBGMH3.js';
-export { AUTO_POSE_DESCRIPTOR, RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR, isPathLike } from './chunk-WPM42WJP.js';
+export { CORNER_ANCHORS, DEFAULT_RESIZE_BEHAVIORS, clampMinSize, cornerPoint, cornerResizeHandles, fixedCornerOf, hitCornerHandle, lockAspectWithModifier, pointSnapToGrid, snapToGrid, snapToGuides } from './chunk-XXQ6FLCJ.js';
+import './chunk-HAGOFNP5.js';
+export { AUTO_POSE_DESCRIPTOR, RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR, isPathLike, isRectPose, poseDescriptorForNode } from './chunk-3LPQ2XZG.js';
 //# sourceMappingURL=resize.js.map
 //# sourceMappingURL=resize.js.map

package/dist/routing.d.ts

@@ -1,142 +1 @@
-import { ParsedModifiers, GestureName, GestureSpec } from '@weasel-js/gestures';
-export { ChannelRef, DescribeRouteOptions, GESTURE_DESCRIPTORS, GestureArgSpec, GestureDescriptor, GestureName, ModRequirement, ModifierKey, ParsedModifiers, ParsedRoute, PhaseAtom, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, RouteDescriptionPart, RouteFieldName, RouteTermLabel, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, parseRoute } from '@weasel-js/gestures';
-import { T as Tool } from './registry-BY-wI9gm.js';
-import './types-bcc7jcUy.js';
-import '@weasel-js/history';
-import './path-JEV2c5If.js';
-import './types-ei3UMl9R.js';
-import './types-DEALFt5F.js';
-import './view-DSQgxBJB.js';
-import '@weasel-js/modes';
-import 'react';
-import './DrawCommand-CD-ug3d9.js';
-import '@weasel-js/paint';
-import '@weasel-js/text';
-import './geometry-6fCNhAux.js';
-import '@weasel-js/cursor';
-import 'react/jsx-runtime';
-import './types-BHK2dkMu.js';
-import '@weasel-js/geom';
-
-/**
- * One row in the route registry — a single `GestureBinding` on one tool,
- * flattened into the route grammar's vocabulary so the inspector, the
- * conflict checker, and `describeRoute` can all read the same shape.
- *
- * Multiple rows can share (gesture, arg, target, modifiers) if different tools
- * declare them; consumers walk the list and group client-side.
- */
-interface RegistryEntry {
-    toolId: string;
-    /** Which phase the binding's `phase` spec restricts it to. `'any'` when it
-     *  declares none, declares `'*'`, or declares an atom list whose atoms
-     *  don't agree on one phase — such a binding fires in either phase, and
-     *  reporting it as `'initial'` made it collide with genuinely-initial
-     *  bindings in `findConflicts`' bucket key. */
-    phase: 'initial' | 'engaged' | 'any';
-    /** Structured v3 modifier requirements. Empty object = "no modifiers
-     *  held" (the strict default). */
-    modifiers: ParsedModifiers;
-    gesture: GestureName;
-    /** Resolved arg value for arg-bearing gestures (wheel direction,
-     *  key name, multiTouchTap fingers). Undefined for gestures whose
-     *  descriptor has no `arg`. */
-    arg: string | undefined;
-    /** Target class for hit-testing gestures. `undefined` when the descriptor
-     *  has `hasTarget: false` or the spec declares no target;
-     *  {@link PREDICATE_TARGET} when the spec uses a `kindOf` predicate, which
-     *  the route grammar has no notation for. */
-    target: string | undefined;
-    /** The action this binding fires. */
-    actionId: string;
-    /** The `GestureSpec` this row was flattened from, by reference. Reflection
-     *  consumers that need something the grammar doesn't capture — the
-     *  specificity tuple, a `kindOf` predicate identity — read it here rather
-     *  than re-walking `Tool.bindings`. */
-    spec: GestureSpec;
-}
-/**
- * Stand-in target for a `{ kindOf }` predicate spec.
- *
- * The route grammar can name target *classes* (`empty`, `selected-body`,
- * `kind:rect`) but not arbitrary predicates, so three distinct select-tool
- * bindings all render as this one token. Narrowing it would mean giving the
- * grammar a way to describe a function, which is a real design question and
- * not one this reflection layer should answer by inventing syntax.
- */
-declare const PREDICATE_TARGET = "predicate";
-/**
- * Flatten every tool's `bindings` into route-registry rows.
- *
- * This was `buildActionRegistry`, and it walked `ToolDef.initial` /
- * `.engaged` phase tables — the grammar that no longer exists. It was also
- * blind to `Tool.bindings` the entire time the two lived side by side, which
- * is why the inspector under-reported select by more than half. The rename
- * fixes a second thing: it never had anything to do with the Actions
- * Registry, and reading `buildActionRegistry` next to `ActionsRegistry`
- * suggested otherwise.
- */
-declare function buildRouteRegistry(tools: readonly Tool<unknown>[]): RegistryEntry[];
-/** The route-grammar gesture a `GestureSpec.kind` routes as, or `undefined`
- *  for kinds the grammar has no name for. */
-declare function routeGestureForSpecKind(kind: GestureSpec['kind']): GestureName | undefined;
-/**
- * Every route string one `GestureSpec` declares, in route-grammar notation.
- *
- * One string per arg alternative — a spec bound to `['ArrowUp','ArrowDown']`
- * yields two routes, because each is separately conflictable and separately
- * readable. Returns `[]` for spec kinds the grammar can't name.
- *
- * This is the display counterpart to {@link buildRouteRegistry}: same
- * projection of a spec onto the grammar, rendered as text instead of as a
- * conflict-checkable row.
- */
-declare function routesForSpec(spec: GestureSpec): readonly string[];
-
-/** Two or more tools declare the same exact (phase, gesture, arg, target,
- *  modifiers) tuple — the dispatcher's slot precedence picks one
- *  arbitrarily (well, deterministically by slot order, but the author
- *  probably didn't intend the duplication). */
-interface Conflict {
-    phase: 'initial' | 'engaged' | 'any';
-    gesture: GestureName;
-    arg: string | undefined;
-    target: string | undefined;
-    modifiers: ParsedModifiers;
-    /** All tool ids that registered the same tuple. At least 2 by
-     *  construction. Order matches the input tools[] order. */
-    toolIds: string[];
-}
-/** Detect exact-tuple overlaps across a tool registration set.
- *
- *  Intentionally NOT flagged:
- *  - Broad vs. narrow targets (e.g. an untargeted `click` alongside
- *    `click` on `empty`) — the dispatcher's specificity ordering resolves
- *    those cleanly, and the broad one is usually the intended fallback.
- *  - Different modifier requirements on the same target — they fire on
- *    different inputs.
- *  - A binding whose action declines via `enabled()` so a lower-priority
- *    one can take the gesture. Detecting that intent would mean evaluating
- *    the action; consumers can suppress known-intentional compositions in
- *    their UI layer.
- *
- *  - Two `{ kindOf }` predicate targets. The route grammar renders every
- *    predicate as the single token {@link PREDICATE_TARGET}, so bucketing on
- *    the rendered target alone reported select's `resize` / `rotate` / `move`
- *    drags — three genuinely different predicates — as a three-way conflict.
- *    Predicate entries bucket by function identity instead, which means two
- *    *separately written but equivalent* predicates go unflagged. That's the
- *    right way to be wrong here: this check has to be silent when nothing is
- *    wrong or nobody will keep it on.
- *
- *  Note that two bindings sharing a tuple on the SAME tool are now possible
- *  (bindings are an array, where phase tables were objects with unique
- *  keys) — so a conflict may name one tool twice.
- *
- *  This is the raw same-tuple detector. Feeding it a whole tool *registry*
- *  over-reports, because registry tools take turns in the active slot and
- *  can't collide with each other — see {@link findScopedConflicts}.
- */
-declare function findConflicts(tools: readonly Tool<unknown>[]): Conflict[];
-
-export { type Conflict, PREDICATE_TARGET, type RegistryEntry, buildRouteRegistry, findConflicts, routeGestureForSpecKind, routesForSpec };
+export { ChannelRef, Conflict, DescribeRouteOptions, GESTURE_DESCRIPTORS, GestureArgSpec, GestureDescriptor, GestureName, ModRequirement, ModifierKey, PREDICATE_TARGET, ParsedModifiers, ParsedRoute, PhaseAtom, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, RegistryEntry, RouteDescriptionPart, RouteFieldName, RouteTermLabel, buildRouteRegistry, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, findConflicts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, parseRoute, reportRouteConflicts, routeGestureForSpecKind, routesForSpec } from '@weasel-js/routing';

package/dist/routing.js

@@ -1,3 +1,3 @@
-export { GESTURE_DESCRIPTORS, PREDICATE_TARGET, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, buildRouteRegistry, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, findConflicts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, parseRoute, routeGestureForSpecKind, routesForSpec } from './chunk-BL65SHCX.js';
+export { GESTURE_DESCRIPTORS, PREDICATE_TARGET, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, buildRouteRegistry, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, findConflicts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, parseRoute, reportRouteConflicts, routeGestureForSpecKind, routesForSpec } from '@weasel-js/routing';
 //# sourceMappingURL=routing.js.map
 //# sourceMappingURL=routing.js.map

package/dist/routing.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"routing.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"routing.js","sourcesContent":[]}

package/dist/{types-ei3UMl9R.d.ts → types-BHGdrOcu.d.ts}

@@ -1,20 +1,6 @@
 import { Op } from '@weasel-js/history';
-import { S as SnapTarget, M as MoveAdapter, I as InsertAdapter } from './types-DEALFt5F.js';
-
-/**
- * Snapshot of modifier-key state at gesture dispatch.
- *
- * Lives in core rather than beside the gesture types that produce it because
- * `core/selection/chromeState.ts` reads it, and core may not import from
- * `interactions/`. Re-exported from `interactions/gestures/types.ts`, which
- * is still where gesture code names it.
- */
-interface ModifierState {
-    alt: boolean;
-    shift: boolean;
-    meta: boolean;
-    ctrl: boolean;
-}
+import { S as SnapTarget, M as MoveAdapter, I as InsertAdapter } from './types-BdaK9PcP.js';
+import { Bounds, ModifierState, ResizeAnchor } from '@weasel-js/routing';
 
 /** Pointer position in both world and client coords. */
 interface PointerState {
@@ -130,31 +116,20 @@ type BehaviorMoveResult<TPose> = BehaviorResult<TPose>;
  *  `useMove`) and return a `BehaviorResult` shaping it (or, legacy, an
  *  override pose run through the back-compat shim). */
 type MoveBehavior<TPose> = ActionBehavior<TPose, GroupTransform, BehaviorResult<TPose>>;
-/** Which corner/edge of the rect stays fixed during a resize. */
-type ResizeAnchor = {
-    x: 'min' | 'max' | 'free';
-    y: 'min' | 'max' | 'free';
-};
-/** Minimum rect-shaped pose required by the resize machinery. */
-interface ResizePose {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
+
 /** Per-frame proposed resize: pose plus the anchor pinning the opposite corner. */
-interface ResizeProposed<TPose extends ResizePose> {
+interface ResizeProposed<TPose extends Bounds> {
     pose: TPose;
     anchor: ResizeAnchor;
 }
 /** Per-frame result a `BoundsConstraint.onMove` can return to override the proposed pose. */
-interface ResizeMoveResult<TPose extends ResizePose> {
+interface ResizeMoveResult<TPose extends Bounds> {
     pose?: TPose;
 }
 /** A bounds-frame constraint plugged into `useResize` / `resizeAction`.
  *  Reads/writes `{x,y,width,height}` and can override the proposed pose
  *  on each frame (e.g. lock-aspect, clamp-min-size, snap-to-grid). */
-type BoundsConstraint<TPose extends ResizePose> = ActionBehavior<TPose, ResizeProposed<TPose>, ResizeMoveResult<TPose>>;
+type BoundsConstraint<TPose extends Bounds> = ActionBehavior<TPose, ResizeProposed<TPose>, ResizeMoveResult<TPose>>;
 /** Live overlay state exposed by `useResize` for rendering the in-flight resize ghost. */
 interface ResizeOverlay<TPose> {
     id: string;
@@ -168,11 +143,7 @@ interface ResizeOverlay<TPose> {
      *  resizes. */
     leafPoses?: Map<string, TPose>;
 }
-/** ResizePose extended with a rotation angle (radians). Pivot is the AABB
- *  center of the unrotated `{x, y, width, height}`. */
-interface RotatedPose extends ResizePose {
-    rotation: number;
-}
+
 /** Per-frame proposed rotation: pose plus the candidate angle in radians. */
 interface RotateProposed<TPose> {
     pose: TPose;
@@ -203,7 +174,7 @@ interface InsertPoint {
 interface InsertProposed<TPose> {
     start: InsertPoint;
     current: InsertPoint;
-    bounds: ResizePose;
+    bounds: Bounds;
     pose: TPose;
 }
 /** Per-frame result an `InsertBehavior.onMove` can return to override the start/current points. */
@@ -221,7 +192,7 @@ interface InsertOverlay<TPose> {
     start: InsertPoint;
     current: InsertPoint;
     /** Axis-aligned bounding rect derived from `start`/`current`. */
-    bounds: ResizePose;
+    bounds: Bounds;
     /** TPose constructed from `bounds` via the hook's `posefromBounds`. */
     pose: TPose;
 }
@@ -276,7 +247,7 @@ type PointSnapFrame = 'dragged-corner' | 'fixed-corner' | 'center' | 'origin';
  *  `draggedCorner` and `fixedCorner` are `null` for edge drags
  *  (`anchor.x === 'free'` or `anchor.y === 'free'`). `center` and
  *  `origin` are always present. */
-interface PointSnapContext<TPose extends ResizePose> {
+interface PointSnapContext<TPose extends Bounds> {
     draggedCorner: {
         worldX: number;
         worldY: number;
@@ -305,7 +276,7 @@ interface PointSnapResult {
     worldY: number;
 }
 /** A point-snap behavior plugged into `useResize`'s `pointSnapBehaviors`. */
-interface PointSnapBehavior<TPose extends ResizePose> {
+interface PointSnapBehavior<TPose extends Bounds> {
     id?: string;
     onMove(ctx: PointSnapContext<TPose>): PointSnapResult | null | undefined;
 }
@@ -336,4 +307,4 @@ interface CloneBehavior {
     }) => Op[];
 }
 
-export type { ActionBehavior as A, BoundsConstraint as B, CloneBehavior as C, RotateOverlay as D, RotateProposed as E, GestureContext as G, InsertBehavior as I, LassoSelectBehavior as L, ModifierState as M, PointSnapBehavior as P, ResizePose as R, SnapStrategy as S, RotatedPose as a, MoveBehavior as b, ResizeAnchor as c, PointSnapFrame as d, RotateBehavior as e, AreaSelectOverlay as f, BehaviorMoveResult as g, BehaviorResult as h, CloneLayer as i, ClonePose as j, GroupTransform as k, InsertMoveResult as l, InsertOverlay as m, InsertPoint as n, InsertProposed as o, LassoSelectMoveResult as p, LassoSelectOverlay as q, LassoSelectPose as r, LassoSelectProposed as s, PointSnapContext as t, PointSnapResult as u, PointerState as v, ResizeMoveResult as w, ResizeOverlay as x, ResizeProposed as y, RotateMoveResult as z };
+export type { ActionBehavior as A, BoundsConstraint as B, CloneBehavior as C, GestureContext as G, InsertBehavior as I, LassoSelectBehavior as L, MoveBehavior as M, PointSnapBehavior as P, RotateBehavior as R, SnapStrategy as S, PointSnapFrame as a, AreaSelectOverlay as b, BehaviorMoveResult as c, BehaviorResult as d, CloneLayer as e, ClonePose as f, GroupTransform as g, InsertMoveResult as h, InsertOverlay as i, InsertPoint as j, InsertProposed as k, LassoSelectMoveResult as l, LassoSelectOverlay as m, LassoSelectPose as n, LassoSelectProposed as o, PointSnapContext as p, PointSnapResult as q, PointerState as r, ResizeMoveResult as s, ResizeOverlay as t, ResizeProposed as u, RotateMoveResult as v, RotateOverlay as w, RotateProposed as x };

package/dist/{types-DEALFt5F.d.ts → types-BdaK9PcP.d.ts}

@@ -133,9 +133,10 @@ interface SnapTarget<TPose = unknown> {
  *
  * **Pose semantics:** `getPose` / `setPose` work in **local** coordinates —
  * relative to the node's direct parent (or world, for root-parented nodes).
- * The kit composes world poses via `composeWorldPose` when it needs to
- * render, hit-test, or snap. For the common axis-aligned rect pose,
- * `composeRectPose` / `decomposeRectPose` ship as the canonical compose pair.
+ * `getWorldPose` is the composed reading, and is what the render walk, picking
+ * and chrome consume. For the common axis-aligned rect pose, `composeRectPose`
+ * (translation only) and `composeRigidPose` (a container's pose is a frame, so
+ * its rotation reaches its children) ship as the two canonical strategies.
  */
 interface SceneAdapter<TNode extends {
     id: string;
@@ -145,6 +146,11 @@ interface SceneAdapter<TNode extends {
     getSelection(): string[];
     hitTest(worldX: number, worldY: number): string | null;
     getPose(id: string): TPose;
+    /** The node's pose in world coordinates, with every ancestor's frame folded
+     *  in. Equal to `getPose` under the absolute-pose model; anything reasoning
+     *  about where a node actually is — picking, chrome, snapping, export —
+     *  wants this rather than `getPose`. */
+    getWorldPose?(id: string): TPose;
     getParent(id: string): string | null;
     setPose(id: string, pose: TPose): void;
     setParent(id: string, parentId: string | null): void;
@@ -376,4 +382,4 @@ interface OrderedAdapter {
     setChildOrder?(parentId: string | null, ids: string[]): void;
 }
 
-export type { AreaSelectAdapter as A, ClipboardSnapshot as C, DropTarget as D, InsertAdapter as I, LayoutStrategy as L, MoveAdapter as M, OrderedAdapter as O, RotateAdapter as R, SnapTarget as S, SceneAdapter as a, LassoHitMode as b, LassoSelectAdapter as c, ResizeAdapter as d, LayerEnumerableAdapter as e, LayoutSnap as f, ContainerBounds as g, LayoutChild as h, LayoutContainer as i, LayoutDragged as j };
+export type { AreaSelectAdapter as A, ClipboardSnapshot as C, DropTarget as D, InsertAdapter as I, LayoutStrategy as L, MoveAdapter as M, OrderedAdapter as O, ResizeAdapter as R, SnapTarget as S, SceneAdapter as a, LassoHitMode as b, LassoSelectAdapter as c, RotateAdapter as d, LayerEnumerableAdapter as e, LayoutSnap as f, ContainerBounds as g, LayoutChild as h, LayoutContainer as i, LayoutDragged as j };