@weasel-js/core 1.0.0 → 1.0.2

package/dist/renderer.d.ts

@@ -109,6 +109,8 @@ declare class GLMeshCache {
     private readonly gl;
     private readonly aPositionLoc;
     private readonly map;
+    /** Meshes this context has drawn at least once; see `uploadRecurring`. */
+    private readonly seen;
     private readonly finalizer;
     private readonly pendingDeletes;
     /** Transient resources allocated this frame; freed at end of render(). */
@@ -123,6 +125,15 @@ declare class GLMeshCache {
      * and the FinalizationRegistry, so transient meshes never wait on GC.
      */
     uploadTransient(mesh: Mesh): GLMeshHandle;
+    /**
+     * Upload a Mesh that may or may not recur across frames. Its first sight in
+     * *this* context takes `uploadTransient`; every later one takes the
+     * persistent handle. One transient upload to find out is cheaper than
+     * stranding a persistent VAO on a mesh that never returns, whose release
+     * would wait on GC. The transient upload does not populate the persistent
+     * map, so steady-state reuse begins on the third frame.
+     */
+    uploadRecurring(mesh: Mesh): GLMeshHandle;
     /**
      * Free all transient resources allocated since the last call. Called by
      * the renderer at the end of each `render()`. Safe under context loss.
@@ -233,6 +244,56 @@ declare class GroupState {
     pop(): void;
 }
 
+/**
+ * Growable vertex staging for consecutive solid-fill geometry.
+ *
+ * Geometry only: `draw.ts` owns when a run starts, what breaks it, and the
+ * uniforms the flush draws under. Colors ride the vertices (the batch program
+ * is `pathFillVColor` with `u_color` left at white) because shapes in a run
+ * differ in color and a merged draw has one set of uniforms — and so does the
+ * model transform, applied here rather than uploaded, so that shapes under
+ * different transforms still share a draw.
+ */
+
+declare class SolidBatch {
+    private readonly gl;
+    private readonly vao;
+    private readonly vbo;
+    private readonly ibo;
+    private verts;
+    private idx;
+    private nVerts;
+    private nIdx;
+    /** What the GPU buffers are currently sized for. */
+    private vboVerts;
+    private iboIdx;
+    constructor(gl: WebGL2RenderingContext, prog: ShaderProgram);
+    get length(): number;
+    /** Whether staging `vertices` more would put the run past the per-flush cap. */
+    wouldOverflow(vertices: number): boolean;
+    /**
+     * Append one rect's four corners through `m`, all carrying `rgba` (straight
+     * alpha). An affine maps a rect to a parallelogram, so two triangles still
+     * cover it and the batch draws at `u_model` identity.
+     */
+    pushRect(x: number, y: number, w: number, h: number, m: Mat3, r: number, g: number, b: number, a: number): void;
+    /**
+     * Append a tessellated mesh through `m`, all vertices carrying `rgba`. The
+     * mesh's own indices are rebased onto the staged vertices, which is why the
+     * index buffer is uploaded per flush rather than written once.
+     */
+    pushMesh(mesh: Mesh, m: Mat3, r: number, g: number, b: number, a: number): void;
+    /** Upload the staged geometry and bind the batch VAO. Returns the index
+     *  count for the caller's `drawElements`. */
+    uploadAndBind(): number;
+    reset(): void;
+    dispose(): void;
+    /** Grow the CPU arrays so `vertices` / `indices` more fit. */
+    private reserve;
+    /** Size both GPU buffers for at least what is staged, doubling to amortize. */
+    private growGpu;
+}
+
 interface WeaselRendererOptions {
     gl?: WebGL2RenderingContext;
     canvas?: HTMLCanvasElement;
@@ -281,10 +342,7 @@ declare class WeaselRenderer {
     private programRegistry;
     private quadVbo;
     private quadIbo;
-    /** Shared rect-fill geometry: 4 verts × 2 floats (dynamic), 6-index static IBO. */
-    private rectVao;
-    private rectVbo;
-    private rectIbo;
+    private solidBatch;
     private readonly groupState;
     private widthCss;
     private heightCss;
@@ -301,10 +359,6 @@ declare class WeaselRenderer {
      *  calls and `registerProgram()` calls. */
     private disposed;
     constructor(opts: WeaselRendererOptions);
-    /** Allocate the shared rect VAO + dynamic VBO (4 verts × 2 floats) + static
-     *  IBO (6 indices). drawRectFast bufferSubData's the 4 corner coords each
-     *  draw, avoiding per-rect buffer allocation in animated demos. */
-    private uploadRectGeometry;
     private uploadQuadGeometry;
     /**
      * Compile a consumer-registered shader program against this renderer's GL context.
@@ -363,6 +417,7 @@ declare class WeaselRenderer {
     /** @internal */ _gl(): WebGL2RenderingContext;
     /** @internal */ _pathFill(): ShaderProgram;
     /** @internal */ _pathFillVColor(): ShaderProgram;
+    /** @internal */ _solidBatch(): SolidBatch;
     /** @internal */ _textSdf(): ShaderProgram;
     /** @internal */ _textSdfR8(): ShaderProgram;
     /** @internal */ _imageFill(): ShaderProgram;

package/dist/renderer.js

@@ -1,5 +1,5 @@
-export { IDENTITY_COLOR_MATRIX, OUTLINE_MIN_SCREEN_PX, ShaderCompileError, WeaselRenderer, buildGradientRamp, canQueryLocalFonts, enableLocalFontOutlines, hasFontOutlines, isCanvasFont, listFontOutlines, mat3, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, registerProgram, subscribeGlyphReady, tessellate, tessellateStroke, unregisterCanvasFont, unregisterFontOutlines, viewToMat3 } from './chunk-D2C6K6FO.js';
-import './chunk-DCIU3SRK.js';
+export { IDENTITY_COLOR_MATRIX, OUTLINE_MIN_SCREEN_PX, ShaderCompileError, WeaselRenderer, buildGradientRamp, canQueryLocalFonts, enableLocalFontOutlines, hasFontOutlines, isCanvasFont, listFontOutlines, mat3, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, registerProgram, subscribeGlyphReady, tessellate, tessellateStroke, unregisterCanvasFont, unregisterFontOutlines, viewToMat3 } from './chunk-PI56ORHE.js';
+import './chunk-W2WB4352.js';
 import './chunk-UB6A6L77.js';
 import './chunk-Z3KNFTTS.js';
 import './chunk-6SHZHXXR.js';
@@ -8,6 +8,5 @@ import './chunk-UGFFCMQP.js';
 import './chunk-BHVYVFGV.js';
 import './chunk-GVCNT7UH.js';
 export { registerTexture } from './chunk-IO5Z75X4.js';
-import './chunk-PZ5AY32C.js';
 //# sourceMappingURL=renderer.js.map
 //# sourceMappingURL=renderer.js.map

package/dist/resize.d.ts

@@ -1,11 +1,11 @@
-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-BuDZWBrL.js';
-export { P as PoseProjection, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR } from './geometry-DVeZ2i-c.js';
-import { R as ResizePose, B as BoundsConstraint, M as ModifierState } from './types-BhJJ2OCM.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-Bj4r_lEQ.js';
+export { P as PoseProjection, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR } from './geometry-CnISZ11w.js';
+import { R as ResizePose, B as BoundsConstraint, M as ModifierState } from './types-Ct4n0Z38.js';
 import { G as Guide } from './types-D2tTKEU0.js';
 import { V as View } from './view-DSQgxBJB.js';
-import './types-BJ8_cyT7.js';
+import './types-Dtxe7jTS.js';
 import '@weasel-js/history';
-import './types-B_-khFM0.js';
+import './types-Ch0Goo-j.js';
 
 declare function clampMinSize<TPose extends ResizePose>(args: {
     minWidth: number;

package/dist/resize.js

@@ -1,5 +1,4 @@
 export { CORNER_ANCHORS, DEFAULT_RESIZE_BEHAVIORS, clampMinSize, cornerPoint, cornerResizeHandles, fixedCornerOf, hitCornerHandle, lockAspectWithModifier, pointSnapToGrid, snapToGrid, snapToGuides } from './chunk-Z3KNFTTS.js';
 export { RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR } from './chunk-6SHZHXXR.js';
-import './chunk-PZ5AY32C.js';
 //# sourceMappingURL=resize.js.map
 //# sourceMappingURL=resize.js.map

package/dist/routing.d.ts

@@ -1,16 +1,115 @@
-export { bd as Conflict, be as PREDICATE_TARGET, bf as RegistryEntry, bg as ToolDef, m as ToolKeybinding, bh as ToolScopes, bi as ViewportToolDef, bj as buildRouteRegistry, bk as defineTool, bl as defineViewportTool, bm as findConflicts, bn as findScopedConflicts, bo as formatConflict, bp as reportRouteConflicts } from './index-ChM3ZJ2v.js';
+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 './types-DUpI7Apc.js';
+import { T as Tool } from './registry-BQL4oyTg.js';
+import './types-Kh_osAq9.js';
 import '@weasel-js/history';
 import './path-B6MMiodD.js';
-import './types-BhJJ2OCM.js';
-import './types-B_-khFM0.js';
+import './types-Ct4n0Z38.js';
+import './types-Ch0Goo-j.js';
 import './view-DSQgxBJB.js';
 import '@weasel-js/modes';
 import 'react';
-import './geometry-DVeZ2i-c.js';
+import './geometry-CnISZ11w.js';
 import './paint-types-CnLIzqq1.js';
 import './DrawCommand-DCmiNkBj.js';
 import 'react/jsx-runtime';
+import './types-Dtxe7jTS.js';
 import '@weasel-js/geom';
-import './types-BJ8_cyT7.js';
+
+/**
+ * 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;
+}
+/**
+ * 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[];
+
+/** 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, type RegistryEntry, buildRouteRegistry, findConflicts };

package/dist/routing.js

@@ -1,4 +1,3 @@
-export { GESTURE_DESCRIPTORS, PREDICATE_TARGET, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, buildRouteRegistry, canonicalModifiers, collapseShiftPairs, defineTool, defineViewportTool, describeRoute, describeRouteParts, findConflicts, findScopedConflicts, formatConflict, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, parseRoute, reportRouteConflicts } from './chunk-DCIU3SRK.js';
-import './chunk-PZ5AY32C.js';
+export { GESTURE_DESCRIPTORS, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, buildRouteRegistry, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, findConflicts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, parseRoute } from './chunk-W2WB4352.js';
 //# sourceMappingURL=routing.js.map
 //# sourceMappingURL=routing.js.map

package/dist/{types-B_-khFM0.d.ts → types-Ch0Goo-j.d.ts}

@@ -66,6 +66,12 @@ interface LayoutStrategy<TPose> {
         x: number;
         y: number;
     }): boolean;
+    /** Optional: reject a drag before any drop-target work happens. A type-aware
+     *  container (a palette that only takes swatches, say) returns `false` and
+     *  the drag falls through to whatever container is under it next. When
+     *  absent, every drag is considered — rejection is still possible later, by
+     *  `snap.pickTarget` returning null. */
+    acceptsDrop?(container: LayoutContainer, dragged: LayoutDragged<TPose>): boolean;
 }
 
 /**
@@ -134,6 +140,12 @@ interface MoveAdapter<TNode extends {
      *  targeting (`getLayout` present), nested-hit collapse
      *  (`pickTopMostHit`), and group-pose composition. Flat scenes may omit. */
     getParent?(id: string): string | null;
+    /** Optional paint depth, read by `pickTopMostHit` to resolve two *siblings*
+     *  whose bodies both cover the pointer. Without it the hit list's own order
+     *  decides, which is right for a back-to-front walk and wrong for anything
+     *  else. See `PickTopMostHitAdapter` for the `compareZ` alternative. */
+    getZIndex?(id: string): number | null | undefined;
+    compareZ?(a: string, b: string): number;
     setPose(id: string, pose: TPose): void;
     /** Optional. Used only by reparent ops (e.g. drag-into-container drops via
      *  layout strategies). Flat scenes that never reparent may omit. */

package/dist/{types-BhJJ2OCM.d.ts → types-Ct4n0Z38.d.ts}

@@ -1,5 +1,5 @@
 import { Op } from '@weasel-js/history';
-import { S as SnapTarget, M as MoveAdapter, I as InsertAdapter } from './types-B_-khFM0.js';
+import { S as SnapTarget, M as MoveAdapter, I as InsertAdapter } from './types-Ch0Goo-j.js';
 
 /**
  * Snapshot of modifier-key state at gesture dispatch.

package/dist/{types-BJ8_cyT7.d.ts → types-Dtxe7jTS.d.ts}

@@ -16,6 +16,9 @@ interface DebugConfig {
     fps?: boolean;
     /** Optional per-feature color overrides; falls back to the default theme. */
     theme?: Partial<DebugTheme>;
+    /** Optional per-feature line-width / dash overrides; falls back to
+     *  {@link DEFAULT_DEBUG_STROKES}. */
+    strokes?: Partial<DebugStrokes>;
 }
 type DebugFeature = 'hitboxes' | 'handles' | 'bounds' | 'origins' | 'snap' | 'layers' | 'ids' | 'fps';
 interface DebugTheme {
@@ -33,6 +36,22 @@ interface DebugTheme {
     fpsText: string;
     fpsTextBg: string;
 }
+/** Line width and dash pattern for one stroked debug feature. An empty (or
+ *  omitted) `dash` is a solid line. */
+interface DebugStroke {
+    width: number;
+    dash?: readonly number[];
+}
+/** The stroked half of the debug overlay's appearance, split from
+ *  {@link DebugTheme} because only some features draw a line at all — text
+ *  panels and filled origin dots take color and nothing else. */
+interface DebugStrokes {
+    hitbox: DebugStroke;
+    bounds: DebugStroke;
+    handle: DebugStroke;
+    /** Rejected snap candidates only; accepted ones paint as a filled dot. */
+    snap: DebugStroke;
+}
 type HandleKind = 'corner' | 'rotation' | 'anchor';
 type HitShape = {
     kind: 'rect';
@@ -127,4 +146,4 @@ interface DebugSink {
     clearSnap(): void;
 }
 
-export type { DebugSink as D, HandleKind as H, RecordedBounds as R, DebugConfig as a, DebugSnapshot as b, DebugTheme as c, DebugFeature as d, HitShape as e, RecordedHandle as f, RecordedHitbox as g, RecordedLayer as h, RecordedOrigin as i, RecordedSnap as j };
+export type { DebugSink as D, HandleKind as H, RecordedBounds as R, DebugConfig as a, DebugSnapshot as b, DebugStrokes as c, DebugTheme as d, DebugFeature as e, DebugStroke as f, HitShape as g, RecordedHandle as h, RecordedHitbox as i, RecordedLayer as j, RecordedOrigin as k, RecordedSnap as l };

package/dist/{types-DUpI7Apc.d.ts → types-Kh_osAq9.d.ts}

@@ -7,7 +7,7 @@ import { P as Path } from './path-B6MMiodD.js';
  * shape used by `composeRectPose` and the `unionBounds` helper. Rotation is
  * in radians, pivoted on the unrotated AABB center; absent === 0. Kit-side
  * code that consumes rotation already reads `pose.rotation ?? 0`
- * (`SceneCanvas.defaultDrawOne`, `rotate/handle.ts`, `pathInWorld.ts`), so
+ * (`wrapNodeOutput`, `rotate/handle.ts`, `pathInWorld.ts`), so
  * the slot exists on every default scene whether or not the consumer
  * populates it.
  */
@@ -212,6 +212,13 @@ interface Scene<TData, TLayer extends string, TPose = RectPose> {
     childrenOf(id: NodeId): readonly NodeId[];
     ancestorsOf(id: NodeId): readonly NodeId[];
     renderOrder(): Iterable<NodeId>;
+    /** The same layer-major sequence as {@link Scene.renderOrder}, as the nodes
+     *  themselves. Prefer this wherever the ids are only going to be resolved
+     *  back to nodes: the traversal already holds them, and re-looking each one
+     *  up was ~40% of the area hit-test's per-node cost. Cached until a
+     *  structural edit, so repeat calls hand back the same array — a snapshot,
+     *  not a live view, and not yours to mutate. */
+    renderOrderNodes(): readonly Node<TData, TLayer, TPose>[];
     add(spec: AddNodeSpec<TData, TLayer, TPose>): NodeId;
     /** Delete `id` **and its entire subtree** — every descendant is removed in
      *  the same operation. Recorded as one undoable step; `undo()` restores the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Domain-agnostic 2D scene graph primitives for React: viewport math, drag/resize/insert/clone interactions, layered canvas rendering.",
   "license": "MIT",
   "author": "orochi235",
@@ -74,11 +74,11 @@
     "react": ">=18"
   },
   "dependencies": {
-    "@weasel-js/font": "1.0.0",
-    "@weasel-js/geom": "1.0.0",
-    "@weasel-js/gestures": "1.0.0",
-    "@weasel-js/history": "1.0.0",
-    "@weasel-js/modes": "1.0.0",
+    "@weasel-js/font": "1.0.2",
+    "@weasel-js/geom": "1.0.2",
+    "@weasel-js/gestures": "1.0.2",
+    "@weasel-js/history": "1.0.2",
+    "@weasel-js/modes": "1.0.2",
     "earcut": "2.2.4",
     "polygon-clipping": "^0.15.7"
   },